= 3:\n print(\"Cubic, F-centred cell\")\n\n if ntwo == 7: # Case (7) !Hexagonal n-2foldaxes=7\n hexap = False\n hexac = False\n\n mv = mt.mod(twofold['dv'])\n order = np.argsort(mv)\n twofold['sigma'] = twofold['sigma'][order]\n twofold['uvw'] = twofold['uvw'][order]\n twofold['hkl'] = twofold['hkl'][order]\n twofold['dv'] = twofold['dv'][order]\n twofold['rv'] = twofold['rv'][order]\n mv = mt.mod(twofold['dv'])\n\n # Search tha a-b plane\n for i, j in combinations(range(ntwo), 2):\n vi = twofold['dv'][i]\n vj = twofold['dv'][j]\n aij = mt.angle_between_vectors(vi, vj)\n if abs(aij - (2 * np.pi / 3.0)) < twofold['toll']:\n if (abs(mv[i] - mv[j]) < tola):\n v1 = vi\n v2 = vj\n v1_i, v2_i = i, j\n hexap = True\n break\n\n\n # then ! Search the c-axis, it should be also\n # a two-fold axis! because Op(6).Op(6).Op(6)=Op(2)\n if hexap:\n for i in range(ntwo):\n vi = twofold['dv'][i]\n aij = mt.angle_between_vectors(v1, vi)\n aik = mt.angle_between_vectors(v2, vi)\n if check90(aij) and check90(aik):\n v3 = vi\n v3_i = i\n hexac = True\n break\n else:\n ok = False\n if verbose:\n print('no axes 90 to hexagonal')\n if hexac:\n tr = np.array([twofold['uvw'][v1_i],\n twofold['uvw'][v2_i],\n twofold['uvw'][v3_i]])\n\n namina = int(nl.det(tr))\n if (namina < 0):\n tr[2] *= -1\n v3 *= -1\n namina *= -1\n if namina == 1:\n print(\"Hexagonal, Primitive cell\")\n elif namina > 1:\n print(\"Hexagonal, centred cell? possible mistake\")\n else:\n print('azzo', namina)\n else:\n ok = False\n print(\"The c-axis of a hexagonal cell was not found!\")\n return\n\n if ntwo == 5: # Case (5) !Tetragonal n-2foldaxes=5\n ab = []\n inp = np.zeros(5)\n mv = mt.mod(twofold['dv']) # modulus twofold vector\n\n for i, j in combinations(range(ntwo), 2):\n vi = twofold['dv'][i]\n vj = twofold['dv'][j]\n m = mt.angle_between_vectors(vi, vj)\n c45 = abs(m - (np.pi * 0.25)) < twofold['toll']\n c135 = abs(m - (np.pi * 0.75)) < twofold['toll']\n if c45 or c135:\n inp[i] = 1\n inp[j] = 1\n ab.append([i, j][np.argmin(mv[[i, j]])])\n ab = list(set(ab))\n if len(ab) < 2:\n ok = False\n if verbose:\n print(\"Basis vectors a-b not found!\")\n return\n # !Determination of the c-axis\n # (that making 90 degree with all the others)\n naminc = np.argmin(inp)\n # !The two axes forming a,b are those of indices ab(1) and ab(2)\n namina = ab[0]\n naminb = ab[1]\n\n tr[0] = twofold['uvw'][namina]\n tr[1] = twofold['uvw'][naminb]\n tr[2] = twofold['uvw'][naminc]\n v1 = twofold['dv'][namina]\n v2 = twofold['dv'][naminb]\n v3 = twofold['dv'][naminc]\n\n namina = nl.det(tr)\n if (namina < 0):\n tr[2] = -tr[2]\n v3 = -v3\n namina = -namina\n\n if namina == 1:\n print(\"Tetragonal, Primitive cell\")\n elif namina == 2:\n print(\"Tetragonal, I-centred cell\")\n else:\n print(\"Error in tetragonal cell\")\n ok = False\n\n if ntwo == 3: # Case (3) !Orthorhombic/Trigonal n-2foldaxes=3\n u = mt.mod(twofold['dv'])\n a_i, b_i, c_i = np.argsort(u)\n tr[0, :] = twofold['uvw'][a_i]\n tr[1, :] = twofold['uvw'][b_i]\n tr[2, :] = twofold['uvw'][c_i]\n\n v1 = twofold['dv'][a_i]\n v2 = twofold['dv'][b_i]\n v3 = twofold['dv'][c_i]\n\n ang = np.array([mt.angle_between_vectors(v3, v2),\n mt.angle_between_vectors(v1, v3),\n mt.angle_between_vectors(v1, v2)])\n\n # Check the system by verifying that the two-fold axes\n # form 90 (orthorhombic)\n if all([check90(i) for i in ang]): # if !orthorhombic\n namina = nl.det(tr)\n if namina < 0:\n tr[2, :] *= -1\n v3 *= -1\n namina *= -1\n\n if namina == 1:\n print(\"Orthorhombic, Primitive cell\")\n elif namina == 2:\n vecs = [[0, 1, 1], [1, 1, 1], [1, 1, 0], [1, 0, 1]]\n for rw_i, rw in enumerate(vecs):\n if not(mt.coprime(np.dot(rw, tr))):\n orthoType = rw_i\n break\n message = [\"Orthorhombic, A-centred cell\",\n \"Orthorhombic, I-centred cell\",\n \"Orthorhombic, C-centred cell\",\n \"Orthorhombic, B-centred cell\"]\n print(message[orthoType])\n if namina >= 3:\n print(\"Orthorhombic, F-centred cell\")\n\n else: # !Rhombohedral/Trigonal\n # In the Trigonal system the two-fold axes are in the plane\n # the three-fold axis, and valid a,b, vectors can be chosen\n # among any two two-fold axes forming an angle of 120 degrees\n # verify that 1 and 2 form 120 \n if any(abs(ang - (2 * np.pi / 3)) < twofold['toll']): # search 120\n res = np.argmin(abs(ang - (2 * np.pi / 3)))\n if res == 0:\n v1, v2, v3 = v2, v3, v1\n tr = tr[[1, 2, 0]]\n elif res == 1:\n v1, v2, v3 = v1, v3, v2\n tr = tr[[0, 2, 1]]\n\n elif any(abs(ang - (np.pi / 3)) < twofold['toll']): # search 60\n res = np.argmin(abs(ang - (np.pi / 3)))\n if res == 0:\n v1, v2, v3 = v2, -v3, v1\n tr = tr[[1, 2, 0]]\n elif res == 1:\n v1, v2, v3 = v1, -v3, v2\n tr = tr[[0, 2, 1]]\n else:\n v2 = -v2\n tr[1] = -tr[1]\n else:\n if verbose:\n print(\"Trigonal/Rhombohedral test failed! \\\n \\nSupply only one two-fold axis\")\n ok = False\n return\n\n ok = False\n for uvw in nestedLoop(range(-3, 4), range(-3, 4), range(0, 4)):\n if not(mt.coprime(uvw)):\n continue\n vec = np.dot(d_base, uvw)\n ang1 = mt.angle_between_vectors(vec, v1)\n ang2 = mt.angle_between_vectors(vec, v2)\n if check90(ang1) and check90(ang2):\n tr[2, :] = uvw\n ok = True\n break\n if ok:\n namina = np.round(nl.det(tr), 4)\n if namina < 0:\n tr[2, :] *= -1\n namina *= -1\n v3 = np.dot(d_base, tr[2])\n if namina == 1:\n print(\"Rhombohedral Primitive hexagonal cell\")\n\n elif namina == 3:\n rw = np.dot([2, 1, 1], tr)\n if not(mt.coprime(rw)):\n print(\"Rhombohedral, obverse setting cell\")\n else:\n print(\"Rhombohedral, reverse setting cell\")\n else:\n print(\"Trigonal/Rhombohedral test failed!\")\n print(\" Supply only one two-fold axis\")\n\n if ntwo == 1: # Case (3) !Monoclinic n-2foldaxes=1\n v2 = twofold['dv'][0]\n tr[1] = twofold['uvw'][0]\n row = []\n for rw in nestedLoop(range(-3, 4), range(-3, 4), range(0, 4)):\n if all(np.array(rw) == 0):\n continue\n if not(mt.coprime(rw)):\n continue\n vec = np.dot(d_base, rw)\n if check90(mt.angle_between_vectors(v2, vec)):\n if any([colinear(rw, i) for i in row]):\n continue\n else:\n row.append(np.array(rw))\n\n\n row_mod = np.array([mt.mod(np.dot(d_base, i)) for i in row])\n rms = np.argsort(row_mod)\n tr[0] = row[rms[0]]\n v1 = np.dot(d_base, tr[0, :])\n tr[2] = row[rms[1]]\n v3 = np.dot(d_base, tr[2, :])\n\n # Test rightness\n if nl.det(tr) < 0:\n tr[1, :] = -tr[1, :]\n v2 = -v2\n\n # Test if beta is lower than 90 in such a case invert c and b\n if mt.angle_between_vectors(v1, v3) < (np.pi / 2): # !angle beta < 90\n tr[0, :] = -tr[0, :]\n v1 = -v1\n tr[2, :] = -tr[2, :]\n v2 = -v2\n\n namina = nl.det(tr)\n if namina == 1:\n print(\"Monoclinic, Primitive cell\")\n if namina == 2:\n if not(mt.coprime(np.dot([1, 1, 0], tr))):\n print(\"Monoclinic, C-centred cell\")\n if not(mt.coprime(np.dot([0, 1, 1], tr))):\n print(\"Monoclinic, A-centred cell\")\n\n if ntwo not in [1, 3, 5, 7, 9]:\n print(\"Wrong number of two-fold axes! \", ntwo)\n ok = False\n return\n # Calculation of the new cell\n alpha = np.degrees(mt.angle_between_vectors(v2, v3))\n beta = np.degrees(mt.angle_between_vectors(v1, v3))\n gamma = np.degrees(mt.angle_between_vectors(v1, v2))\n a = mt.mod(v1)\n b = mt.mod(v2)\n c = mt.mod(v3)\n print(f'a={round(a,2)}, b={round(b,2)}, c={round(c,2)},',\n f'alpha={round(alpha,2)}, beta={round(beta,2)},',\n f'gamma={round(gamma,2)}')\n ok = True\n return [a, b, c, alpha, beta, gamma], tr","def __init__(self, m,r,v):\n self.m = m\n self.r = r\n self.v = v\n self.rv = np.array([r,0,0,v])","def _reset_solution(self, firm_size):\n x_lower, x_upper = self.model.workers.lower, self.model.workers.upper\n y_upper = self.model.firms.upper\n initial_V = np.array([y_upper, firm_size])\n\n if self.model.assortativity == 'positive':\n self.ivp.set_initial_value(initial_V, x_upper)\n wage = self.evaluate_wage(x_upper, initial_V)\n profit = self.evaluate_profit(x_upper, initial_V)\n self._solution = np.hstack((x_upper, initial_V, wage, profit))\n else:\n self.ivp.set_initial_value(initial_V, x_lower)\n wage = self.evaluate_wage(x_lower, initial_V)\n profit = self.evaluate_profit(x_lower, initial_V)\n self._solution = np.hstack((x_lower, initial_V, wage, profit))","def testNonVarying(self):\n photoCalib = lsst.afw.image.PhotoCalib(self.calibration)\n self._testPhotoCalibCenter(photoCalib, 0)\n\n self.assertEqual(1, photoCalib.instFluxToMaggies(self.instFlux, self.pointXShift))\n self.assertEqual(0, photoCalib.instFluxToMagnitude(self.instFlux, self.pointXShift))\n result = photoCalib.instFluxToMaggies(self.instFlux, self.instFluxErr)\n self.assertEqual(1, result.value)\n\n photoCalib = lsst.afw.image.PhotoCalib(self.calibration, self.calibrationErr)\n self._testPhotoCalibCenter(photoCalib, self.calibrationErr)\n\n # constant, with a bbox\n photoCalib = lsst.afw.image.PhotoCalib(self.calibration, bbox=self.bbox)\n self._testPhotoCalibCenter(photoCalib, 0)","def test_zPartialCurrents(self):\n # node 15 (ring=2, position=3), axial=3, group=3, j=1 (z-plus)\n iNode, iz, ig, j = 14, 2, 2, 0\n self.assertAlmostEqual(\n self.nhf.partialCurrentsZ[iNode, iz, j, ig] / 1.6928521e06, 1.0\n )","def _get_kriging_matrix(self, n, exact_values):\n\n xyz = np.concatenate((self.X_ADJUSTED[:, np.newaxis],\n self.Y_ADJUSTED[:, np.newaxis],\n self.Z_ADJUSTED[:, np.newaxis]), axis=1)\n d = cdist(xyz, xyz, 'euclidean')\n a = np.zeros((n+1, n+1))\n a[:n, :n] = - self.variogram_function(self.variogram_model_parameters, d)\n if not exact_values:\n if self.variogram_model == 'linear':\n np.fill_diagonal(a, self.variogram_model_parameters[1])\n elif self.variogram_model != 'custom':\n np.fill_diagonal(a, self.variogram_model_parameters[2])\n else :\n np.fill_diagonal(a, 0.)\n a[n, :-1] = 1.0\n a[:-1, n] = 1.0\n\n return a"],"string":"[\n \"def calculate():\\n global v, vNew, n, stepsToToleranceArray\\n stepsToToleranceArray = []\\n for n in nArray:\\n print('Currently working with n = ', n)\\n initiateVMatrixes()\\n step = 0\\n toleranceAcqurired = False\\n while not toleranceAcqurired:\\n step+=1\\n relax_checker()\\n # Controll accuracy\\n toleranceAcqurired = True # run through v and set false if not acquired\\n for i in range(1,n):\\n for j in range(1,n):\\n if np.abs( (v[i,j]-vExact[i,j])/vExact[i,j] ) > tolerance:\\n toleranceAcqurired = False\\n if toleranceAcqurired:\\n stepsToToleranceArray.append(step)\\n if n in [5,10]: print('n =', n, 'steps =', step)\",\n \"def solve_VFI(self):\\r\\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \\r\\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\\r\\n tol = self.tol ; Niter = self.Niter ; R = self.R\\r\\n beta = self.beta ; Pi = self.Pi\\r\\n \\r\\n V0 = np.zeros((dimA,dimC,dimW))\\r\\n V1 = np.zeros((dimA,dimC,dimW))\\r\\n Pol = np.zeros((dimA,dimC,dimW))\\r\\n U = np.zeros((dimA,dimC,dimW))\\r\\n \\r\\n t0 = time()\\r\\n diff = 1 ; niter = 0\\r\\n \\r\\n while diff > tol:\\r\\n niter += 1\\r\\n # Value update step\\r\\n for ia in range(dimA):\\r\\n for ic in range(dimC):\\r\\n for iw in range(dimW):\\r\\n c = W[iw] + R*A[ia] - A\\r\\n x = C[ic]\\r\\n \\r\\n c[c < 0] = np.nan \\r\\n if x < 0:\\r\\n x = np.nan\\r\\n \\r\\n u = self.u(c,x) \\r\\n U[:,ic,iw] = u \\r\\n \\r\\n Objective = U + beta * V0 @ Pi.T\\r\\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\\r\\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\\r\\n \\r\\n # Evaluate distance between the value functions\\r\\n diff = np.max(np.max(np.abs(V1 - V0))) \\r\\n V0[:] = V1\\r\\n \\r\\n # Break the while loop if too many iterations\\r\\n #print(\\\"The current error is \\\"+str(diff))\\r\\n if niter > Niter:\\r\\n print('Ops, no convergence')\\r\\n break\\r\\n \\r\\n t1 = time()\\r\\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\\r\\n \\r\\n self.V1 = V1 ; self.Pol = Pol\",\n \"def test_vmec_objective(self):\\n self.set_up()\\n self.assertRaises(ValueError,\\n self.vmecOptimization.vmec_objective,\\n which_objective='volumee')\\n boundary = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new = np.hstack((boundary,boundary))\\n self.assertRaises(ValueError,\\n self.vmecOptimization.vmec_objective,\\n boundary=boundary_new)\\n\\n boundary_new = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new[0] = 1.1*boundary_new[0]\\n volume1 = self.vmecOptimization.vmec_objective(\\n which_objective='volume',boundary=boundary_new)\\n self.assertAlmostEqual(self.vmecOptimization.boundary_opt[0],\\n boundary_new[0])\\n boundary_old = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new[0] = 1.1*boundary_new[0]\\n volume1 = self.vmecOptimization.vmec_objective(\\n which_objective='volume',boundary=boundary_new,update=False)\\n self.assertAlmostEqual(self.vmecOptimization.boundary_opt[0],\\n boundary_old[0])\\n self.tear_down()\",\n \"def test_evaluate_vmec(self):\\n self.set_up()\\n boundary = self.vmecOptimization.boundary_opt\\n boundary[0] = 1.1*boundary[0]\\n exit_code, vmecOutput_new = \\\\\\n self.vmecOptimization.evaluate_vmec(boundary=boundary)\\n self.assertEqual(exit_code,0) \\n self.assertTrue(np.array_equal(boundary,\\n self.vmecOptimization.boundary_opt))\\n self.assertEqual(boundary[0],vmecOutput_new.rmnc[-1,0])\\n \\n boundary_new = np.copy(boundary)\\n boundary_new[1] = 1.1*boundary_new[1]\\n exit_code, vmecOutput_new = \\\\\\n self.vmecOptimization.evaluate_vmec(boundary=boundary_new,\\n update=False)\\n self.assertEqual(exit_code,0) \\n self.assertTrue(np.array_equal(boundary,\\n self.vmecOptimization.boundary_opt))\\n self.assertEqual(boundary_new[0],vmecOutput_new.rmnc[-1,0])\\n\\n pres = vmecOutput_new.pres+1\\n exit_code, vmecOutput_new = \\\\\\n self.vmecOptimization.evaluate_vmec(pres=pres)\\n self.assertEqual(exit_code,0) \\n self.assertTrue(np.allclose(pres,vmecOutput_new.pres))\\n \\n It = vmecOutput_new.current()+1\\n exit_code, vmecOutput_new = \\\\\\n self.vmecOptimization.evaluate_vmec(It=It)\\n self.assertEqual(exit_code,0) \\n self.assertTrue(np.allclose(It,vmecOutput_new.current()))\\n self.tear_down()\",\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 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 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 v(resistances, r_i, applied_voltages, **kwargs):\\n if r_i.word_line > 0 or r_i.bit_line > 0:\\n g = fill.g(resistances, r_i)\\n i = fill.i(applied_voltages, resistances, r_i)\\n\\n utils.message('Started solving for v.', **kwargs)\\n v_matrix = linalg.spsolve(g.tocsc(), i)\\n utils.message('Solved for v.', **kwargs)\\n\\n # if `num_examples == 1`, it can result in 1D array.\\n if v_matrix.ndim == 1:\\n v_matrix = v_matrix.reshape(v_matrix.shape[0], 1)\\n\\n # if one of the interconnect resistances is zero, only half of the\\n # matrix_v had to be solved. The other half can be filled without\\n # solving because the node voltages are known.\\n if r_i.word_line == 0:\\n new_v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n new_v_matrix[:resistances.size, ] = np.repeat(\\n applied_voltages, resistances.shape[1], axis=0)\\n new_v_matrix[resistances.size:, ] = v_matrix\\n v_matrix = new_v_matrix\\n if r_i.bit_line == 0:\\n new_v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n new_v_matrix[:resistances.size, ] = v_matrix\\n v_matrix = new_v_matrix\\n else:\\n # if both interconnect resistances are zero, all node voltages are\\n # known.\\n v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n v_matrix[:resistances.size, ] = np.repeat(\\n applied_voltages, resistances.shape[1], axis=0)\\n\\n return v_matrix\",\n \"def solve_prep(self):\\n\\n par = self.par\\n sol = self.sol\\n\\n # a. retirement\\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\\n\\n # b. working\\n if par.solmethod == 'G2EGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n \\n elif par.solmethod == 'NEGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((0,0,0))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((0,0,0))\\n \\n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\",\n \"def test_call_vmec(self):\\n self.set_up()\\n inputObject = self.vmecOptimization.vmecInputObject\\n inputObject_new = VmecInput(self.input_filename_intersecting)\\n error_code = self.vmecOptimization.call_vmec(inputObject_new)\\n self.assertEqual(error_code,16)\\n \\n # To do : add test for ill-conditioned Jacobian\\n# rbc = np.copy(inputObject.rbc)\\n# zbs = np.copy(inputObject.zbs)\\n# inputObject.rbc[1::] = 1e-4*inputObject.rbc[1::]\\n# inputObject.zbs = inputObject.zbs\\n# error_code = self.vmecOptimization.call_vmec(inputObject)\\n# self.assertEqual(error_code,16)\\n # Reset boundary\\n# inputObject.rbc = rbc\\n# inputObject.zbs = zbs\\n \\n inputObject = VmecInput(self.input_filename)\\n error_code = self.vmecOptimization.call_vmec(inputObject)\\n self.assertEqual(error_code,0)\\n self.tear_down()\",\n \"def _solve_explicit(self, initial_conditions):\\n coeff = self.a ** 2 * self.tau / self.h ** 2\\n current_solution = initial_conditions\\n next_solution = np.empty_like(current_solution)\\n solutions = []\\n\\n for t in self.t_grid:\\n next_solution[1:-1] = (\\n current_solution[1:-1]\\n + (current_solution[:-2] - 2 * current_solution[1:-1] + current_solution[2:]) * coeff\\n ) + self.rhs(self.x_grid[1:-1], t) * self.tau\\n\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n next_solution[0] = self.left_bc(t)\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n next_solution[0] = (\\n 4 * next_solution[1]\\n - next_solution[2]\\n - 2 * self.h * self.left_bc(t)\\n ) / 3.0\\n\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n next_solution[-1] = self.right_bc(t)\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n next_solution[-1] = (\\n 4 * next_solution[-2]\\n - next_solution[-3]\\n + 2 * self.h * self.right_bc(t)\\n ) / 3.0\\n if self.mode == \\\"VISUALIZATION\\\":\\n solutions.append((t, next_solution.copy()))\\n current_solution = next_solution\\n if self.mode == \\\"TEST\\\":\\n # print(\\\"Result: \\\", current_solution.tolist())\\n # print(\\\"Right answer: \\\", self.anl_solution.tolist())\\n self._norma(current_solution)\\n elif self.mode == \\\"VISUALIZATION\\\":\\n return solutions\",\n \"def find_potential(n=10,nwalks=200):\\n \\n boundary = np.zeros((n+1, n+1)) # Store boundary potentials\\n v = np.zeros((n+1, n+1)) # Store potential for all positions\\n \\n # Set the boundary conditions\\n for i in range(1,n):\\n boundary[0,i] = 10\\n boundary[n,i] = 10\\n boundary[i,0] = 5\\n boundary[i,n] = 5\\n # Set the the boundary position that maximizes the potential at [3, 5] to 20\\n boundary[3,0] = boundary[4,0] = boundary[5,0] = boundary[6,0] = boundary[7,0] = 20\\n #boundary[0,3] = boundary[0,4] = boundary[0,5] = boundary[0,6] = boundary[0,7] = 20\\n \\n v = np.copy(boundary) # Store potential for all positions\\n\\n # Compute Greens function for each position\\n for x in range(1,n):\\n for y in range(1,n):\\n position = [x, y] # Position to compute Greens function for\\n Greens_func = Greens_function_approxRW(n=n, nwalks=nwalks, start_position=position) # The Greens function\\n \\n # Find potential at current position\\n v_pos = potential_from_Greens(boundary, n=n, G=Greens_func, nwalks=nwalks)\\n v[position[1], position[0]] = v_pos\\n \\n # v is now computed for all locations and can be plotted\\n fig = plt.figure()\\n plt.title('Maximized potential for [3,5]', fontsize = 18)\\n im = plt.imshow(v, cmap=None, interpolation='nearest')\\n cb = fig.colorbar(im)\\n cb.ax.tick_params(labelsize=14)\\n plt.show()\",\n \"def reconstruct_solution(spikes,sol,uval,twin,ics,tau,variable,**kwargs):\\n\\n # Model parameters\\n pars = {'dt' : 1e-3}\\n pars = gu.varargin(pars,**kwargs)\\n\\n # Generate time vector\\n time = np.arange(twin[0],twin[-1],pars['dt'])\\n time = np.sort(np.r_[time,spikes])\\n # Generate spike vector\\n tspk = np.copy(time)\\n for i in range(1,len(spikes)):\\n tspk[np.where(np.logical_and(time>=spikes[i-1],time<spikes[i]))[0]] = spikes[i-1]\\n tspk[np.where(time >= spikes[len(spikes)-1])[0]] = spikes[len(spikes)-1]\\n tspk[np.where(time < spikes[0])[0]] = 0\\n # Generate general solution vector\\n vsol = np.ones(time.size)\\n if (variable=='x') and isscalar(uval):\\n uval = uval * np.ones(sol.size)\\n if variable=='x':\\n for i in range(1, len(spikes)):\\n # x must be given at x(t_i^+) according to xsol\\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]*(1-uval[i-1])\\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]*(1-uval[len(spikes)-1])\\n else:\\n for i in range(1, len(spikes)):\\n vsol[np.where(np.logical_and(time >= spikes[i - 1], time < spikes[i]))[0]] = sol[i-1]\\n vsol[np.where(time >= spikes[len(spikes) - 1])[0]] = sol[len(spikes) - 1]\\n vsol[np.where(time < spikes[0])[0]] = ics\\n # Compute effective solution\\n solution = np.zeros((2, time.size))\\n solution[0] = time\\n\\n if variable=='x':\\n # Assumes that the first ICs is x(0)\\n solution[1] = xsol(vsol,time-tspk,tau)\\n else:\\n solution[1] = usol(vsol,time-tspk,tau)\\n\\n return solution\",\n \"def _update_initial_guess(self, lower, upper):\\n err_mesg = 'Upper and lower bounds are identical: check solver tols!'\\n assert (upper - lower) / upper > np.finfo('float').eps, err_mesg\\n guess = 0.5 * (lower + upper)\\n return guess\",\n \"def solve(self):\\n for x in range(9):\\n for y in range(9):\\n if self.arr[x][y] == 0:\\n for value in range(1,10):\\n if self.is_possible_value(x,y,value):\\n self.arr[x][y] = value\\n self.solve()\\n self.arr[x][y] = 0 \\n return\\n print(np.matrix(self.arr))\",\n \"def test_velocity_vs_current(self):\\n t, x_n, x_p = self.t, self.x_n, self.x_p\\n\\n beta_n = self.model.param.beta_n\\n beta_n = self.param.evaluate(beta_n)\\n beta_p = self.model.param.beta_p\\n beta_p = self.param.evaluate(beta_p)\\n\\n np.testing.assert_array_almost_equal(\\n self.v_box(t, x_n), beta_n * self.i_e(t, x_n)\\n )\\n np.testing.assert_array_almost_equal(\\n self.v_box(t, x_p), beta_p * self.i_e(t, x_p)\\n )\",\n \"def _check_init_solution(self):\\r\\n B = np.array([self._A[:, j] for j in self._basic_vars]).transpose()\\r\\n self._B_inv = np.linalg.inv(B)\\r\\n x_B = self._B_inv @ self._b\\r\\n for x in x_B:\\r\\n if x < 0:\\r\\n raise AssertionError(\\\"Initial solution is not feasible!\\\")\",\n \"def test_update_boundary_opt(self):\\n self.set_up()\\n boundary_opt_new = np.hstack((self.vmecOptimization.boundary_opt,\\n self.vmecOptimization.boundary_opt))\\n self.assertRaises(ValueError,self.vmecOptimization.update_boundary_opt,\\n boundary_opt_new)\\n boundary_opt_new = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_opt_new[0] = 1\\n self.vmecOptimization.update_boundary_opt(boundary_opt_new)\\n self.assertEqual(1,self.vmecOptimization.boundary_opt[0])\\n self.tear_down()\",\n \"def test0(self):\\r\\n lr = constant(0.011)\\r\\n v = matrix()\\r\\n v.name = 'v'\\r\\n gv = fill(v / v, 1.0) / v - (fill(v / v, 1.0) * v) / (v * v)\\r\\n fn_py = inplace_func([v], gv)\\r\\n fn_c_or_py = inplace_func([v], gv)\\r\\n\\r\\n a = rand(5, 2).astype(config.floatX)\\r\\n self.assertTrue(numpy.all(fn_py(a) == fn_c_or_py(a)))\",\n \"def calibration(N,kb,T,Ekinv,V):\\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\\n \\n if lamb < 0.9999:\\n V = lamb*V\\n elif lamb>1.0001:\\n V = lamb*V\\n \\n return V\",\n \"def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\\n mask, max_iter=100, init=None,\\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\\n\\n # shape of image box\\n \\n alpha = 1\\n\\n flat_mask = mask.ravel()\\n volume_shape = mask.shape\\n H_size = len(Hurst_init)\\n\\n if lipschitz_constant == 0:\\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\\n\\n #init[\\\"z\\\"] = Hurst_init.copy()\\n #init[\\\"t\\\"] = 1\\n #ini[\\\"stepsize\\\"] = 1 / lipschitz_constant\\n\\n def total_energy(x):\\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\\n\\n def unmaskvec(w):\\n return _unmask(w, mask)\\n\\n def maskvec(w):\\n return w[flat_mask]\\n\\n def f1_grad(x):\\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\\n\\n def f2_prox(w, stepsize, dgap_tol, init):\\n out, info = _prox_tvl1(unmaskvec(w),\\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\\n dgap_tol=dgap_tol, init=unmaskvec(init),\\n max_iter=prox_max_iter, fista = False,\\n verbose=verbose)\\n #pdb.set_trace()\\n return maskvec(out.ravel()), info\\n\\n w, obj, init = mfista(\\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\\n max_iter=max_iter, callback=None)\\n \\n return w, obj, init\",\n \"def test_input_objective(self):\\n self.set_up()\\n self.assertRaises(ValueError,\\n self.vmecOptimization.input_objective,\\n which_objective='volumee')\\n boundary = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new = np.hstack((boundary,boundary))\\n self.assertRaises(ValueError,\\n self.vmecOptimization.input_objective,\\n boundary=boundary_new)\\n volume1 = self.vmecOptimization.input_objective(\\n which_objective='volume')\\n volume2 = self.vmecOptimization.vmec_objective(\\n which_objective='volume') \\n self.assertAlmostEqual(volume1,volume2)\\n \\n boundary_new = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new[0] = 1.1*boundary_new[0]\\n volume1 = self.vmecOptimization.input_objective(\\n which_objective='volume',boundary=boundary_new)\\n self.assertAlmostEqual(self.vmecOptimization.boundary_opt[0],\\n boundary_new[0])\\n boundary_old = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new[0] = 1.1*boundary_new[0]\\n volume1 = self.vmecOptimization.input_objective(\\n which_objective='volume',boundary=boundary_new,update=False)\\n self.assertAlmostEqual(self.vmecOptimization.boundary_opt[0],\\n boundary_old[0])\\n self.tear_down()\",\n \"def update_speed_input_step(self,curr_v):\\n \\n # update speed inputs \\n self.speed_inputs_east*=0\\n self.speed_inputs_west*=0\\n self.speed_inputs_north*=0\\n self.speed_inputs_south*=0\\n\\n if self.use_eight_directions is True: \\n self.speed_inputs_north_east*=0\\n self.speed_inputs_north_west*=0\\n self.speed_inputs_south_east*=0\\n self.speed_inputs_south_west*=0\\n \\n #speed_values=self.rr[:self.N_e,0] \\n speed_values=np.ones((self.N_e,1))\\n\\n if curr_v[0]>0:\\n \\n # north-east\\n if self.use_eight_directions is True and curr_v[1]>0:\\n self.speed_inputs_north_east=speed_values \\n \\n # south-east \\n elif self.use_eight_directions is True and curr_v[1]<0:\\n self.speed_inputs_south_east=speed_values\\n \\n #east \\n else:\\n self.speed_inputs_east=speed_values\\n\\n\\n elif curr_v[0]<0:\\n\\n # north-west \\n if self.use_eight_directions is True and curr_v[1]>0:\\n self.speed_inputs_north_west=speed_values\\n\\n # south-west \\n elif self.use_eight_directions is True and curr_v[1]<0:\\n self.speed_inputs_south_west=speed_values\\n \\n # west \\n else:\\n self.speed_inputs_west=speed_values\\n\\n else: \\n # north\\n if curr_v[1]>0:\\n self.speed_inputs_north=speed_values\\n\\n # south\\n elif curr_v[1]<0:\\n self.speed_inputs_south=speed_values\",\n \"def __init__(self, model, innerTol, misfit_only=False):\\n self.model = model\\n self.tol = innerTol\\n self.gauss_newton_approx = self.model.gauss_newton_approx \\n self.misfit_only=misfit_only\\n self.ncalls = 0\\n \\n self.rhs_fwd = model.generate_vector(STATE)\\n self.rhs_adj = model.generate_vector(ADJOINT)\\n self.rhs_adj2 = model.generate_vector(ADJOINT)\\n self.uhat = model.generate_vector(STATE)\\n self.phat = model.generate_vector(ADJOINT)\\n self.yhelp = model.generate_vector(PARAMETER)\",\n \"def SOR_Solve_Opt(A,b,tol=1.0e-6,max_iterations=100,LOUD=False):\\n [Nrow, Ncol] = A.shape\\n assert Nrow == Ncol\\n N = Nrow\\n converged = False\\n iteration = 1\\n omega = 1\\n l = 5\\n p = 2\\n x = np.random.rand(N) #random initial guess \\n x_new = np.zeros(N)\\n while not(converged):\\n x = x_new.copy() #replace old value\\n for row in range(N):\\n x_new[row] = b[row]\\n for column in range(N):\\n if column != row:\\n x_new[row] -= A[row,column]*x_new[column]\\n x_new[row] /= A[row,row]\\n x_new[row] = (1.0-omega) * x[row] + omega*x_new[row]\\n relative_change = np.linalg.norm(x_new-x)/np.linalg.norm(x_new)\\n #record change after iteration k\\n if (l==iteration):\\n dxl = np.linalg.norm(x_new-x)\\n if (l + p == iteration):\\n dxlp = np.linalg.norm(x_new-x)\\n omega = 2.0/(1.0+np.sqrt(1-(dxlp/dxl)**(1.0/p)))\\n if (LOUD):\\n print(\\\"Iteration\\\",iteration,\\\": Relative Change =\\\",relative_change)\\n if (relative_change < tol) or (iteration >= max_iterations):\\n converged = True\\n iteration += 1\\n return x_new\",\n \"def VFI(method) :\\n iteration=0 # Iteration Counter\\n converged = 0 # Convergence Flag|\\n \\n#----- Initial Settings \\n v_update = zeros(n_grid)\\n v_func = empty(n_grid)\\n k_next_vec = empty(n_grid)\\n run_time = empty(2)\\n \\n def obj(k_next) :\\n \\\"\\\"\\\"\\n This function is used in value function iteration.\\n It represents the objective function to be maximized for one node (state) of current capitals.\\n Resulting value is maximized one corresponding to next period's capital as a maximizer. \\n Next period's value is computed by interpolation.\\n \\n Input : k_next (next period's capital)\\n \\n Output : value_vec (maximized value resulting from choosing optimal capital in the next period)\\n \\\"\\\"\\\" \\n \\n if method==1 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*linear_interp(k_grid,v_update,k_next))\\n elif method==2 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*quad_interp(k_grid,v_update,k_next))\\n elif method==3 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*cubic_interp(k_grid,v_update,k_next))\\n \\n return value_vec\\n\\n#----- Value function iteration\\n start = time.time() # start time\\n while converged==0 :\\n index = 0\\n for k_current in k_grid :\\n k_next = fminbound(obj,k_grid[0],k_grid[-1])\\n v_func[index] = (-1) * obj(k_next)\\n k_next_vec[index] = k_next\\n index = index + 1\\n dist = abs(max(v_func - v_update))\\n if dist<tol :\\n converged = 1\\n v_k, g_k = v_func, k_next_vec\\n v_update = v_func\\n print \\\"Iteration : \\\",iteration,\\\"\\\",\\\"Distance : \\\",dist # convergence process\\n iteration = iteration + 1\\n v_func = empty(n_grid) \\n k_next_vec = empty(n_grid)\\n \\n end = time.time() # end time\\n run_time[0],run_time[1] = runtime_cal(start,end) # total running time\\n \\n return v_k, g_k, run_time, iteration\",\n \"def __init__(self, initial, goal=None):\\n \\n #fill the grid with random numbers\\n from random import randint as IA\\n \\n #in switches we must keep track of what numbers are here at the start\\n #to prevent switching them.\\n initialNumber = [[1 for x in range(size)] for y in range(size)]\\n \\n for i in range(size):\\n for j in range(size):\\n if(initial[i][j] == 0):\\n x = IA(1,9)\\n initialNumber[i][j] = 0\\n while(not isLegalInBox(initial,i,j,x)):\\n x = IA(1,9)\\n initial[i][j] = x\\n \\n self.initialNumber = initialNumber\\n self.initial = initial\",\n \"def potentialSolver(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 # solve potential\\n for it in np.arange(1,max_it+1):\\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 #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 #check for convergence*/\\n if it%25==0:\\n sum = 0;\\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 R = -self.phi[i][j][k]*(2*dx2+2*dy2+2*dz2) +\\\\\\n 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])\\n\\n sum += R*R;\\n\\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 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 \"def set_voltages(): \\n #0) set parameters\\n from project_parameters import trapFile,multipoleControls,reg,driveFrequency,ax,az,phi,coefs\\n import pickle\\n with open(trapFile,'rb') as f:\\n trap = pickle.load(f)\\n V,X,Y,Z=trap.instance.DC,trap.instance.X,trap.instance.Y,trap.instance.Z\\n tc=trap.configuration\\n C = tc.multipoleControl\\n el = []\\n #1) check if trap_knobs has been run yet, creating multipoleControl and multipoleKernel\\n if tc.trap_knobs != True:\\n return 'WARNING: You must run trap_knobs first!'\\n #2a) determine electrode voltages directly\\n elif multipoleControls: # note plurality to contrast from attribute\\n el = np.dot(C,coefs.T) # these are the electrode voltages\\n #2b) determine electrode volages indirectly\\n else:\\n charge = tc.charge\\n mass = tc.mass\\n V0 = mass*(2*np.pi*frequencyRF)**2/charge\\n U2 = az*V0/8\\n U1 = U2+ax*V0/4\\n U3 = 2*U1*np.tan(2*np.pi*(phi+tc.thetaRF)/180)\\n U1p= np.sqrt(U1**2+U3**2/2)\\n U4 = U1p*tc.Qrf[4]/tc.Qrf[1]\\n U5 = U1p*tc.Qrf[5]/tc.Qrf[1]\\n inp = np.array([E[0], E[1], E[2], U1, U2, U3, U4, U5]).T\\n mCf = tc.multipoleCoefficients[1:9,:]\\n el = np.dot(mCf.T,inp) # these are the electrode voltages\\n el = np.real(el)\\n #3) regularize if set to do so\\n reg = 0\\n if reg: \\n C = el\\n Lambda = np.linalg.lstsq(tc.multipoleKernel,C)\\n Lambda=Lambda[0]\\n el = el-(np.dot(tc.multipoleKernel,Lambda))\\n return el\",\n \"def one_step(self):\\r\\n assert (self.uv_vol is not None)\\r\\n assert (self.guv_vol is not None)\\r\\n assert (self.uv_bound is not None)\\r\\n assert (self.vf_vect_bound is not None)\\r\\n assert (self.vF_vect_vol is not None)\\r\\n # Shape checks\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\\r\\n assert (self.uv_vol.shape == self.guv_vol.shape)\\r\\n assert (self.uv_vol.shape == self.uv_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\\r\\n \\r\\n if self.step == 0:\\r\\n self.check_k_matrix_stability()\\r\\n # print(\\\"Epsilon is :\\\"+str(self.Epsilon))\\r\\n # print(\\\"Beta is :\\\"+str(self.Beta))\\r\\n\\r\\n # Form \\\"Stiffness\\\" matrix:\\r\\n K = self.make_k_matrix()\\r\\n # Form \\\"Force\\\" vector: \\r\\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\\r\\n\\r\\n # print(\\\"FORCE VECTOR:\\\")\\r\\n # print(f)\\r\\n # print(\\\"STIFFNESS MATRIX\\\")\\r\\n # print(K)\\r\\n # print(\\\"UV_VOL\\\")\\r\\n # print(self.uv_vol)\\r\\n # print(\\\"EPSILON * GUV_VOL\\\")\\r\\n # print(self.Epsilon * self.guv_vol)\\r\\n # print(\\\"UV_BOUND * COEFF\\\")\\r\\n # print((self.Epsilon / self.Beta) * self.uv_bound)\\r\\n sol = scipy_sparse_linsolve(K, f)\\r\\n # print(\\\"SOLUTION\\\")\\r\\n # print(sol)\\r\\n return sol\",\n \"def relu(self, v):\\n if v > 0:\\n solution = v\\n else:\\n solution = 0\\n return solution\",\n \"def exactsolution(x, t, u):\\n if 0 <= (x - u*t) and (x - u*t) <= 0.2:\\n temp = 1 - (10 * (x - u*t) -1)**2\\n else:\\n temp = 0\\n return temp\",\n \"def solve(self):\\n\\t\\t# row and column to control the selected corner\\n\\t\\tcurrent_positions = [0, 0]\\n\\t\\tmax_row = self.result_index[self.__ROW_INDEX]-1\\n\\t\\tmax_col = self.result_index[self.__COLUMN_INDEX]-1\\n\\t\\twhile self.matrix[max_row][max_col] != 0:\\n\\t\\t\\tcurrent_row = current_positions[self.__ROW_INDEX]\\n\\t\\t\\tcurrent_column = current_positions[self.__COLUMN_INDEX]\\n\\t\\t\\tmultiplier_selected = self.get_multiplier_with_index(current_row, current_column)\\n\\t\\t\\tactual_weight = self.matrix[current_row][current_column]\\n\\t\\t\\tactual_result_weight = multiplier_selected[1]\\n\\t\\t\\tself.resulting_matrix[current_row][current_column] = actual_weight * actual_result_weight\\n\\t\\t\\tself.matrix[max_row][max_col] -= actual_result_weight\\n\\t\\t\\tself.matrix[current_row][max_col] -= actual_result_weight\\n\\t\\t\\tself.matrix[max_row][current_column] -= actual_result_weight\\n\\t\\t\\tcurrent_positions[multiplier_selected[0]] += 1\",\n \"def test_born_newton(self):\\n\\n n0 = 3.4\\n omega = 2*np.pi*200e12\\n dl = 0.01\\n chi3 = 2.8E-18\\n\\n width = 1\\n L = 5\\n L_chi3 = 4\\n\\n width_voxels = int(width/dl)\\n L_chi3_voxels = int(L_chi3/dl)\\n\\n Nx = int(L/dl)\\n Ny = int(3.5*width/dl)\\n\\n eps_r = np.ones((Nx, Ny))\\n eps_r[:, int(Ny/2-width_voxels/2):int(Ny/2+width_voxels/2)] = np.square(n0)\\n\\n nl_region = np.zeros(eps_r.shape)\\n nl_region[int(Nx/2-L_chi3_voxels/2):int(Nx/2+L_chi3_voxels/2), int(Ny/2-width_voxels/2):int(Ny/2+width_voxels/2)] = 1\\n\\n simulation = Simulation(omega, eps_r, dl, [15, 15], 'Ez')\\n simulation.add_mode(n0, 'x', [17, int(Ny/2)], width_voxels*3)\\n simulation.setup_modes()\\n simulation.add_nl(chi3, nl_region, eps_scale=True, eps_max=np.max(eps_r))\\n\\n srcval_vec = np.logspace(1, 3, 3)\\n pwr_vec = np.array([])\\n T_vec = np.array([])\\n for srcval in srcval_vec:\\n simulation.setup_modes()\\n simulation.src *= srcval\\n\\n # Newton\\n simulation.solve_fields_nl(solver_nl='newton')\\n E_newton = simulation.fields[\\\"Ez\\\"]\\n\\n # Born\\n simulation.solve_fields_nl(solver_nl='born')\\n E_born = simulation.fields[\\\"Ez\\\"]\\n\\n # More solvers (if any) should be added here with corresponding calls to assert_allclose() below\\n\\n assert_allclose(E_newton, E_born, rtol=1e-3)\",\n \"def run_exact(self):\\n self.operator, var_form, opt = self.generate_VQE_args()\\n\\n exact_eigensolver = ExactEigensolver(self.operator, k=1)\\n self.result = exact_eigensolver.run()\\n\\n solution = self.extract_solution(self.result, True)\\n return solution\",\n \"def solve(grid):\\n\\n if is_grid_solved(grid):\\n return grid\\n\\n new_grid = copy.deepcopy(grid)\\n\\n for x_element in range(len(new_grid)):\\n for y_element in range(len(new_grid[x_element])):\\n if new_grid[x_element][y_element] == 0:\\n answers = ExactCover(new_grid, x_element, y_element)\\n for answer in answers:\\n new_grid[x_element][y_element] = answer\\n new_grid = solve(new_grid)\\n if not is_grid_solved(new_grid):\\n new_grid[x_element][y_element] = 0\\n else:\\n break\\n return new_grid\\n\\n return new_grid\",\n \"def bellman_operator(self, v):\\n new_v = np.empty(v.shape)\\n for i in range(self.N):\\n for j in range(self.N):\\n # stay put\\n v1 = self.theta[i] + self.epsilon[j] + self.beta * v[i, j]\\n\\n # new job\\n v2 = (self.theta[i] + self.G_mean + self.beta *\\n np.dot(v[i, :], self.G_probs))\\n\\n # new life\\n v3 = (self.G_mean + self.F_mean + self.beta *\\n np.dot(self.F_probs, np.dot(v, self.G_probs)))\\n new_v[i, j] = max(v1, v2, v3)\\n return new_v\",\n \"def __init__(self, lower_bound, upper_bound):\\n # Todo: implement\\n self.x = np.zeros(np.size(lower_bound))\\n self.v = np.zeros(np.size(lower_bound))\\n self.value = -inf\\n self.evaluated = False\\n i = 0\\n while i < np.size(lower_bound):\\n self.x[i] = random.uniform(lower_bound[i], upper_bound[i])\\n self.v[i] = random.uniform(-(upper_bound[i] - lower_bound[i]), upper_bound[i] - lower_bound[i])\\n i = i + 1\\n self.best_position = self.x\\n self.best_value = -inf\",\n \"def test_initial_guess_and_observables(self):\\n initial_guess = np.zeros(self.ansatz.num_parameters)\\n sampler = Sampler()\\n estimator = Estimator()\\n fidelity_primitive = ComputeUncompute(sampler)\\n\\n pvqd = PVQD(\\n fidelity_primitive,\\n self.ansatz,\\n self.initial_parameters,\\n estimator,\\n optimizer=SPSA(maxiter=0, learning_rate=0.1, perturbation=0.01),\\n num_timesteps=10,\\n initial_guess=initial_guess,\\n )\\n problem = TimeEvolutionProblem(\\n self.hamiltonian, time=0.1, aux_operators=[self.hamiltonian, self.observable]\\n )\\n\\n result = pvqd.evolve(problem)\\n\\n observables = result.aux_ops_evaluated\\n self.assertEqual(observables[0], 0.1) # expected energy\\n self.assertEqual(observables[1], 1) # expected magnetization\",\n \"def test_velocity_boundaries(self):\\n L_x = self.x_edge[-1]\\n np.testing.assert_array_almost_equal(self.v_box(self.t, 0), 0, decimal=4)\\n np.testing.assert_array_almost_equal(self.v_box(self.t, L_x), 0, decimal=4)\",\n \"def __init__(self, v, j, area, current=False, reversed_j=False):\\r\\n \\r\\n PINT = 100 #[mW/cm^2]\\r\\n\\r\\n self.v = v\\r\\n self.area = float(area)\\r\\n\\r\\n if not reversed_j:\\r\\n j = -j\\r\\n\\r\\n if current:\\r\\n self.j = j/self.area * 1000 #[mA] -> [A]\\r\\n self.i = j\\r\\n else:\\r\\n self.j = j\\r\\n self.i = j * self.area / 1000 #[A] -> [mA]\\r\\n \\r\\n self.power = self.v * self.i #[W]\\r\\n\\r\\n self.voc = find_zero_cross(self.v,self.j)\\r\\n self.jsc = find_zero_cross(self.j,self.v)\\r\\n self.isc = self.jsc * self.area / 1000 #[A]\\r\\n\\r\\n self.mpp = self.power.max()\\r\\n\\r\\n self.ff = self.mpp/(self.voc * self.isc)\\r\\n self.pce = (self.mpp * 1000)/ self.area / PINT * 100 # calcurate in mW/cm^2 unit. Finally the value is converted to %.\\r\\n\\r\\n if (self.voc==0) or (self.jsc==0):\\r\\n self.ff = 0\\r\\n self.pce = 0\\r\\n \\r\\n try:\\r\\n self.rs = find_rs(self.v, self.j) #[Ohm cm^2]\\r\\n self.rsh = find_rsh(self.v, self.j) #[Ohm cm^2]\\r\\n\\r\\n except:\\r\\n print 'error at Rs, Rsh fitting'\\r\\n self.rs = 0\\r\\n self.rsh = 0\",\n \"def test_too_low_max_iterations(self):\\n\\n # Set up the problem of finding the square roots of three numbers.\\n constants = np.array([4.0, 9.0, 16.0])\\n initial_values = np.ones(len(constants))\\n\\n def objective_and_gradient(values):\\n objective = values**2 - constants\\n gradient = 2.0 * values\\n return objective, gradient\\n\\n # Obtain and evaluate a tensor containing the roots.\\n roots = newton_root_finder(\\n objective_and_gradient, initial_values, max_iterations=1)\\n _, converged, failed = self.evaluate(roots)\\n\\n # Reference values - we should neither have converged nor failed.\\n converged_bench = np.array([False, False, False])\\n failed_bench = np.array([False, False, False])\\n\\n # Assert that the values we obtained are close to the true values.\\n np.testing.assert_array_equal(converged, converged_bench)\\n np.testing.assert_array_equal(failed, failed_bench)\",\n \"def ExecuteBeforeSolutionLoop(self):\\n super().ExecuteBeforeSolutionLoop()\\n num_of_vaviables = len(self.variables) + len(self.nonhistorical_variables)\\n self.values = [[-1e6] * num_of_vaviables for _ in self.found_positions]\",\n \"def _solve_implicit(self, initial_conditions):\\n coeff = self.a ** 2 * self.tau / self.h ** 2\\n l_and_u = (1, 1)\\n ab = np.empty((3, self.n_x))\\n # main diagonal\\n ab[1] = 1 + 2.0 * coeff\\n # upper and lower diagonals\\n ab[0] = ab[2] = -coeff\\n\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n ab[0][1] = 0 # upper diagonal\\n ab[1][0] = 1 # main diagonal\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n ab[0][1] = 1 # upper diagonal\\n ab[1][0] = -1 # main diagonal\\n\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n ab[1][-1] = 1 # main diagonal\\n ab[2][-2] = 0 # lower diagonal\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n ab[1][-1] = 1 # main diagonal\\n ab[2][-2] = -1 # lower diagonal\\n\\n current_solution = initial_conditions\\n solutions = []\\n\\n for t in self.t_grid:\\n b = current_solution + self.tau * self.rhs(self.x_grid, t)\\n # left bc\\n if self.left_bc_type == \\\"DIRICHLET\\\":\\n b[0] = self.left_bc(t)\\n elif self.left_bc_type == \\\"NEUMANN\\\":\\n b[0] = self.h * self.left_bc(t)\\n # right bc\\n if self.right_bc_type == \\\"DIRICHLET\\\":\\n b[-1] = self.right_bc(t)\\n elif self.right_bc_type == \\\"NEUMANN\\\":\\n b[-1] = self.h * self.right_bc(t)\\n\\n next_solution = solve_banded(l_and_u, ab, b)\\n if self.mode == \\\"VISUALIZATION\\\":\\n solutions.append((t, next_solution.copy()))\\n current_solution = next_solution\\n if self.mode == \\\"TEST\\\":\\n # print(\\\"Result: \\\", current_solution.tolist())\\n # print(\\\"Right answer: \\\", self.anl_solution.tolist())\\n self._norma(current_solution)\\n elif self.mode == \\\"VISUALIZATION\\\":\\n return solutions\",\n \"def get_membrane_potential(self):\\n threshold = self.results['threshold']\\n interpolated_spike_times = self.results['interpolated_spike_times']\\n\\n interpolated_spike_thresholds = self.results['interpolated_spike_threshold']\\n grid_spike_indices = self.results['spike_time_steps']\\n grid_spike_times = self.results['grid_spike_times']\\n after_spike_currents = self.results['AScurrents']\\n\\n vm = self.results['voltage']\\n if len(self.results['interpolated_spike_voltage']) > 0:\\n isv = self.results['interpolated_spike_voltage'].tolist()[0]\\n vm = list(map(lambda x: isv if np.isnan(x) else x, vm))\\n dt = self.glif.dt\\n self.vM = AnalogSignal(vm,units = mV,sampling_period = dt * ms)\\n return vms\",\n \"def _handle_bounds_speedj(self):\\n inside_bound, inside_buffer_bound, mat, xyz = self._check_bound(self._qt_[-1])\\n inside_angle_bound = np.all(self._angles_low <= self._qt_[-1, self._joint_indices]) and \\\\\\n np.all(self._qt_[-1, self._joint_indices] <= self._angles_high)\\n if inside_bound:\\n self.return_point = None\\n if inside_angle_bound:\\n self.angle_return_point = False\\n if not inside_bound:\\n if self.return_point is None:\\n # we are outside the bounds and return point wasn't computed yet\\n print(\\\"outside box bound\\\")\\n xyz = np.clip(xyz, self._end_effector_low + self._box_bound_buffer,\\n self._end_effector_high - self._box_bound_buffer)\\n mat[:3, 3] = xyz\\n ref_pos = self._q_ref.copy()\\n ref_pos[self._joint_indices] = self._q_[-1, self._joint_indices]\\n solutions = ur_utils.inverse_near(mat, wrist_desired=self._q_ref[-1], ref_pos=ref_pos,\\n params=self._ik_params)\\n servoj_q = self._q_ref.copy()\\n if len(solutions) == 0:\\n servoj_q[self._joint_indices] = self._q_[-1, self._joint_indices]\\n else:\\n servoj_q[self._joint_indices] = solutions[0][self._joint_indices]\\n self.return_point = servoj_q[self._joint_indices]\\n # Speed at which arm approaches the boundary. The faster this speed,\\n # the larger opposite acceleration we need to apply in order to slow down\\n self.init_boundary_speed = np.max(np.abs(self._qd_.copy()))\\n # if return point is already computed, keep going to it, no need\\n # to recompute it at every time step\\n self._cmd_ = self.return_point - self._q_[0][self._joint_indices]\\n # Take the direction to return point and normalize it to have norm 0.1\\n if np.linalg.norm(self._cmd_) != 0:\\n self._cmd_ /= np.linalg.norm(self._cmd_) / 0.1\\n\\n self._speedj_packet[1:1 + 6][self._joint_indices] = self._cmd_\\n # This acceleration guarantees that we won't move beyond\\n # the bounds by more than 0.05 radian on each joint. This\\n # follows from kinematics equations.\\n accel_to_apply = np.max(np.abs(self._qd_)) * self.init_boundary_speed / 0.05\\n\\n # self.boundary_packet[1:1 + 6][self.joint_indices] = self.return_point\\n # self.actuator_comms['UR5'].actuator_buffer.write(self.reset_packet)\\n # time.sleep(1.0)\\n self._speedj_packet[-2] = np.clip(accel_to_apply, 2.0, 5.0)\\n self._actuation_packet_['UR5'] = self._speedj_packet\\n self._cmd_.fill(0.0)\\n self._cmd_prev_.fill(0.0)\\n self._first_deriv_.fill(0.0)\\n\\n elif not inside_angle_bound:\\n # if return point is already computed, keep going to it, no need\\n self.rel_indices = self._joint_indices\\n cur_pos = self._q_[0][self._joint_indices]\\n clipped_pos = np.clip(cur_pos, self._angles_low + self._angle_bound_buffer,\\n self._angles_high - self._angle_bound_buffer)\\n # a point within the box to which we will be returning\\n affected_joints = np.where(clipped_pos != cur_pos)\\n if not self.angle_return_point:\\n print(\\\"outside of angle bound on joints %r\\\" % (list(affected_joints[0])))\\n self.angle_return_point = True\\n self._cmd_[affected_joints] = np.sign(clipped_pos - cur_pos)[affected_joints]*np.max(np.abs(self._cmd_))\\n self._speedj_packet[1:1 + 6][self._joint_indices] = self._cmd_\\n self._actuation_packet_['UR5'] = self._speedj_packet\",\n \"def root_v0(self, v):\\n from scipy.integrate import quad\\n from scipy.special import erfc, erfcx\\n def integrand(u):\\n \\\"\\\"\\\"Integrand of self-consistency equation\\\"\\\"\\\"\\n return erfcx(-u)\\n #if u < -4.0:\\n #return -1. / np.sqrt(np.pi) * (1.0 / u - 1.0 / (2.0 * u**3) + \\n ##3.0 / (4.0 * u**5) - \\n ##15.0 / (8.0 * u**7))\\n #else:\\n #return np.exp(u**2) * (1. + erf(u))\\n\\n\\n mu_v = self.mu(v)\\n sd_v = self.sd(v)\\n low = (self.V_r - mu_v) / sd_v\\n up = (self.theta - mu_v) / sd_v\\n bounds = np.array([low, up]).T\\n\\n integral = np.array([quad(integrand, lower, upper)[0] for lower, upper in bounds])\\n root = - 1. / v + self.t_ref * 1e-3 \\\\\\n + np.sqrt(np.pi) * self.tau_m * 1e-3 * integral\\n return root\",\n \"def interpolate_hold_9(self):\\n\\n # Initialize variables\\n n_ensembles = self.u_mps.shape[0]\\n\\n # Get data from object\\n self.u_processed_mps = np.copy(self.u_mps)\\n self.v_processed_mps = np.copy(self.v_mps)\\n self.u_processed_mps[self.valid_data[0, :] == False] = np.nan\\n self.v_processed_mps[self.valid_data[0, :] == False] = np.nan\\n\\n n_invalid = 0\\n # Process data by ensembles\\n for n in range(n_ensembles):\\n # Check if ensemble is invalid and number of consecutive invalids is less than 9\\n if self.valid_data[0, n] == False and n_invalid < 9:\\n self.u_processed_mps[n] = self.u_processed_mps[n - 1]\\n self.v_processed_mps[n] = self.v_processed_mps[n - 1]\\n n_invalid += 1\\n else:\\n n_invalid = 0\",\n \"def block_solve_newton(\\n r_j,\\n A_j,\\n a_1_j,\\n a_2_j,\\n m,\\n b_j_init,\\n C_j,\\n I_j,\\n ls_alpha=0.5,\\n ls_beta=0.9,\\n max_iters=20,\\n tol=1e-8,\\n verbose=False,\\n):\\n b_j = b_j_init\\n k = 1\\n pbar_stats = {} # stats for the progress bar\\n pbar = tqdm.tqdm(\\n desc=\\\"Solving block with Newton's method\\\", disable=not verbose, leave=False\\n )\\n\\n while True:\\n # First, compute the Newton step and decrement.\\n q_b_j = r_j - A_j @ b_j\\n b_j_norm = b_j.norm(p=2)\\n grad_b_j = _grad_j(q_b_j, A_j, b_j, b_j_norm, a_1_j, a_2_j, m)\\n hess_b_j = _hess_j(C_j, I_j, b_j, b_j_norm, a_1_j, a_2_j)\\n hessinv_b_j = torch.inverse(hess_b_j)\\n v_j = hessinv_b_j @ grad_b_j\\n dec_j = grad_b_j @ (hessinv_b_j @ grad_b_j)\\n\\n # Check tolerance stopping criterion. Exit if dec_j / 2 is less than the\\n # tolerance.\\n if dec_j / 2 <= tol:\\n break\\n\\n # Perform backtracking line search.\\n t = 1\\n f_b_j = _f_j(q_b_j, b_j_norm, a_1_j, a_2_j, m)\\n k_j = grad_b_j @ v_j\\n while True:\\n # Compute the update and evaluate function at that point.\\n bp_j = b_j - t * v_j\\n q_bp_j = r_j - A_j @ bp_j\\n bp_j_norm = bp_j.norm(p=2)\\n f_bp_j = _f_j(q_bp_j, bp_j_norm, a_1_j, a_2_j, m)\\n\\n if f_bp_j <= f_b_j - ls_alpha * t * k_j:\\n b_j = bp_j\\n break\\n t *= ls_beta\\n\\n # Make b_j non-zero if it is 0.\\n if all(b_j.abs() < tol):\\n b_j.fill_(1e-3)\\n\\n pbar_stats[\\\"t\\\"] = \\\"{:.2g}\\\".format(t)\\n pbar_stats[\\\"1/2 newton decrement\\\"] = \\\"{:.2g}\\\".format(dec_j / 2)\\n pbar.set_postfix(pbar_stats)\\n pbar.update()\\n\\n # Check max iterations stopping criterion.\\n if max_iters is not None and k == max_iters and k > 2:\\n break\\n k += 1\\n\\n pbar.close()\\n return b_j\",\n \"def solve_with_bruteforce(grid):\\n\\n res = check_sudoku(grid)\\n if res is None or res is False:\\n return res\\n \\n for row in range(0, 9):\\n for col in range(0, 9):\\n if grid[row][col] == 0:\\n for n in range(1,10):\\n grid[row][col] = n\\n solution = solve_with_bruteforce(grid)\\n if solution is False:\\n grid[row][col] = 0\\n else:\\n return solution\\n return False\\n return grid\",\n \"def potential(self) -> np.ndarray:\\n if self._V is None:\\n potential = -self._gp.reshape(-1, 1) * self._gp # pylint: disable=E1101\\n object.__setattr__(self, \\\"_V\\\", potential)\\n return self._V\",\n \"def solve(self):\\n\\n\\t\\tempty_spot = self.find_unsettled_spot()\\n\\t\\tif not empty_spot:\\n\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\trow, col = empty_spot\\n\\n\\t\\t\\t# Loop through all the available numbers\\n\\t\\t\\tfor number in range(1, 10):\\n\\t\\t\\t\\t# If the number has no conflicts in its row, column or subgrid\\n\\t\\t\\t\\tif self.no_conflicts(row, col, number):\\n\\t\\t\\t\\t\\t# Then overwrite the 0 with the new number\\n\\t\\t\\t\\t\\tself.grid[row][col] = number\\n\\n\\t\\t\\t\\t\\tif self.solve():\\n\\t\\t\\t\\t\\t\\treturn True\\n\\n\\t\\t\\t\\t\\t# This is where backtracking happens\\n\\t\\t\\t\\t\\t# Reset the latest position back to 0 and try with new number value\\n\\t\\t\\t\\t\\tself.grid[row][col] = 0\\n\\n\\t\\treturn False\",\n \"def solve(self,init=None,g_init=1e-3,g_step=5e-3,g_fin=None,evol=False,movingGrid=False):\\n if(g_fin==None): g_fin=self.g\\n #Check if all signs are correct\\n if(g_fin<0):\\n if(g_step>0): g_step*=-1.\\n if(g_init>0): g_init*=-1.\\n else:\\n if(g_step<0): g_step*=-1.\\n if(g_init<0): g_step*=-1.\\n\\n #If no initial distribution is given, start from the BCS ground state\\n if(init==None): init=[1 if i<self.N else 0 for i in range(self.n)]\\n var_init=np.array([-2.*init[i]-g_init/(1-2.*init[i])*np.sum([self.XXZ.Z(j,i)*(init[j]-init[i]) for j in range(self.n) if j!=i]) for i in range(self.n)])\\n n_step=int((g_fin-g_init)/g_step)\\n g=g_init\\n\\n #Define necessary variables if evol or movingGrid=True\\n if(evol or movingGrid):\\n var_evol=np.zeros([n_step,self.n])\\n g_evol=np.zeros(n_step)\\n if(movingGrid):\\n rap_evol = np.zeros([n_step,self.N],dtype=complex)\\n rap_evol[0] = [self.levels[i] for i in range(self.n) if init[i]!=0 ]\\n rap=np.array([self.levels[i]+0.5*np.abs(np.random.rand()) for i in range(self.n) if init[i]!=0])\\n grid=np.zeros(self.N+1,dtype=complex)\\n grid[0]=1e3\\n for k in range(self.N): grid[k+1]=rap[k]\\n n_grid=n_step/20 #Calculates rapidities at 20 intermediate steps\\n\\n #Gradually increase the coupling constant g and solve iteratively at each step starting from the Taylor approximation from the previous step\\n for i in range(n_step):\\n var_new=self.newtonraphson(g,var_init)\\n der=self.get_derivative(var_new,g)\\n #var_init=self.taylor_expansion(g,g_step,var_new)\\n var_init = var_new+g_step*der\\n g+=g_step\\n #print g\\n\\n #Save variables at current step if evol =True\\n if(evol or movingGrid):\\n var_evol[i]=var_init\\n g_evol[i]=g\\n if(movingGrid and i%n_grid==0 and i!=0):\\n #Method for obtaining the rapidities starting from the set of Lambda_i\\n rf=RootFinder(self.XXZ,var_evol[i]/g_evol[i],g_evol[i],self.N)\\n u=rf.solveForU(grid)\\n lm=LaguerreMethod(grid,u)\\n rap=lm.laguerre()\\n rap_evol[i]=np.sort(lm.laguerre())\\n for k in range(self.N): grid[k+1]=rap[k]\\n grid[0]=10*max(rap)\\n elif(movingGrid and i!=0):\\n rf=RootFinder(self.XXZ,var_evol[i]/g_evol[i],g_evol[i],self.N)\\n u=rf.solveForU(grid)\\n lm=LaguerreMethod(grid,u)\\n rap_evol[i]=np.sort(lm.laguerre())\\n \\n \\n #One final iterative solution at g=g_fin\\n self.solution=self.newtonraphson(g_fin,var_init)\\n #Calculate the occupation numbers\\n self.occupation=0.5*(-1.-self.solution+g_fin*self.get_derivative(self.solution,g_fin))\\n\\n #One final calculation of the rapidities\\n if(movingGrid):\\n rf=RootFinder(self.XXZ,self.solution/g_fin,g_fin,self.N)\\n u=rf.solveForU(grid)\\n lm=LaguerreMethod(grid,u)\\n rap=lm.laguerre()\\n self.rapidities=rap\\n\\n if movingGrid: return [g_evol,var_evol,rap_evol]\\n if evol: return [g_evol,var_evol]\\n return self.solution\",\n \"def test_basic_newton_finder(self):\\n forwards = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n strikes = np.array([1.0, 2.0, 1.0, 0.5, 1.0, 1.0])\\n expiries = np.array([1.0, 1.0, 1.0, 1.0, 0.5, 2.0])\\n discounts = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n init_vols = np.array([2.0, 0.5, 2.0, 0.5, 1.5, 1.5])\\n option_signs = np.array([1.0, 1.0, -1.0, -1.0, 1.0, 1.0])\\n volatilities = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n prices = np.array([\\n 0.38292492, 0.19061012, 0.38292492, 0.09530506, 0.27632639, 0.52049988\\n ])\\n results = implied_vol(\\n forwards,\\n strikes,\\n expiries,\\n discounts,\\n prices,\\n option_signs,\\n initial_volatilities=init_vols,\\n max_iterations=100)\\n implied_vols, converged, failed = self.evaluate(results)\\n num_volatilities = len(volatilities)\\n self.assertAllEqual(np.ones(num_volatilities, dtype=np.bool), converged)\\n self.assertAllEqual(np.zeros(num_volatilities, dtype=np.bool), failed)\\n self.assertArrayNear(volatilities, implied_vols, 1e-7)\",\n \"def test_test_jacobian(self):\\n self.set_up()\\n inputObject = self.vmecOptimization.vmecInputObject\\n rbc = np.copy(inputObject.rbc)\\n zbs = np.copy(inputObject.zbs)\\n inputObject.rbc = 0*inputObject.rbc\\n inputObject.zbs = 0*inputObject.zbs\\n orientable = self.vmecOptimization.test_jacobian(inputObject)\\n self.assertFalse(orientable)\\n # Reset boundary\\n inputObject.rbc = rbc\\n inputObject.zbs = zbs\\n self.tear_down()\",\n \"def test_vmec_objective_grad(self): \\n self.set_up()\\n self.assertRaises(ValueError,\\n self.vmecOptimization.vmec_objective_grad,\\n which_objective='volumee')\\n \\n boundary = np.copy(self.vmecOptimization.boundary_opt)\\n boundary_new = np.hstack((boundary,boundary))\\n self.assertRaises(ValueError,\\n self.vmecOptimization.vmec_objective_grad,\\n boundary=boundary_new)\\n self.assertRaises(RuntimeError,\\n self.vmecOptimization.vmec_objective_grad,\\n which_objective='iota') \\n self.assertRaises(RuntimeError,\\n self.vmecOptimization.vmec_objective_grad,\\n which_objective='iota_prime') \\n self.assertRaises(RuntimeError,\\n self.vmecOptimization.vmec_objective_grad,\\n which_objective='iota_target') \\n self.assertRaises(RuntimeError,\\n self.vmecOptimization.vmec_objective_grad,\\n which_objective='well_ratio') \\n self.assertRaises(RuntimeError,\\n self.vmecOptimization.vmec_objective_grad,\\n which_objective='well') \\n self.assertRaises(RuntimeError,\\n self.vmecOptimization.vmec_objective_grad,\\n which_objective='axis_ripple') \\n # Jacobian\\n dfdomega = self.vmecOptimization.vmec_objective_grad(\\n boundary=boundary,which_objective='jacobian')\\n boundary = self.vmecOptimization.boundary_opt\\n dfdomega_fd = finite_difference_derivative(boundary, lambda boundary :\\n self.vmecOptimization.vmec_objective(boundary=boundary,\\n which_objective='jacobian'),epsilon=1e-4,\\n method='centered')\\n\\n self.assertTrue(np.allclose(dfdomega,dfdomega_fd,atol=1e-5))\\n # Radius\\n dfdomega = self.vmecOptimization.vmec_objective_grad(\\n boundary=boundary,which_objective='radius')\\n boundary = self.vmecOptimization.boundary_opt\\n dfdomega_fd = finite_difference_derivative(boundary, lambda boundary :\\n self.vmecOptimization.vmec_objective(boundary=boundary,\\n which_objective='radius'),epsilon=1e-4,\\n method='centered')\\n self.assertTrue(np.allclose(dfdomega,dfdomega_fd,atol=1e-5))\\n # normalized_jacobian\\n dfdomega = self.vmecOptimization.vmec_objective_grad(\\n boundary=boundary,which_objective=\\n 'normalized_jacobian')\\n boundary = self.vmecOptimization.boundary_opt\\n dfdomega_fd = finite_difference_derivative(boundary, lambda boundary :\\n self.vmecOptimization.vmec_objective(boundary=boundary,\\n which_objective='normalized_jacobian'),epsilon=1e-4,\\n method='centered')\\n self.assertTrue(np.allclose(dfdomega,dfdomega_fd,atol=1e-5))\\n # iota\\n inputObject = VmecInput('input.rotating_ellipse_highres')\\n boundary = np.copy(self.vmecOptimization.boundary_opt)\\n boundary[0] = 1.1*boundary[0]\\n self.vmecOptimization.inputObject = inputObject\\n self.vmecOptimization.vmecInputFilename = 'input.rotating_ellipse_highres'\\n self.vmecOptimization.delta_curr = 10\\n dfdomega = self.vmecOptimization.vmec_objective_grad(\\n boundary=boundary,which_objective='iota',\\n weight_function = axis_weight)\\n dfdomega_fd = finite_difference_derivative(boundary, lambda boundary :\\n self.vmecOptimization.vmec_objective(boundary=boundary,\\n which_objective='iota', weight_function = axis_weight),\\n epsilon=1e-3, method='centered')\\n self.assertTrue(np.allclose(dfdomega,dfdomega_fd,atol=1e-2))\\n \\n # To do : finish FD testing\\n self.tear_down()\",\n \"def solve(initial_board, forward_checking = False, MRV = False, MCV = False,\\n LCV = False):\\n\\n curr_board = initial_board\\n f_checking = forward_checking\\n #minimum remaining values= choose var with fewest values left\\n my_MRV = MRV\\n #most constrained variable (degree)= choose var that is involved in largest num of constraints with unnassigned vars\\n my_MCV = MCV\\n #least constrained value= choose value that rules out fewest choices for other unnassigned vars\\n my_LCV = LCV\\n\\n #call DFS on board to solve\\n backtrack(curr_board, 0, f_checking, my_MRV, my_MCV, my_LCV)\\n\\n #print \\\"Your code will solve the initial_board here!\\\"\\n #print \\\"Remember to return the final board (the SudokuBoard object).\\\"\\n #print \\\"I'm simply returning initial_board for demonstration purposes.\\\"\\n return curr_board\",\n \"def solve(self, model, target, init=None, u=1e-3, v=1.5):\\n if init is None:\\n init = np.zeros(model.n_params)\\n out_n = np.shape(model.run(init).ravel())[0]\\n jacobian = np.zeros([out_n, init.shape[0]])\\n\\n last_update = 0\\n last_mse = 0\\n params = init\\n for i in range(self.max_iter):\\n residual = (model.run(params) - target).reshape(out_n, 1)\\n mse = np.mean(np.square(residual))\\n\\n if abs(mse - last_mse) < self.mse_threshold:\\n return params\\n\\n for k in range(params.shape[0]):\\n jacobian[:, k] = self.get_derivative(model, params, k)\\n\\n jtj = np.matmul(jacobian.T, jacobian)\\n jtj = jtj + u * np.eye(jtj.shape[0])\\n\\n update = last_mse - mse\\n delta = np.matmul(\\n np.matmul(np.linalg.inv(jtj), jacobian.T), residual\\n ).ravel()\\n params -= delta\\n\\n if update > last_update and update > 0:\\n u /= v\\n else:\\n u *= v\\n\\n last_update = update\\n last_mse = mse\\n\\n if self.verbose:\\n print(i, self.timer.tic(), mse)\\n\\n return params\",\n \"def calc(self):\\n\\n # the following if query ensures that volume- and interaction-terms\\n # are only calculated if tau > 0.\\n # (to avoid nan-values from invalid function-evaluations)\\n\\n if self.V.tau.shape == (1,):\\n Isurf = self.surface()\\n # differentiation for non-existing canopy, as otherwise NAN values\\n if self.V.tau > 0.:\\n Ivol = self.volume()\\n if self.int_Q is True:\\n Iint = self.interaction()\\n else:\\n Iint = np.array([0.])\\n else:\\n Ivol = np.array([0.])\\n Iint = np.array([0.])\\n else:\\n # calculate surface-term (valid for any tau-value)\\n Isurf = self.surface()\\n\\n # store initial parameter-values\\n old_t_0 = self.t_0\\n old_p_0 = self.p_0\\n old_t_ex = self.t_ex\\n old_p_ex = self.p_ex\\n\\n old_tau = self.V._get_tau()\\n old_omega = self.V._get_omega()\\n old_NN = self.SRF._get_NormBRDF()\\n\\n # set mask for tau > 0.\\n mask = old_tau > 0.\\n valid_index = np.where(mask)\\n inval_index = np.where(~mask)\\n\\n # set parameter-values to valid values for calculation\\n self.t_0 = old_t_0[valid_index[0]]\\n self.p_0 = old_p_0[valid_index[0]]\\n self.t_ex = old_t_ex[valid_index[0]]\\n self.p_ex = old_p_ex[valid_index[0]]\\n\\n # squeezing the arrays is necessary since the setter-function for\\n # tau, omega and NormBRDF automatically adds an axis to the arrays!\\n self.V.tau = np.squeeze(old_tau[valid_index[0]])\\n if np.array(self.V.omega).size != 1:\\n self.V.omega = np.squeeze(old_omega[valid_index[0]])\\n if np.array(self.SRF.NormBRDF).size != 1:\\n self.SRF.NormBRDF = np.squeeze(old_NN[valid_index[0]])\\n\\n # calculate volume and interaction term where tau-values are valid\\n _Ivol = self.volume()\\n if self.int_Q is True:\\n _Iint = self.interaction()\\n else:\\n _Iint = np.full_like(self.t_0, 0.)\\n\\n # reset parameter values to old values\\n self.t_0 = old_t_0\\n self.p_0 = old_p_0\\n self.t_ex = old_t_ex\\n self.p_ex = old_p_ex\\n\\n # squeezing the arrays is necessary since the setter-function for\\n # tau, omega and NormBRDF automatically add an axis to the arrays!\\n self.V.tau = np.squeeze(old_tau)\\n self.V.omega = np.squeeze(old_omega)\\n self.SRF.NormBRDF = np.squeeze(old_NN)\\n\\n # combine calculated volume-contributions for valid tau-values\\n # with zero-arrays for invalid tau-values\\n Ivol = np.ones_like(self.t_0)\\n Ivol[valid_index[0]] = _Ivol\\n Ivol[inval_index[0]] = np.ones_like(Ivol[inval_index[0]]) * 0.\\n\\n # combine calculated interaction-contributions for valid tau-values\\n # with zero-arrays for invalid tau-values\\n if self.int_Q is True:\\n Iint = np.ones_like(self.t_0)\\n Iint[valid_index[0]] = _Iint\\n Iint[inval_index[0]] = np.ones_like(Iint[inval_index[0]]) * 0.\\n else:\\n Iint = np.full_like(self.t_0, 0.)\\n\\n return Isurf + Ivol + Iint, Isurf, Ivol, Iint\",\n \"def vcjamged(self, whichval, newvalue):\\n\\n if self.performingupdate or whichval >= self.numcols or type(newvalue) != float:\\n return\\n\\n diff = newvalue - self.currentvalues[whichval]\\n if abs(diff) < 0.01:\\n return\\n\\n incr = 0.01\\n if diff < 0.0:\\n incr = -.01\\n\\n while newvalue in self.currentvalues:\\n newvalue = round(newvalue + incr, 2)\\n\\n # If we've run off either end, we'll have to go back to where we were\\n\\n if newvalue < self.minvalue or newvalue > self.maxvalue:\\n self.performingupdate = True\\n self.vspins[whichval].setValue(self.currentvalues[whichval])\\n self.performingupdate = False\\n return\\n\\n self.performingupdate = True\\n self.currentvalues[whichval] = newvalue\\n self.currentvalues.sort()\\n self.createrest()\\n self.fillingrid()\\n self.performingupdate = False\\n self.plotmap()\",\n \"def test_get_values_from_new_grid(mock_amg):\\n\\n # create an array of random displacements\\n randu = np.random.rand(5, 4)\\n randv = np.random.rand(5, 4)\\n\\n # create 5 random values which will be the new windows\\n randu_new = np.random.rand(5)\\n randv_new = np.random.rand(5)\\n\\n # split the central cell\\n mock_amg.cells[7].split()\\n\\n # define the window values for the new locations\\n for ii in range(5):\\n mock_amg.windows[-5+ii].u = randu_new[ii]\\n mock_amg.windows[-5+ii].v = randv_new[ii]\\n\\n # create the expected grid\\n expu, expv = np.zeros((9, 7)), np.zeros((9, 7))\\n\\n # set the expected values in the middle\\n # we have split the middle cell (out of 3) on row 3\\n # bl_index = [4, 2]\\n # left middle\\n expu[5, 2] = randu_new[0]\\n expv[5, 2] = randv_new[0]\\n\\n # middle bottom\\n expu[4, 3] = randu_new[1]\\n expv[4, 3] = randv_new[1]\\n\\n # middle middle\\n expu[5, 3] = randu_new[2]\\n expv[5, 3] = randv_new[2]\\n\\n # middle top\\n expu[6, 3] = randu_new[3]\\n expv[6, 3] = randv_new[3]\\n\\n # right middle\\n expu[5, 4] = randu_new[4]\\n expv[5, 4] = randv_new[4]\\n\\n # get the values\\n uu, vv = mock_amg.grids[1].get_values()\\n uu[np.isnan(uu)] = 0\\n vv[np.isnan(vv)] = 0\\n assert np.allclose(uu, expu)\\n assert np.allclose(vv, expv)\",\n \"def test_near_surface_consistency():\\n bead_diameter = 0.5\\n shared_pars = {\\n \\\"bead_diameter\\\": bead_diameter,\\n \\\"viscosity\\\": 1.1e-3,\\n \\\"temperature\\\": 25,\\n \\\"rho_sample\\\": 997.0,\\n \\\"rho_bead\\\": 1040.0,\\n \\\"distance_to_surface\\\": bead_diameter,\\n }\\n sim_pars = {\\n \\\"sample_rate\\\": 78125,\\n \\\"stiffness\\\": 0.1,\\n \\\"pos_response_um_volt\\\": 0.618,\\n \\\"driving_sinusoid\\\": (500, 31.95633),\\n \\\"diode\\\": (0.6, 15000),\\n }\\n\\n np.random.seed(1337)\\n volts, stage = generate_active_calibration_test_data(\\n 10, hydrodynamically_correct=True, **sim_pars, **shared_pars\\n )\\n power_spectrum = calculate_power_spectrum(volts, sim_pars[\\\"sample_rate\\\"])\\n\\n active_pars = {\\n \\\"force_voltage_data\\\": volts,\\n \\\"driving_data\\\": stage,\\n \\\"sample_rate\\\": 78125,\\n \\\"driving_frequency_guess\\\": 32,\\n }\\n\\n def fit_spectrum(active, hydro):\\n model = (\\n ActiveCalibrationModel(**active_pars, **shared_pars, hydrodynamically_correct=hydro)\\n if active\\n else PassiveCalibrationModel(**shared_pars, hydrodynamically_correct=hydro)\\n )\\n return fit_power_spectrum(power_spectrum, model)\\n\\n parameters_of_interest = {\\n \\\"kappa\\\": sim_pars[\\\"stiffness\\\"],\\n \\\"Rd\\\": sim_pars[\\\"pos_response_um_volt\\\"],\\n \\\"Rf\\\": sim_pars[\\\"stiffness\\\"] * sim_pars[\\\"pos_response_um_volt\\\"] * 1e3,\\n }\\n\\n for active_calibration in (True, False):\\n for hydrodynamic_model in (True, False):\\n fit = fit_spectrum(active_calibration, hydrodynamic_model)\\n\\n # Note that the corner frequency of the hydrodynamic model is specified in bulk, while\\n # the regular model has its corner frequency specified at the current height.\\n fc_bulk = (\\n fit[\\\"fc\\\"].value\\n if hydrodynamic_model\\n else fit[\\\"fc\\\"].value\\n * faxen_factor(shared_pars[\\\"distance_to_surface\\\"] * 1e-6, bead_diameter * 1e-6 / 2)\\n )\\n np.testing.assert_allclose(fc_bulk, 3070.33, rtol=2e-2)\\n for param, ref_value in parameters_of_interest.items():\\n np.testing.assert_allclose(fit[param].value, ref_value, rtol=2e-2)\",\n \"def test_exact_numerical_solution():\\n a = 0.2\\n b = 3\\n\\n def f(t, u):\\n return a # + (u - u_exact(t))**5\\n\\n def u_exact(t):\\n \\\"\\\"\\\"Exact u(t) corresponding to f above.\\\"\\\"\\\"\\n return a * t + b\\n\\n u0 = u_exact(0)\\n T = 8\\n N = 10\\n tol = 1E-15\\n #t_points = np.linspace(0, T, N)\\n t_span = (0, T)\\n for solver_class in registered_solver_classes:\\n solver = solver_class(f)\\n solver.set_initial_condition(u0)\\n t, u = solver.solve(t_span, N)\\n u_e = u_exact(t)\\n max_error = (u_e - u).max()\\n msg = f'{solver.__class__.__name__} failed with max_error={max_error}'\\n assert max_error < tol, msg\",\n \"def mtvsolverbis(Hurstaest_init, yij, varyj, nj, j1, j2,\\n mask, max_iter=100, init=None,\\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\\n l=1, l1_ratio=0, wtype=1, lipschitz_constant=0):\\n\\n # shape of image box\\n \\n alpha = 1\\n\\n flat_mask = mask.ravel()\\n volume_shape = mask.shape\\n H_size = len(Hurstaest_init)\\n\\n if lipschitz_constant == 0:\\n lipschitz_constant = H_size * lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\\n\\n #init[\\\"z\\\"] = Hurst_init.copy()\\n #init[\\\"t\\\"] = 1\\n #ini[\\\"stepsize\\\"] = 1 / lipschitz_constant\\n\\n def total_energy(estimation):\\n return fbis(estimation, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(estimation[:H_size / 2],\\n mask))\\n\\n def unmaskvec(estimation):\\n return _unmask(estimation, mask)\\n\\n def maskvec(estimation):\\n return estimation[flat_mask]\\n\\n def f1_grad(estimation):\\n return gradfbis(estimation, yij, varyj, nj, j1, j2, wtype)\\n\\n def f2_prox(estimation, stepsize, dgap_tol, init):\\n lenw = len(estimation)\\n Hurst = estimation[lenw / 2:]\\n init = unmaskvec(init[:lenw / 2]) if not init is None else init\\n\\n out, info = _prox_tvl1(unmaskvec(Hurst),\\n weight=(l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\\n dgap_tol=dgap_tol, init=init,\\n max_iter=prox_max_iter, fista = False,\\n verbose=verbose)\\n #pdb.set_trace()\\n return np.concatenate((maskvec(out.ravel()),estimation[lenw / 2:])), info\\n\\n w, obj, init = mfista(\\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\\n max_iter=max_iter, callback=None)\\n \\n return w, obj, init\",\n \"def _redef_via_predef_eqn(self):\\r\\n time = self.current_T # + self.d_T\\r\\n\\r\\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\\\\r\\n (self.convect_coeff) \\r\\n self.Epsilon = self.d_T * self.thermal_conductivity / \\\\\\r\\n (self.density * self.heat_capacity)\\r\\n\\r\\n # Source term.\\r\\n def F_func(elem, eta):\\r\\n x = elem.local_to_global(eta)\\r\\n F = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n F -= self.Epsilon * self.redef_F_laplacian(x[0], x[1], time)\\r\\n F += self.redef_dTdt(x[0], x[1], time) * self.d_T\\r\\n return elem.funcs(eta) * F\\r\\n\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func,\\r\\n self.node_map,\\r\\n gauss_mult=2) # Use double gp_1D\\r\\n\\r\\n # Boundary term.\\r\\n def f_func(elem, eta):\\r\\n n = elem.guess_normal_vector_global(eta)\\r\\n f = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n x = elem.local_to_global(eta)\\r\\n # Evaluate our boundary term.\\r\\n f += self.Beta * self.redef_f_norm_grad(x[0], x[1], time, n)\\r\\n f += self.redef_dTdt(x[0], x[1], time) * self.d_T\\r\\n return elem.funcs(eta) * f\\r\\n\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func,\\r\\n self.node_map,\\r\\n gauss_mult=2)\",\n \"def initRunningVals(self):\\n self.r_Vm = [0.0]*self.mirror.dataPoints\\n self.r_Va = [0.0]*self.mirror.dataPoints\",\n \"def test_solve_quadratic_fixed(self):\\n iden1 = Identity()\\n iden2 = Identity()\\n iden3 = Identity()\\n iden1.x.val = 4\\n iden2.x.val = 5\\n iden3.x.val = 6\\n iden1.x.name = 'x1'\\n iden2.x.name = 'x2'\\n iden3.x.name = 'x3'\\n iden2.x.fixed = False\\n term1 = LeastSquaresTerm(iden1.target, 1, 1)\\n term2 = LeastSquaresTerm(iden2.target, 2, 2)\\n term3 = LeastSquaresTerm(iden3.target, 3, 3)\\n prob = LeastSquaresProblem([term1, term2, term3])\\n prob.solve()\\n self.assertAlmostEqual(prob.objective, 10)\\n self.assertAlmostEqual(iden1.x.val, 4)\\n self.assertAlmostEqual(iden2.x.val, 2)\\n self.assertAlmostEqual(iden3.x.val, 6)\",\n \"def init_constraints(self):\\n for (row, col), curr_value in np.ndenumerate(self.final_values):\\n self.possible_values[row][col] = [] # Initialize empty list\\n if curr_value == 0: # If the final value is 0 then the position is vacant\\n for value in range(1, 10): # Iterate through all possible values (1, 9) and check if they are possible\\n if self.__is_valid_value(row, col, value):\\n self.possible_values[row][col].append(value) # Append possible values to the corresponding list\\n return\",\n \"def test_v0(self):\\n\\t\\tposition = [0.0, 1.57079, 3.14159, 4.71238, 6.28318, 7.85398, 9.42477]\\n\\t\\tpotential = [0.0, 6.0, 0.0, -6.0, 0.0, 6.0, 0.0]\\n\\t\\tposition = tf.constant(position, shape = [1, len(position)], dtype = tf.float32)\\n\\t\\tpotential = tf.constant(potential, shape = [1, len(potential)], dtype = tf.float32)\\n\\t\\tbasis = schrodinger.create_basis(5)\\n\\t\\ta = schrodinger.v0(position, potential, basis).numpy()\\n\\t\\tb = [[ 6.0000000e+00], [ 1.8000000e+01], [ 1.0135167e-04], [-1.4448209e-05], [-6.0000000e+00]]\\n\\t\\tself.assertEqual(a[0], b[0])\\n\\t\\tself.assertEqual(a[1], b[1])\",\n \"def equiangulate(self,x,mask):\\n\\n timeout = 100\\n k = 0\\n while (not mask.all())and(k<timeout):\\n\\n changed_tris,j = np.nonzero(~mask)\\n chosen_cell = changed_tris[0]\\n cell_mask = np.zeros(3,dtype=np.bool)\\n cell_mask[j[0]] = True\\n chosen_opposite_cell = self.v_neighbours[chosen_cell,cell_mask][0]\\n\\n\\n cells = np.roll(self.tris[chosen_cell],-j[0])\\n opposite_cells = self.tris[chosen_opposite_cell]\\n opposite_cells = np.roll(opposite_cells, - self.k2s[chosen_cell,cell_mask])\\n\\n\\n self.tris[chosen_cell] = cells[0], opposite_cells[0],cells[2]\\n self.tris[chosen_opposite_cell] = opposite_cells[0],cells[0], opposite_cells[2]\\n\\n self.Angles[[chosen_cell,chosen_opposite_cell]] = tri_angles_periodic(x, self.tris[[chosen_cell,chosen_opposite_cell]], self.L)\\n # self.Angles = tri_angles_periodic(x,self.tris,self.L)\\n self.Cents = x[self.tris]\\n self.vs = self.get_vertex_periodic()\\n\\n\\n modify_neighbours = np.concatenate([self.v_neighbours[chosen_cell],self.v_neighbours[chosen_opposite_cell]])\\n modify_neighbours.sort()\\n self.v_neighbours[modify_neighbours] = -1\\n\\n\\n n_neigh = get_neighbours(self.tris,self.v_neighbours,Range = modify_neighbours)\\n self.v_neighbours = n_neigh\\n self.neighbours = self.vs[n_neigh]\\n\\n self.k2s = get_k2(self.tris, self.v_neighbours)\\n if (self.k2s>=3).sum()!=0:\\n self._triangulate_periodic(x)\\n self.k2s = get_k2(self.tris, self.v_neighbours)\\n mask[:] = True\\n else:\\n mask = ((self.Angles[self.v_neighbours, self.k2s] + self.Angles) < np.pi)\\n k+=1\\n if k == timeout:\\n self._triangulate_periodic(x)\\n self.k2s = get_k2(self.tris, self.v_neighbours)\",\n \"def test_v_bounds(self):\\n n = 50\\n t_max = 100.0\\n dt = 0.1\\n\\n G = StudentLayer(n)\\n G.i_ext_init = np.linspace(-1.0, 1.0, n)\\n\\n class BoundsChecker(object):\\n def __init__(self, target):\\n self.target = target\\n self.small = None\\n self.large = None\\n self.order = 1\\n\\n def evolve(self, t, dt):\\n small = np.min(self.target.v)\\n large = np.max(self.target.v)\\n if self.small is None or self.small > small:\\n self.small = small\\n if self.large is None or self.large < large:\\n self.large = large\\n \\n M = BoundsChecker(G)\\n\\n sim = simulation.Simulation(G, M, dt=dt)\\n sim.run(t_max)\\n\\n self.assertLess(M.large, G.v_th)\",\n \"def jacobian(self, v):\\n from scipy.special import erf, erfcx\\n def integrand(u_arr):\\n \\\"\\\"\\\"Integrand of self-consistency equation\\\"\\\"\\\"\\n integrand_all = erfcx(-u_arr)\\n #integrand_all = np.zeros(u_arr.shape)\\n #u_mask = u_arr < -4.0\\n #u = u_arr[u_mask]\\n #integrand_all[u_mask] = -1. / np.sqrt(np.pi) * (1.0 / u - 1.0 / (2.0 * u**3) + \\n #3.0 / (4.0 * u**5) - \\n #15.0 / (8.0 * u**7))\\n #integrand_all[~u_mask] = np.exp(u_arr[~u_mask]**2) * (1. + erf(u_arr[~u_mask]))\\n return integrand_all\\n\\n\\n mu_v = self.mu(v)\\n sd_v = self.sd(v)\\n low = (self.V_r - mu_v) / sd_v # reduced resting potential\\n up = (self.theta - mu_v) / sd_v # reduced threshold\\n f_low = integrand(low)\\n f_up = integrand(up)\\n jac_mat_1 = self.tau_m * 1e-3 * np.sqrt(np.pi) * self.mat_mu\\n jac_mat_2 = self.tau_m * 1e-3 * np.sqrt(np.pi) * self.mat_var / (2. * sd_v**2)\\n\\n jac_T = np.diag(1. / v**2) - \\\\\\n jac_mat_1.T * (f_up - f_low) + \\\\\\n jac_mat_2.T * (f_up * up - f_low * low)\\n return jac_T.T\",\n \"def get_initial_condition_euler(self, tol=1e-10):\\n Z = zeros((len(self._meshes), len(self._meshes[0].elements)+1))\\n for mi, m in enumerate(self._meshes):\\n if not m._left_lift:\\n raise Exception(\\\"get_initial_condition_euler() only works if all boundary conditions are given on the left.\\\")\\n\\n Z[mi, 0] = m._left_value\\n def get_F(Z, t):\\n \\\"\\\"\\\"\\n Evaluates the RHS for the vector Z and time tau.\\n \\\"\\\"\\\"\\n Z0 = zeros((len(self._meshes),))\\n for mi, m in enumerate(self._meshes):\\n Z0[mi] = self._F(mi, Z, t)\\n return Z0\\n def get_phi(Z, Zprev, tau, t):\\n return Z - tau*get_F(Z, t) - Zprev\\n def get_J(Z, tau, t):\\n mat = eye(len(self._meshes))\\n for i in range(len(self._meshes)):\\n for j in range(len(self._meshes)):\\n mat[i, j] += - tau*self._DFDY(i, j, Z, t)\\n return mat\\n\\n # initial time and initial condition vector:\\n tprev = self._meshes[0].elements[0].nodes[0].x\\n Zprev = Z[:, 0].copy()\\n Znext = Zprev[:].copy()\\n for el_i in range(len(self._meshes[0].elements)):\\n #print \\\"doing element:\\\", el_i\\n tau = self._meshes[0].elements[el_i].length\\n tnext = tprev + tau\\n error = 1e10\\n i = 0\\n while error > tol:\\n J = get_J(Zprev, tau, tprev)\\n phi = get_phi(Znext, Zprev, tau, tprev)\\n dZ = solve(J, -phi)\\n Znext += dZ\\n error_dZ = l2_norm(dZ)\\n error_phi = l2_norm(get_phi(Znext, Zprev, tau, tnext))\\n #print \\\"it=%d, l2_norm_dZ=%e, l2_norm_phi=%e\\\" % \\\\\\n # (i, error_dZ, error_phi)\\n error = max(error_dZ, error_phi)\\n i += 1\\n Z[:, el_i+1] = Znext[:].copy()\\n Zprev = Znext[:].copy()\\n tprev = tnext\\n\\n\\n # now assign the Z to the vertex dofs and leave zeros in the bubbles\\n Y = zeros((self.ndofs,))\\n for mi, m in enumerate(self._meshes):\\n coeffs_one_mesh = Z[mi, 1:]\\n Y[m.dof_start:m.dof_start+len(coeffs_one_mesh)] = coeffs_one_mesh\\n return Y\",\n \"def _find_new_candidate_and_update_parameters(\\n main_model,\\n hessian_info,\\n lambdas,\\n stopping_criteria,\\n converged,\\n):\\n x_candidate = cho_solve(\\n (hessian_info.upper_triangular, False), -main_model.linear_terms\\n )\\n x_norm = np.linalg.norm(x_candidate)\\n\\n if x_norm <= 1 and lambdas.candidate == 0:\\n converged = True\\n\\n w = solve_triangular(hessian_info.upper_triangular, x_candidate, trans=\\\"T\\\")\\n w_norm = np.linalg.norm(w)\\n\\n newton_step = _compute_newton_step(lambdas, x_norm, w_norm)\\n\\n if x_norm < 1:\\n (\\n x_candidate,\\n hessian_info,\\n lambdas_new,\\n converged,\\n ) = _update_candidate_and_parameters_when_candidate_within_trustregion(\\n x_candidate,\\n main_model,\\n hessian_info,\\n lambdas,\\n newton_step,\\n stopping_criteria,\\n converged,\\n )\\n\\n else:\\n lambdas_new, converged = _update_lambdas_when_candidate_outside_trustregion(\\n lambdas,\\n newton_step,\\n x_norm,\\n stopping_criteria,\\n converged,\\n )\\n\\n return (\\n x_candidate,\\n hessian_info,\\n lambdas_new,\\n converged,\\n )\",\n \"def update_vrad_tolerance(self):\\n try:\\n value = float(self.edit_vrad_tolerance.text())\\n except:\\n value = None\\n self._get_selected_model().metadata[\\\"velocity_tolerance\\\"] = value\\n return None\",\n \"def _check_approx_fixed_point(V_current, V_previous, tol):\\n\\n # Compute the sup norm between `V_current` and `V_previous`\\n sup_norm = np.max(np.abs(V_current - V_previous))\\n\\n # Algorithm termination condition\\n fp = sup_norm <= tol\\n\\n return fp, sup_norm\",\n \"def update_total_speed_input_step(self,curr_v):\\n \\n tot_speed_input_east=np.dot(self.W_speed_east,self.speed_inputs_east)/self.N_e\\n tot_speed_input_west=np.dot(self.W_speed_west,self.speed_inputs_west)/self.N_e\\n tot_speed_input_north=np.dot(self.W_speed_north,self.speed_inputs_north)/self.N_e\\n tot_speed_input_south=np.dot(self.W_speed_south,self.speed_inputs_south)/self.N_e\\n\\n self.tot_speed_input_all_padded[:self.N_e,0]=\\\\\\n tot_speed_input_east+tot_speed_input_west+\\\\\\n tot_speed_input_north+tot_speed_input_south\\n \\n if self.use_eight_directions is True:\\n tot_speed_input_north_east=np.dot(self.W_speed_north_east,\\n self.speed_inputs_north_east)/self.N_e\\n tot_speed_input_north_west=np.dot(self.W_speed_north_west,\\n self.speed_inputs_north_west)/self.N_e\\n tot_speed_input_south_east=np.dot(self.W_speed_south_east,\\n self.speed_inputs_south_east)/self.N_e\\n tot_speed_input_south_west=np.dot(self.W_speed_south_west,\\n self.speed_inputs_south_west)/self.N_e\\n \\n self.tot_speed_input_all_padded[:self.N_e,0]+=\\\\\\n tot_speed_input_north_east+tot_speed_input_north_west+\\\\\\n tot_speed_input_south_east+tot_speed_input_south_west\\n \\n else:\\n \\n # diagonal move with four directions\\n if abs(curr_v[0])>0 and abs(curr_v[1])>0:\\n self.tot_speed_input_all_padded[:self.N_e,0]*=.5\",\n \"def relax_checker():\\n checker = 2\\n global v, vNew, n\\n for check in range(0,2):\\n for x in range(1,n):\\n for y in range(1,n):\\n if (x*(n+1) + y) % 2 == check:\\n v[x,y] = (v[x-1][y] + v[x+1][y] + v[x][y-1] + v[x][y+1])*0.25\",\n \"def __init__(self, v=30, *args, **kwargs):\\n super(Dumb, self).__init__(*args, **kwargs)\\n self.vmax=v\",\n \"def __init__(self, number_of_devices=5, v_gate=400, v_source=0, max_iterations=200, len_source=25,\\n width_source=17, len_gate=40, width_gate=17, width_structure=80, dx=1, dy=1):\\n self.number_of_devices = number_of_devices\\n self.v_gate = v_gate\\n self.v_source = v_source\\n self.max_iterations = max_iterations\\n self.len_source = len_source\\n self.width_source = width_source\\n self.len_gate = len_gate\\n self.width_gate = width_gate\\n self.width_structure = width_structure\\n self.dx = dx\\n self.dy = dy\\n\\n self.len_source = self.len_gate / self. dx\\n self.width_source = self.width_source / self.dy\\n self.len_gate = self.len_gate / self.dx\\n self.width_gate = width_source\\n self.width_structure = self.width_structure / self.dy\\n\\n self.v_bottom = 0\\n self.v_left = 0\\n self.v_right = 0\\n\\n # set dimensions of grid\\n self.len_x = int(self.number_of_devices * (self.len_source + self.len_gate) + self.len_source)\\n self.len_y = int(self.width_structure)\\n self.grid_x = range(0, self.len_x)\\n self.grid_y = range(0, self.len_y)\\n\\n # initialize solution\\n self.rows_init = len(self.grid_y)\\n self.columns_init = len(self.grid_x)\",\n \"def newtonraphson(self,g_temp,var_init):\\n n_step=0\\n error=np.linalg.norm(self.evaluate(var_init,g_temp))\\n\\n while (error > 1e-12 and n_step < 50):\\n #Improve solution while error is too large and the number of steps does not exceed a limit\\n J_inv=np.linalg.pinv(self.jacobian(var_init,g_temp))\\n var_new=var_init-np.dot(J_inv,self.evaluate(var_init,g_temp))\\n error=np.linalg.norm(self.evaluate(var_new,g_temp))\\n var_init=var_new\\n n_step+=1\\n\\n return var_init\",\n \"def simulate(initstate, t, timestep=forward, drive=donothing, bounds = [0.97, 0.97, 0.97, 0.97], saveinterval=10, beta=0.281105, eps=0.013, gamma=0.0880, mu=0.3, nu=0, dudt_x = dudt, dvdt_x = dvdt, dndt_x = dndt, grav=True, cori=True, advx=True, advy=True, attn=True): # gives surface height array of the system after evert dt\\n bounds = np.asarray(bounds, dtype=np.float32)\\n h, n, u, v, f, dx, dy, dt = [initstate[k] for k in ('h', 'n', 'u', 'v', 'lat', 'dx', 'dy', 'dt')]\\n \\n f = np.float32(((2*2*np.pi*np.sin(f*np.pi/180))/(24*3600))[:,np.newaxis])\\n \\n \\n du0 = np.zeros_like(u)\\n dv0 = np.zeros_like(v)\\n dn0 = np.zeros_like(n)\\n \\n \\n dndt_x(h, n, u, v, dx, dy, dn0)\\n dn = (dn0, np.copy(dn0), np.copy(dn0))\\n \\n dudt_x(h, n, f, u, v, dx, dy, du0)\\n du = (du0, np.copy(du0), np.copy(du0), np.copy(du0))\\n \\n dvdt_x(h, n, f, u, v, dx, dy, dv0)\\n dv = (dv0, np.copy(dv0), np.copy(dv0), np.copy(dv0))\\n \\n nu = (dx+dy)/1000\\n \\n mmax = np.max(np.abs(n))\\n landthresh = 1.5*np.max(n) # threshhold for when sea ends and land begins\\n itrs = int(np.ceil(t/dt))\\n saveinterval = np.int(saveinterval//dt)\\n assert (dt >= 0), 'negative dt!' # dont try if timstep is zero or negative\\n \\n ntt = np.zeros((np.int(np.ceil(itrs/saveinterval)),)+n.shape, dtype=np.float32)\\n maxn = np.zeros(n.shape, dtype=n.dtype) # max height in that area\\n \\n coastx = np.less(h, landthresh) # where the reflective condition is enforced on the coast\\n \\n print('simulating...')\\n try:\\n for itr in range(itrs):# iterate for the given number of iterations\\n if itr%saveinterval == 0:\\n ntt[np.int(itr/saveinterval),:,:] = n\\n print(np.argmax( ntt[np.int(itr/saveinterval),:,:],axis=0)[5])\\n \\n \\n maxn = np.max((n, maxn), axis=0) # record new maxes if they are greater than previous records \\n \\n # pushes n, u, v one step into the future\\n n,u,v, du, dv, dn = timestep(h, n, u, v, f, dt, dx, dy, du, dv, dn, beta=beta, eps=eps, gamma=gamma, mu=mu, nu=nu, dudt_x=dudt_x, dvdt_x=dvdt_x, dndt_x=dndt_x, grav=grav, cori=cori, advx=advx, advy=advy, attn=attn)\\n\\n land(h, n, u, v, coastx) # how to handle land/coast\\n border(n, u, v, 15, bounds) \\n drive(h, n, u, v, f, dt, dx, dy, nu, coastx, bounds, mu, itr)\\n print('simulation complete')\\n except Exception as e:\\n print('timestep: ', itr)\\n raise e\\n return ntt, maxn#, minn, timemax # return surface height through time and maximum heights\",\n \"def construct_inv_boundaries(params,par_dict,eq_dict,K_RC,K_CP,m_P):\\n #intrapop params\\n q1=par_dict['q1']\\n q2=par_dict['q2']\\n K =par_dict['K']\\n m_C= K_CP*m_P\\n q10 = params['q10']\\n q20 = params['q20']\\n hC0 = params['hC0']\\n hP0 = params['hP0']\\n\\n #interpop params\\n a1=par_dict['a1']\\n a2=par_dict['a2']\\n a3=par_dict['a3']\\n e1=params['e1']\\n e2=params['e2']\\n e3=params['e3']\\n \\n\\n t_hc = par_dict['t_hc']\\n t_hp = par_dict['t_hp']\\n\\n #eq values\\n\\n #L-V\\n R_eq_s2 = eq_dict['R_eq_s2']\\n C_eq_s2 = eq_dict['C_eq_s2']\\n P_eq_s3 = eq_dict['P_eq_s3']\\n R_eq_s3 = eq_dict['R_eq_s3']\\n #R-M\\n R_eq_s2RM = eq_dict['R_eq_s2RM']\\n C_eq_s2RM = eq_dict['C_eq_s2RM']\\n R_eq_s3RM = eq_dict['R_eq_s3RM']\\n P_eq_s3RM = eq_dict['P_eq_s3RM']\\n \\n ##Invasibility boundaries\\n\\n #L-V\\n I_C_s2 = set_I_C_s2(e1,a1,K,q1)\\n I_P_s3 = set_I_P_s3(e2,a2,K,q2)\\n I_P_s4 = set_I_P_s4(e2,e3,a2,a3,q2,R_eq_s2,C_eq_s2)\\n I_C_s5 = set_I_C_s5(e1,a1,a3,R_eq_s3,P_eq_s3,q1)\\n \\n #R-M\\n I_C_s2RM = set_I_C_s2RM(e1,a1,K,q1,hC0,q10)\\n I_P_s3RM = set_I_P_s3RM(e2,a2,K,q2,hP0,q20)\\n I_P_s4RM = set_I_P_s4RM(e2,e3,a2,a3,q2,R_eq_s2RM,C_eq_s2RM,hP0,q20)\\n I_C_s5RM = set_I_C_s5RM(e1,e2,a1,a3,m_C,R_eq_s3RM,P_eq_s3RM,q1,t_hc,q10,q20,hP0,hC0) \\n\\n inv_dict= {'I_C_s2':I_C_s2,'I_P_s3':I_P_s3,'I_P_s4':I_P_s4,'I_C_s5':I_C_s5,\\n 'I_C_s2RM':I_C_s2RM,'I_P_s3RM':I_P_s3RM,'I_P_s4RM':I_P_s4RM,'I_C_s5RM':I_C_s5RM}\\n\\n return inv_dict\",\n \"def solve(bo):\\n find = find_empty(bo)\\n\\n if find:\\n row, col = find\\n else:\\n return True\\n\\n for i in range(1,10):\\n if valid(bo, (row, col), i):\\n bo[row][col] = i\\n\\n if solve(bo):\\n return True\\n\\n bo[row][col] = 0\\n\\n return False\",\n \"def solve(self):\\n if self.is_solved():\\n return True\\n else:\\n empty_box_coordinates = self._find_empty()\\n row, column = empty_box_coordinates\\n for i in range(1, 10):\\n if self.is_valid_number(i, empty_box_coordinates):\\n self.model[row][column] = i\\n\\n if self.solve():\\n return True\\n\\n self.model[row][column] = 0\\n return False\",\n \"def Solve(self,iter_val=0):\\n\\n ### Save Files before solve ###\\n self.fprint(\\\"Saving Input Data\\\",special=\\\"header\\\")\\n if \\\"mesh\\\" in self.params.output:\\n self.problem.dom.Save(val=iter_val)\\n if \\\"initial_guess\\\" in self.params.output:\\n self.problem.bd.SaveInitialGuess(val=iter_val)\\n if \\\"height\\\" in self.params.output and self.problem.dom.dim == 3:\\n self.problem.bd.SaveHeight(val=iter_val)\\n if \\\"turbine_force\\\" in self.params.output:\\n self.problem.farm.SaveRotorDisks(val=iter_val)\\n self.fprint(\\\"Finished\\\",special=\\\"footer\\\")\\n\\n ####################################################################\\n ### This is the better way to define a nonlinear problem but it \\n ### doesn't play nice with dolfin_adjoint\\n # ### Define Jacobian ###\\n # dU = TrialFunction(self.problem.fs.W)\\n # J = derivative(self.problem.F, self.problem.up_next, dU)\\n\\n # ### Setup nonlinear solver ###\\n # nonlinear_problem = NonlinearVariationalProblem(self.problem.F, self.problem.up_next, self.problem.bd.bcs, J)\\n # nonlinear_solver = NonlinearVariationalSolver(nonlinear_problem)\\n\\n # ### Set some parameters ###\\n # solver_parameters = nonlinear_solver.parameters\\n # solver_parameters[\\\"nonlinear_solver\\\"] = \\\"snes\\\"\\n # solver_parameters[\\\"snes_solver\\\"][\\\"linear_solver\\\"] = \\\"mumps\\\"\\n # solver_parameters[\\\"snes_solver\\\"][\\\"maximum_iterations\\\"] = 50\\n # solver_parameters[\\\"snes_solver\\\"][\\\"error_on_nonconvergence\\\"] = False\\n # solver_parameters[\\\"snes_solver\\\"][\\\"line_search\\\"] = \\\"bt\\\" # Available: basic, bt, cp, l2, nleqerr\\n\\n ### Solve the problem ###\\n # self.fprint(\\\"Solving\\\",special=\\\"header\\\")\\n # start = time.time()\\n # iters, converged = nonlinear_solver.solve()\\n # stop = time.time()\\n # self.fprint(\\\"Total Nonlinear Iterations: {:d}\\\".format(iters))\\n # self.fprint(\\\"Converged Successfully: {0}\\\".format(converged))\\n ####################################################################\\n\\n\\n nonlinear_solver = self.params[\\\"solver\\\"].get(\\\"nonlinear_solver\\\", \\\"snes\\\")\\n relaxation = self.params[\\\"solver\\\"].get(\\\"newton_relaxation\\\", 1.0)\\n\\n self.fprint(\\\"Solving with {0}\\\".format(nonlinear_solver))\\n if nonlinear_solver == \\\"newton\\\":\\n self.fprint(\\\"Relaxation parameter = {: 1.2f}\\\".format(relaxation))\\n\\n newton_options = {\\\"relaxation_parameter\\\": relaxation,\\n \\\"maximum_iterations\\\": 40,\\n \\\"linear_solver\\\": \\\"mumps\\\",\\n \\\"absolute_tolerance\\\": 1e-6,\\n \\\"relative_tolerance\\\": 1e-5}\\n \\n solver_parameters = {\\\"nonlinear_solver\\\": \\\"newton\\\",\\n \\\"newton_solver\\\": newton_options}\\n\\n elif nonlinear_solver == \\\"snes\\\":\\n # ### Add some helper functions to solver options ###\\n solver_parameters = {\\\"nonlinear_solver\\\": \\\"snes\\\",\\n \\\"snes_solver\\\": {\\n \\\"linear_solver\\\": \\\"mumps\\\", \\n \\\"maximum_iterations\\\": 40,\\n \\\"error_on_nonconvergence\\\": True,\\n \\\"line_search\\\": \\\"bt\\\",\\n }}\\n \\n else:\\n raise ValueError(\\\"Unknown nonlinear solver type: {0}\\\".format(nonlinear_solver))\\n\\n ### Start the Solve Process ###\\n self.fprint(\\\"Solving\\\",special=\\\"header\\\")\\n start = time.time()\\n \\n # ### Solve the Baseline Problem ###\\n # solve(self.problem.F_sans_tf == 0, self.problem.up_next, self.problem.bd.bcs, solver_parameters=solver_parameters, **self.extra_kwarg)\\n\\n # ### Store the Baseline and Assign for the real solve ###\\n # self.up_baseline = self.problem.up_next.copy(deepcopy=True)\\n # self.problem.up_next.assign(self.up_baseline)\\n\\n ### Solve the real problem ###\\n solve(self.problem.F == 0, self.problem.up_next, self.problem.bd.bcs, solver_parameters=solver_parameters)\\n stop = time.time()\\n self.fprint(\\\"Solve Complete: {:1.2f} s\\\".format(stop-start),special=\\\"footer\\\")\\n # self.u_next,self.p_next = self.problem.up_next.split(True)\\n self.u_next,self.p_next = split(self.problem.up_next)\\n # self.nu_T = project(self.problem.nu_T,self.problem.fs.Q,solver_type='mumps',**self.extra_kwarg)\\n self.nu_T = None\\n\\n\\n ### Save solutions ###\\n if \\\"solution\\\" in self.params.output:\\n self.fprint(\\\"Saving Solution\\\",special=\\\"header\\\")\\n self.Save(val=iter_val)\\n self.fprint(\\\"Finished\\\",special=\\\"footer\\\")\\n\\n ### calculate the power for each turbine ###\\n ###################################\\n ### Fix how angle is transfered ###\\n ###################################\\n if self.optimizing or self.save_power:\\n self.J += -self.CalculatePowerFunctional((iter_val-self.problem.dom.init_wind)) \\n\\n # self.fprint(\\\"Speed Percent of Inflow Speed\\\")\\n # ps = []\\n # for i in range(6):\\n # HH = self.problem.farm.HH[0]\\n # RD = self.problem.farm.RD[0]\\n # x_val = (i+1)*RD\\n # vel = self.problem.up_next([x_val,0,HH])\\n # vel = vel[0:3]\\n # nom = np.linalg.norm(vel)\\n # perc = nom/self.problem.bd.HH_vel\\n # ps.append(perc)\\n # self.fprint(\\\"Speed Percent at (\\\"+repr(int(x_val))+\\\", 0, \\\"+repr(HH)+\\\"): \\\"+repr(perc))\\n # print(ps)\",\n \"def solve_nonlinear(self, params, unknowns, resids):\\n\\n x = params['x']\\n z = unknowns['z']\\n znew = z\\n\\n iter = 0\\n eps = 1.0e99\\n while iter < self.maxiter and abs(eps) > self.atol:\\n z = znew\\n znew = 4.0 - x*z\\n\\n eps = x*znew + znew - 4.0\\n\\n unknowns['z'] = znew\\n unknowns['y'] = x + 2.0*znew\\n\\n resids['z'] = eps\\n #print(unknowns['y'], unknowns['z'])\",\n \"def start_solving(self):\\n self.mesh.output_vtk_mesh(self.model_name + \\\"0\\\", \\n [self.current_pressure, \\n self.mesh.get_cell_domain_all()], \\n [\\\"pressure\\\", \\\"domain\\\"])\\n\\n self.time_step_output(0., 0)\\n\\n for time_step in range(1,self.number_of_time_steps+1):\\n current_time = time_step*self.delta_t\\n print(time_step)\\n\\n self.update_pressure()\\n self.find_upwinding_direction()\\n self.update_concentration()\\n \\n if time_step%self.output_frequency == 0:\\n self.mesh.output_vtk_mesh(self.model_name+str(time_step), \\n [self.current_pressure,\\n self.current_concentration, \\n self.mesh.get_cell_domain_all()],\\n [\\\"pressure\\\", \\\"concentration\\\" , \\\"domain\\\"])\\n\\n self.time_step_output(current_time, time_step)\",\n \"def optimizeposition(areas, omegas, x0, x1, z0, z1):\\n\\n # initial position of each quadpoint is at the center\\n # of the edge connecting the midpoint and a corner point\\n rhos = 0.5 * ones(4)\\n a = 1 / sqrt(3)\\n deltarhos = 0.25 * ones(4) # delta for finite differences\\n\\n while True: # while method has not converged\\n # print(\\\"################## new iteration #############\\\")\\n rhs = f(rhos, omegas, a, x0, x1, z0, z1, areas)\\n print(\\\"##\\\")\\n print(rhs)\\n print(rhos)\\n if norm(rhs) < 1e-5:\\n break\\n mat = df(rhos, omegas, a, x0, x1, z0, z1, areas, deltarhos)\\n update = solve(mat, rhs)\\n\\n rhos += update\\n # for i in range(4):\\n # rhos[i] = max(0,min(1,rhos[i]))\\n \\\"\\\"\\\"\\n print(\\\"the norm of the rhs is \\\")\\n print(norm(rhs))\\n print(mat)\\n print(\\\"rhs\\\")\\n print(rhs)\\n print(update)\\n print(\\\"rhos\\\")\\n print(rhos)\\n \\\"\\\"\\\"\\n # print(alpha)\\n return rhos\",\n \"def set_vb_param(self,vb_param):\\r\\n self.q_u_canonical_flat = vb_param.copy()\\r\\n self.q_u_canonical = self.q_u_canonical_flat[:self.num_inducing*self.output_dim].reshape(self.num_inducing,self.output_dim),self.q_u_canonical_flat[self.num_inducing*self.output_dim:].reshape(self.num_inducing,self.num_inducing)\\r\\n\\r\\n self.q_u_prec = -2.*self.q_u_canonical[1]\\r\\n self.q_u_cov, q_u_Li, q_u_L, tmp = pdinv(self.q_u_prec)\\r\\n self.q_u_Li = q_u_Li\\r\\n self.q_u_logdet = -tmp\\r\\n self.q_u_mean, _ = dpotrs(q_u_Li, np.asfortranarray(self.q_u_canonical[0]),lower=1)\\r\\n\\r\\n self.q_u_expectation = (self.q_u_mean, np.dot(self.q_u_mean,self.q_u_mean.T)+self.q_u_cov*self.output_dim)\",\n \"def __init__(self, temperature=298.0 * simtk.unit.kelvin, collision_rate=91.0 / simtk.unit.picoseconds, timestep=1.0 * simtk.unit.femtoseconds):\\n\\n # Compute constants.\\n kT = kB * temperature\\n gamma = collision_rate\\n\\n # Create a new custom integrator.\\n super(VVVRIntegrator, self).__init__(timestep)\\n\\n #\\n # Integrator initialization.\\n #\\n self.addGlobalVariable(\\\"kT\\\", kT) # thermal energy\\n self.addGlobalVariable(\\\"b\\\", numpy.exp(-gamma * timestep)) # velocity mixing parameter\\n self.addPerDofVariable(\\\"sigma\\\", 0)\\n self.addPerDofVariable(\\\"x1\\\", 0) # position before application of constraints\\n\\n #\\n # Allow context updating here.\\n #\\n self.addUpdateContextState()\\n\\n #\\n # Pre-computation.\\n # This only needs to be done once, but it needs to be done for each degree of freedom.\\n # Could move this to initialization?\\n #\\n self.addComputePerDof(\\\"sigma\\\", \\\"sqrt(kT/m)\\\")\\n\\n #\\n # Velocity perturbation.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Metropolized symplectic step.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"v + 0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x + v*dt\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v + 0.5*dt*f/m + (x-x1)/dt\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Velocity randomization\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\\\")\\n self.addConstrainVelocities()\",\n \"def compton(E, v):\\r\\n E = E/511 # Change to energy in units of electron mass\\r\\n continue_loop = True\\r\\n while continue_loop:\\r\\n # Determine Emin, Emax\\r\\n #E = 140 # keV\\r\\n Emin = E/(1+2*E)\\r\\n Emax = E\\r\\n \\r\\n # Determine normalisation constants\\r\\n A1_f = lambda E: E\\r\\n A2_f = lambda E: 1/E\\r\\n A1 = 1/scipy.integrate.quad(A1_f, Emin, Emax)[0]\\r\\n A2 = 1/scipy.integrate.quad(A2_f, Emin, Emax)[0]\\r\\n \\r\\n # Determine alpha\\r\\n a1 = 1/(A1*E)\\r\\n a2 = E/A2\\r\\n \\r\\n gamma = random.random() # Random num to determine which distribution eps should be sampled from\\r\\n if gamma < a1/(a1+a2):\\r\\n gamma = random.random() # Need to sample new gamma to sample an eps from this distribution\\r\\n eps = np.sqrt(Emin**2 + 2*gamma/A1)\\r\\n else:\\r\\n gamma = random.random() # Need to sample new gamma to sample an eps from this distribution\\r\\n eps = Emin*np.exp(gamma/A2)\\r\\n \\r\\n # Determine theta using eps and E\\r\\n sin2 = 1 - (1 - 1/eps + 1/E)**2\\r\\n theta = np.arcsin(np.sqrt(1 - (1 - 1/eps + 1/E)**2))\\r\\n \\r\\n gamma = random.random()\\r\\n if gamma < (1 - sin2/(eps/E + E/eps)): # I honestly don't know what this condition is. Refer to Vassilev ch. 2.8\\r\\n continue_loop = False\\r\\n eps = normal_distribution(eps,E)*511 # Comment this line to get rid of normal distribution. 511 returns us to units of keV\\r\\n #eps *= 511 # Comment this line if you want the normal distribution\\r\\n new_v = scattering_direction(v, theta)\\r\\n return eps, new_v\",\n \"def get_cell(twofold, verbose=False):\\n\\n\\n def check90(angle):\\n return abs(angle - (np.pi / 2)) < twofold['toll']\\n\\n def eqv(a, b, tola=0.2):\\n return abs(a - b) < tola\\n\\n def colinear(v1, v2):\\n return all(np.cross(v1, v2) == 0)\\n\\n\\n tr = np.identity(3, dtype=int)\\n d_base = twofold['dbase']\\n ntwo = len(twofold['uvw'])\\n\\n if ntwo == 9: # Case (9) !Cubic n-2foldaxes=9\\n mv = mt.mod(twofold['dv'])\\n for i, j, k in combinations(range(ntwo), 3):\\n vi = twofold['dv'][i]\\n vj = twofold['dv'][j]\\n vk = twofold['dv'][k]\\n aij = mt.angle_between_vectors(vi, vj)\\n aik = mt.angle_between_vectors(vi, vk)\\n ajk = mt.angle_between_vectors(vj, vk)\\n if check90(aij) and check90(aik) and check90(ajk):\\n eij = eqv(mv[i], mv[j])\\n eik = eqv(mv[i], mv[k])\\n ejk = eqv(mv[j], mv[k])\\n if eij and eik and ejk:\\n v1 = vi\\n v2 = vj\\n v3 = vk\\n tr = np.array([twofold['uvw'][i] for i in [i, j, k]])\\n break\\n\\n # check rightness\\n namina = nl.det(tr)\\n if namina < 0:\\n tr[3] *= -1\\n v3 *= -1\\n namina *= -1\\n\\n if namina == 0:\\n print(\\\"Pseudo-cubic but tolerance too small ... \\\")\\n ok = False\\n return\\n if namina == 1:\\n print(\\\"Cubic, Primitive cell\\\")\\n if namina == 2:\\n if not(mt.coprime(np.dot([0, 1, 1], tr))):\\n print(\\\"Cubic, A-centred cell\\\")\\n elif not(mt.coprime(np.dot([1, 1, 1], tr))):\\n print(\\\"Cubic, I-centred cell\\\")\\n elif not(mt.coprime(np.dot([1, 1, 0], tr))):\\n print(\\\"Cubic, C-centred cell\\\")\\n elif not(mt.coprime(np.dot([1, 0, 1], tr))):\\n print(\\\"Cubic, B-centred cell\\\")\\n if namina >= 3:\\n print(\\\"Cubic, F-centred cell\\\")\\n\\n if ntwo == 7: # Case (7) !Hexagonal n-2foldaxes=7\\n hexap = False\\n hexac = False\\n\\n mv = mt.mod(twofold['dv'])\\n order = np.argsort(mv)\\n twofold['sigma'] = twofold['sigma'][order]\\n twofold['uvw'] = twofold['uvw'][order]\\n twofold['hkl'] = twofold['hkl'][order]\\n twofold['dv'] = twofold['dv'][order]\\n twofold['rv'] = twofold['rv'][order]\\n mv = mt.mod(twofold['dv'])\\n\\n # Search tha a-b plane\\n for i, j in combinations(range(ntwo), 2):\\n vi = twofold['dv'][i]\\n vj = twofold['dv'][j]\\n aij = mt.angle_between_vectors(vi, vj)\\n if abs(aij - (2 * np.pi / 3.0)) < twofold['toll']:\\n if (abs(mv[i] - mv[j]) < tola):\\n v1 = vi\\n v2 = vj\\n v1_i, v2_i = i, j\\n hexap = True\\n break\\n\\n\\n # then ! Search the c-axis, it should be also\\n # a two-fold axis! because Op(6).Op(6).Op(6)=Op(2)\\n if hexap:\\n for i in range(ntwo):\\n vi = twofold['dv'][i]\\n aij = mt.angle_between_vectors(v1, vi)\\n aik = mt.angle_between_vectors(v2, vi)\\n if check90(aij) and check90(aik):\\n v3 = vi\\n v3_i = i\\n hexac = True\\n break\\n else:\\n ok = False\\n if verbose:\\n print('no axes 90 to hexagonal')\\n if hexac:\\n tr = np.array([twofold['uvw'][v1_i],\\n twofold['uvw'][v2_i],\\n twofold['uvw'][v3_i]])\\n\\n namina = int(nl.det(tr))\\n if (namina < 0):\\n tr[2] *= -1\\n v3 *= -1\\n namina *= -1\\n if namina == 1:\\n print(\\\"Hexagonal, Primitive cell\\\")\\n elif namina > 1:\\n print(\\\"Hexagonal, centred cell? possible mistake\\\")\\n else:\\n print('azzo', namina)\\n else:\\n ok = False\\n print(\\\"The c-axis of a hexagonal cell was not found!\\\")\\n return\\n\\n if ntwo == 5: # Case (5) !Tetragonal n-2foldaxes=5\\n ab = []\\n inp = np.zeros(5)\\n mv = mt.mod(twofold['dv']) # modulus twofold vector\\n\\n for i, j in combinations(range(ntwo), 2):\\n vi = twofold['dv'][i]\\n vj = twofold['dv'][j]\\n m = mt.angle_between_vectors(vi, vj)\\n c45 = abs(m - (np.pi * 0.25)) < twofold['toll']\\n c135 = abs(m - (np.pi * 0.75)) < twofold['toll']\\n if c45 or c135:\\n inp[i] = 1\\n inp[j] = 1\\n ab.append([i, j][np.argmin(mv[[i, j]])])\\n ab = list(set(ab))\\n if len(ab) < 2:\\n ok = False\\n if verbose:\\n print(\\\"Basis vectors a-b not found!\\\")\\n return\\n # !Determination of the c-axis\\n # (that making 90 degree with all the others)\\n naminc = np.argmin(inp)\\n # !The two axes forming a,b are those of indices ab(1) and ab(2)\\n namina = ab[0]\\n naminb = ab[1]\\n\\n tr[0] = twofold['uvw'][namina]\\n tr[1] = twofold['uvw'][naminb]\\n tr[2] = twofold['uvw'][naminc]\\n v1 = twofold['dv'][namina]\\n v2 = twofold['dv'][naminb]\\n v3 = twofold['dv'][naminc]\\n\\n namina = nl.det(tr)\\n if (namina < 0):\\n tr[2] = -tr[2]\\n v3 = -v3\\n namina = -namina\\n\\n if namina == 1:\\n print(\\\"Tetragonal, Primitive cell\\\")\\n elif namina == 2:\\n print(\\\"Tetragonal, I-centred cell\\\")\\n else:\\n print(\\\"Error in tetragonal cell\\\")\\n ok = False\\n\\n if ntwo == 3: # Case (3) !Orthorhombic/Trigonal n-2foldaxes=3\\n u = mt.mod(twofold['dv'])\\n a_i, b_i, c_i = np.argsort(u)\\n tr[0, :] = twofold['uvw'][a_i]\\n tr[1, :] = twofold['uvw'][b_i]\\n tr[2, :] = twofold['uvw'][c_i]\\n\\n v1 = twofold['dv'][a_i]\\n v2 = twofold['dv'][b_i]\\n v3 = twofold['dv'][c_i]\\n\\n ang = np.array([mt.angle_between_vectors(v3, v2),\\n mt.angle_between_vectors(v1, v3),\\n mt.angle_between_vectors(v1, v2)])\\n\\n # Check the system by verifying that the two-fold axes\\n # form 90 (orthorhombic)\\n if all([check90(i) for i in ang]): # if !orthorhombic\\n namina = nl.det(tr)\\n if namina < 0:\\n tr[2, :] *= -1\\n v3 *= -1\\n namina *= -1\\n\\n if namina == 1:\\n print(\\\"Orthorhombic, Primitive cell\\\")\\n elif namina == 2:\\n vecs = [[0, 1, 1], [1, 1, 1], [1, 1, 0], [1, 0, 1]]\\n for rw_i, rw in enumerate(vecs):\\n if not(mt.coprime(np.dot(rw, tr))):\\n orthoType = rw_i\\n break\\n message = [\\\"Orthorhombic, A-centred cell\\\",\\n \\\"Orthorhombic, I-centred cell\\\",\\n \\\"Orthorhombic, C-centred cell\\\",\\n \\\"Orthorhombic, B-centred cell\\\"]\\n print(message[orthoType])\\n if namina >= 3:\\n print(\\\"Orthorhombic, F-centred cell\\\")\\n\\n else: # !Rhombohedral/Trigonal\\n # In the Trigonal system the two-fold axes are in the plane\\n # the three-fold axis, and valid a,b, vectors can be chosen\\n # among any two two-fold axes forming an angle of 120 degrees\\n # verify that 1 and 2 form 120 \\n if any(abs(ang - (2 * np.pi / 3)) < twofold['toll']): # search 120\\n res = np.argmin(abs(ang - (2 * np.pi / 3)))\\n if res == 0:\\n v1, v2, v3 = v2, v3, v1\\n tr = tr[[1, 2, 0]]\\n elif res == 1:\\n v1, v2, v3 = v1, v3, v2\\n tr = tr[[0, 2, 1]]\\n\\n elif any(abs(ang - (np.pi / 3)) < twofold['toll']): # search 60\\n res = np.argmin(abs(ang - (np.pi / 3)))\\n if res == 0:\\n v1, v2, v3 = v2, -v3, v1\\n tr = tr[[1, 2, 0]]\\n elif res == 1:\\n v1, v2, v3 = v1, -v3, v2\\n tr = tr[[0, 2, 1]]\\n else:\\n v2 = -v2\\n tr[1] = -tr[1]\\n else:\\n if verbose:\\n print(\\\"Trigonal/Rhombohedral test failed! \\\\\\n \\\\nSupply only one two-fold axis\\\")\\n ok = False\\n return\\n\\n ok = False\\n for uvw in nestedLoop(range(-3, 4), range(-3, 4), range(0, 4)):\\n if not(mt.coprime(uvw)):\\n continue\\n vec = np.dot(d_base, uvw)\\n ang1 = mt.angle_between_vectors(vec, v1)\\n ang2 = mt.angle_between_vectors(vec, v2)\\n if check90(ang1) and check90(ang2):\\n tr[2, :] = uvw\\n ok = True\\n break\\n if ok:\\n namina = np.round(nl.det(tr), 4)\\n if namina < 0:\\n tr[2, :] *= -1\\n namina *= -1\\n v3 = np.dot(d_base, tr[2])\\n if namina == 1:\\n print(\\\"Rhombohedral Primitive hexagonal cell\\\")\\n\\n elif namina == 3:\\n rw = np.dot([2, 1, 1], tr)\\n if not(mt.coprime(rw)):\\n print(\\\"Rhombohedral, obverse setting cell\\\")\\n else:\\n print(\\\"Rhombohedral, reverse setting cell\\\")\\n else:\\n print(\\\"Trigonal/Rhombohedral test failed!\\\")\\n print(\\\" Supply only one two-fold axis\\\")\\n\\n if ntwo == 1: # Case (3) !Monoclinic n-2foldaxes=1\\n v2 = twofold['dv'][0]\\n tr[1] = twofold['uvw'][0]\\n row = []\\n for rw in nestedLoop(range(-3, 4), range(-3, 4), range(0, 4)):\\n if all(np.array(rw) == 0):\\n continue\\n if not(mt.coprime(rw)):\\n continue\\n vec = np.dot(d_base, rw)\\n if check90(mt.angle_between_vectors(v2, vec)):\\n if any([colinear(rw, i) for i in row]):\\n continue\\n else:\\n row.append(np.array(rw))\\n\\n\\n row_mod = np.array([mt.mod(np.dot(d_base, i)) for i in row])\\n rms = np.argsort(row_mod)\\n tr[0] = row[rms[0]]\\n v1 = np.dot(d_base, tr[0, :])\\n tr[2] = row[rms[1]]\\n v3 = np.dot(d_base, tr[2, :])\\n\\n # Test rightness\\n if nl.det(tr) < 0:\\n tr[1, :] = -tr[1, :]\\n v2 = -v2\\n\\n # Test if beta is lower than 90 in such a case invert c and b\\n if mt.angle_between_vectors(v1, v3) < (np.pi / 2): # !angle beta < 90\\n tr[0, :] = -tr[0, :]\\n v1 = -v1\\n tr[2, :] = -tr[2, :]\\n v2 = -v2\\n\\n namina = nl.det(tr)\\n if namina == 1:\\n print(\\\"Monoclinic, Primitive cell\\\")\\n if namina == 2:\\n if not(mt.coprime(np.dot([1, 1, 0], tr))):\\n print(\\\"Monoclinic, C-centred cell\\\")\\n if not(mt.coprime(np.dot([0, 1, 1], tr))):\\n print(\\\"Monoclinic, A-centred cell\\\")\\n\\n if ntwo not in [1, 3, 5, 7, 9]:\\n print(\\\"Wrong number of two-fold axes! \\\", ntwo)\\n ok = False\\n return\\n # Calculation of the new cell\\n alpha = np.degrees(mt.angle_between_vectors(v2, v3))\\n beta = np.degrees(mt.angle_between_vectors(v1, v3))\\n gamma = np.degrees(mt.angle_between_vectors(v1, v2))\\n a = mt.mod(v1)\\n b = mt.mod(v2)\\n c = mt.mod(v3)\\n print(f'a={round(a,2)}, b={round(b,2)}, c={round(c,2)},',\\n f'alpha={round(alpha,2)}, beta={round(beta,2)},',\\n f'gamma={round(gamma,2)}')\\n ok = True\\n return [a, b, c, alpha, beta, gamma], tr\",\n \"def __init__(self, m,r,v):\\n self.m = m\\n self.r = r\\n self.v = v\\n self.rv = np.array([r,0,0,v])\",\n \"def _reset_solution(self, firm_size):\\n x_lower, x_upper = self.model.workers.lower, self.model.workers.upper\\n y_upper = self.model.firms.upper\\n initial_V = np.array([y_upper, firm_size])\\n\\n if self.model.assortativity == 'positive':\\n self.ivp.set_initial_value(initial_V, x_upper)\\n wage = self.evaluate_wage(x_upper, initial_V)\\n profit = self.evaluate_profit(x_upper, initial_V)\\n self._solution = np.hstack((x_upper, initial_V, wage, profit))\\n else:\\n self.ivp.set_initial_value(initial_V, x_lower)\\n wage = self.evaluate_wage(x_lower, initial_V)\\n profit = self.evaluate_profit(x_lower, initial_V)\\n self._solution = np.hstack((x_lower, initial_V, wage, profit))\",\n \"def testNonVarying(self):\\n photoCalib = lsst.afw.image.PhotoCalib(self.calibration)\\n self._testPhotoCalibCenter(photoCalib, 0)\\n\\n self.assertEqual(1, photoCalib.instFluxToMaggies(self.instFlux, self.pointXShift))\\n self.assertEqual(0, photoCalib.instFluxToMagnitude(self.instFlux, self.pointXShift))\\n result = photoCalib.instFluxToMaggies(self.instFlux, self.instFluxErr)\\n self.assertEqual(1, result.value)\\n\\n photoCalib = lsst.afw.image.PhotoCalib(self.calibration, self.calibrationErr)\\n self._testPhotoCalibCenter(photoCalib, self.calibrationErr)\\n\\n # constant, with a bbox\\n photoCalib = lsst.afw.image.PhotoCalib(self.calibration, bbox=self.bbox)\\n self._testPhotoCalibCenter(photoCalib, 0)\",\n \"def test_zPartialCurrents(self):\\n # node 15 (ring=2, position=3), axial=3, group=3, j=1 (z-plus)\\n iNode, iz, ig, j = 14, 2, 2, 0\\n self.assertAlmostEqual(\\n self.nhf.partialCurrentsZ[iNode, iz, j, ig] / 1.6928521e06, 1.0\\n )\",\n \"def _get_kriging_matrix(self, n, exact_values):\\n\\n xyz = np.concatenate((self.X_ADJUSTED[:, np.newaxis],\\n self.Y_ADJUSTED[:, np.newaxis],\\n self.Z_ADJUSTED[:, np.newaxis]), axis=1)\\n d = cdist(xyz, xyz, 'euclidean')\\n a = np.zeros((n+1, n+1))\\n a[:n, :n] = - self.variogram_function(self.variogram_model_parameters, d)\\n if not exact_values:\\n if self.variogram_model == 'linear':\\n np.fill_diagonal(a, self.variogram_model_parameters[1])\\n elif self.variogram_model != 'custom':\\n np.fill_diagonal(a, self.variogram_model_parameters[2])\\n else :\\n np.fill_diagonal(a, 0.)\\n a[n, :-1] = 1.0\\n a[:-1, n] = 1.0\\n\\n return a\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6296358","0.6104716","0.59339637","0.5927703","0.5892736","0.58395153","0.58070314","0.58070314","0.5806339","0.5777011","0.5720289","0.5665781","0.55881447","0.5543292","0.55227625","0.552212","0.55061567","0.5506091","0.5480284","0.5473143","0.5467505","0.54668427","0.5455181","0.54287493","0.54260427","0.5382687","0.5367455","0.5345759","0.5324117","0.5322873","0.53052723","0.5299711","0.5294564","0.5294366","0.52859247","0.52700573","0.5268174","0.52635676","0.526272","0.5256428","0.52432466","0.5227699","0.5226098","0.52217156","0.52057505","0.5204466","0.51979727","0.518907","0.5185411","0.51748914","0.5173568","0.5173505","0.51647323","0.5162583","0.5147853","0.51474774","0.51453054","0.5143242","0.51431376","0.51395196","0.51393133","0.51391596","0.5125207","0.5121397","0.5108885","0.5105096","0.50999475","0.50704175","0.5069606","0.50636905","0.50621706","0.50582796","0.5058046","0.5049564","0.50476885","0.5038318","0.50328153","0.50317067","0.50300014","0.5028266","0.5025105","0.50193614","0.5014257","0.5013396","0.5006903","0.50035316","0.49996108","0.49995106","0.49958068","0.49950933","0.4987253","0.4980133","0.49789274","0.49788818","0.49682873","0.496367","0.49608436","0.49466124","0.49460864","0.4943247"],"string":"[\n \"0.6296358\",\n \"0.6104716\",\n \"0.59339637\",\n \"0.5927703\",\n \"0.5892736\",\n \"0.58395153\",\n \"0.58070314\",\n \"0.58070314\",\n \"0.5806339\",\n \"0.5777011\",\n \"0.5720289\",\n \"0.5665781\",\n \"0.55881447\",\n \"0.5543292\",\n \"0.55227625\",\n \"0.552212\",\n \"0.55061567\",\n \"0.5506091\",\n \"0.5480284\",\n \"0.5473143\",\n \"0.5467505\",\n \"0.54668427\",\n \"0.5455181\",\n \"0.54287493\",\n \"0.54260427\",\n \"0.5382687\",\n \"0.5367455\",\n \"0.5345759\",\n \"0.5324117\",\n \"0.5322873\",\n \"0.53052723\",\n \"0.5299711\",\n \"0.5294564\",\n \"0.5294366\",\n \"0.52859247\",\n \"0.52700573\",\n \"0.5268174\",\n \"0.52635676\",\n \"0.526272\",\n \"0.5256428\",\n \"0.52432466\",\n \"0.5227699\",\n \"0.5226098\",\n \"0.52217156\",\n \"0.52057505\",\n \"0.5204466\",\n \"0.51979727\",\n \"0.518907\",\n \"0.5185411\",\n \"0.51748914\",\n \"0.5173568\",\n \"0.5173505\",\n \"0.51647323\",\n \"0.5162583\",\n \"0.5147853\",\n \"0.51474774\",\n \"0.51453054\",\n \"0.5143242\",\n \"0.51431376\",\n \"0.51395196\",\n \"0.51393133\",\n \"0.51391596\",\n \"0.5125207\",\n \"0.5121397\",\n \"0.5108885\",\n \"0.5105096\",\n \"0.50999475\",\n \"0.50704175\",\n \"0.5069606\",\n \"0.50636905\",\n \"0.50621706\",\n \"0.50582796\",\n \"0.5058046\",\n \"0.5049564\",\n \"0.50476885\",\n \"0.5038318\",\n \"0.50328153\",\n \"0.50317067\",\n \"0.50300014\",\n \"0.5028266\",\n \"0.5025105\",\n \"0.50193614\",\n \"0.5014257\",\n \"0.5013396\",\n \"0.5006903\",\n \"0.50035316\",\n \"0.49996108\",\n \"0.49995106\",\n \"0.49958068\",\n \"0.49950933\",\n \"0.4987253\",\n \"0.4980133\",\n \"0.49789274\",\n \"0.49788818\",\n \"0.49682873\",\n \"0.496367\",\n \"0.49608436\",\n \"0.49466124\",\n \"0.49460864\",\n \"0.4943247\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81041306"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81594,"cells":{"query":{"kind":"string","value":"One checkerrelax iteration. v[i,j] is set as the avarage of its neighbours."},"document":{"kind":"string","value":"def relax_checker():\n checker = 2\n global v, vNew, n\n for check in range(0,2):\n for x in range(1,n):\n for y in range(1,n):\n if (x*(n+1) + y) % 2 == check:\n v[x,y] = (v[x-1][y] + v[x+1][y] + v[x][y-1] + v[x][y+1])*0.25"},"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 relaxVertex(self, v):\r\n for arc in self.graph.getAdj(v):\r\n neighbour = arc.getExtremityNode()\r\n if neighbour in self.closed_set:\r\n continue\r\n self.nb_relax_edges += 1\r\n new_dist = self.dists_so_far[v] + arc.getWeight()\r\n # print(arc.getTravelType(), arc.getWeight(), end=\" \")\r\n if neighbour not in self.preds or new_dist < self.dists_so_far[neighbour]:\r\n self.preds[neighbour] = v\r\n self.dists_so_far[neighbour] = new_dist\r\n self.pushPriorityQueue((new_dist, neighbour))","def _relax(self, G, v):\n for e in G.adj(v):\n w = e.get_to()\n if self._distTo[w] > self._distTo[v] + e.weight()):\n self._distTo[w] = self._distTo[v] + e.weight()\n self._edgeTo[w] = e\n if not self._onQueue[w]:\n self_queue.append(w) # enqueue(w)\n self._onQueue[w] = True\n if self._cost%G.V() == 0:\n self.findNegativeCycle()\n if self.hasNegativeCycle(): return # found a negative cycle\n self._cost += 1","def iterate_value(self):\n self.V = np.zeros(self.stateCount)\n for i in range(self.maxIter):\n last_V = np.copy(self.V)\n for state_index in range(self.stateCount):\n current_state = self.env.statespace[state_index]\n for action in self.env.actionspace:\n next_state = self.env.next_state(current_state,action)\n reward = self.env.compute_reward(next_state)\n next_state_index = self.env.stateDict[next_state]\n self.Q[state_index][action] = reward + self.gamma*last_V[next_state_index]\n if self.mode == 'debug':\n print(\"Q(s={}):{}\".format(current_state,self.Q[state_index]))\n self.V[state_index] = max(self.Q[state_index])\n if np.sum(np.fabs(last_V - self.V)) <= self.th:\n print (\"Convergene Achieved in {}th iteration. \"\n \"Breaking V_Iteration loop!\".format(i))\n break","def calculate():\n global v, vNew, n, stepsToToleranceArray\n stepsToToleranceArray = []\n for n in nArray:\n print('Currently working with n = ', n)\n initiateVMatrixes()\n step = 0\n toleranceAcqurired = False\n while not toleranceAcqurired:\n step+=1\n relax_checker()\n # Controll accuracy\n toleranceAcqurired = True # run through v and set false if not acquired\n for i in range(1,n):\n for j in range(1,n):\n if np.abs( (v[i,j]-vExact[i,j])/vExact[i,j] ) > tolerance:\n toleranceAcqurired = False\n if toleranceAcqurired:\n stepsToToleranceArray.append(step)\n if n in [5,10]: print('n =', n, 'steps =', step)","def _arnoldi_fact(matvec, args, v0, krylov_vectors, H, start, num_krylov_vecs,\n eps):\n Z = jax.numpy.linalg.norm(v0)\n v = v0 / Z\n krylov_vectors = jax.ops.index_update(krylov_vectors,\n jax.ops.index[start, :],\n jax.numpy.ravel(v))\n H = jax.lax.cond(\n start > 0, start,\n lambda x: jax.ops.index_update(H, jax.ops.index[x, x - 1], Z), None,\n lambda x: H)\n\n # body of the arnoldi iteration\n def body(vals):\n krylov_vectors, H, matvec, vector, _, threshold, i, maxiter = vals\n Av = matvec(vector, *args)\n initial_vals = [Av, krylov_vectors, i, H]\n Av, krylov_vectors, _, H = jax.lax.fori_loop(\n 0, i + 1, modified_gram_schmidt_step_arnoldi, initial_vals)\n norm = jax.numpy.linalg.norm(Av)\n Av /= norm\n H = jax.ops.index_update(H, jax.ops.index[i + 1, i], norm)\n krylov_vectors = jax.ops.index_update(krylov_vectors,\n jax.ops.index[i + 1, :],\n jax.numpy.ravel(Av))\n return [krylov_vectors, H, matvec, Av, norm, threshold, i + 1, maxiter]\n\n def cond_fun(vals):\n # Continue loop while iteration < num_krylov_vecs and norm > eps\n _, _, _, _, norm, _, iteration, _ = vals\n counter_done = (iteration >= num_krylov_vecs)\n norm_not_too_small = norm > eps\n continue_iteration = jax.lax.cond(counter_done,\n _, lambda x: False,\n _, lambda x: norm_not_too_small)\n\n return continue_iteration\n initial_norm = v.real.dtype.type(1.0+eps)\n initial_values = [krylov_vectors, H, matvec, v, initial_norm, eps, start,\n num_krylov_vecs]\n final_values = jax.lax.while_loop(cond_fun, body, initial_values)\n kvfinal, Hfinal, _, _, norm, _, it, _ = final_values\n return kvfinal, Hfinal, it, norm < eps","def solve_VFI(self):\r\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \r\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\r\n tol = self.tol ; Niter = self.Niter ; R = self.R\r\n beta = self.beta ; Pi = self.Pi\r\n \r\n V0 = np.zeros((dimA,dimC,dimW))\r\n V1 = np.zeros((dimA,dimC,dimW))\r\n Pol = np.zeros((dimA,dimC,dimW))\r\n U = np.zeros((dimA,dimC,dimW))\r\n \r\n t0 = time()\r\n diff = 1 ; niter = 0\r\n \r\n while diff > tol:\r\n niter += 1\r\n # Value update step\r\n for ia in range(dimA):\r\n for ic in range(dimC):\r\n for iw in range(dimW):\r\n c = W[iw] + R*A[ia] - A\r\n x = C[ic]\r\n \r\n c[c < 0] = np.nan \r\n if x < 0:\r\n x = np.nan\r\n \r\n u = self.u(c,x) \r\n U[:,ic,iw] = u \r\n \r\n Objective = U + beta * V0 @ Pi.T\r\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\r\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\r\n \r\n # Evaluate distance between the value functions\r\n diff = np.max(np.max(np.abs(V1 - V0))) \r\n V0[:] = V1\r\n \r\n # Break the while loop if too many iterations\r\n #print(\"The current error is \"+str(diff))\r\n if niter > Niter:\r\n print('Ops, no convergence')\r\n break\r\n \r\n t1 = time()\r\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\r\n \r\n self.V1 = V1 ; self.Pol = Pol","def amalgamate(self,i,j):\n # conserve momentum\n self.v[i] = (self.v[i]*self.m[i]+self.v[j]*self.m[j])/ \\\n (self.m[i]+self.m[j])\n self.r[i] = (self.r[j] - self.r[i])/2 + self.r[j] \n self.m[i] = self.m[i] + self.m[j]\n self.r[j] = self.r[self.n-1]\n self.v[j] = self.v[self.n-1]\n self.m[j] = self.m[self.n-1]\n self.n = self.n - 1","def solve(self):\n initial_fes = eades(self.graph, self.force_forward_edges)\n initial_fes_vec = self.edge_vector(initial_fes)\n\n # bounds for the objective\n lower_bound = 0\n upper_bound = np.sum(initial_fes_vec @ self.weights)\n\n self.logger.info('Calculating FES for graph with %d edges, max %d feedback edges', self.m, len(initial_fes))\n\n simple_cycles = set(induced_cycles(self.graph, initial_fes))\n\n for iteration in itertools.count(1):\n self.logger.info('Baharev iteration %d, %g <= objective <= %g, %d simple cycles', iteration, lower_bound,\n upper_bound, len(simple_cycles))\n\n # Formulate and solve the problem for this iteration:\n y = cp.Variable(self.m, boolean=True, name=\"y\")\n objective = cp.Minimize(cp.sum(y @ self.weights))\n\n cycle_vectors = [self.edge_vector(nx.utils.pairwise(cycle)) for cycle in simple_cycles]\n constraints = [cp.sum(a @ y) >= 1 for a in cycle_vectors]\n constraints.append(cp.sum(y @ self.force_forward_vec) == 0) # no force forward vec may be in the result set\n problem = cp.Problem(objective, constraints)\n resolution = problem.solve(**self.solver_args)\n if problem.status != 'optimal':\n self.logger.warning('Optimization solution is %s. Try solver != %s?', problem.status,\n problem.solver_stats.solver_name)\n self.logger.debug(\n \"Solved optimization problem with %d constraints: %s -> %s (%g + %g seconds, %d iterations, solver %s)\",\n len(constraints), resolution, problem.solution.status,\n problem.solver_stats.solve_time or 0, problem.solver_stats.setup_time or 0,\n problem.solver_stats.num_iters or 0, problem.solver_stats.solver_name)\n current_solution = np.abs(y.value) >= 0.5 # y.value = vector of floats each ≈ 0 or 1\n current_fes = self.edges_for_vector(current_solution)\n self.logger.debug('Iteration %d, resolution: %s, %d feedback edges', iteration, resolution,\n len(current_fes))\n # S, the feedback edge set calculated using the constraint subset, can be an incomplete solution\n # (i.e. cycles remain after removing S from the graph). So lets compare this with the upper bound\n # from the heuristic\n lower_bound = max(lower_bound, objective.value)\n if lower_bound == upper_bound:\n self.logger.info('upper == lower bound == %g, optimal solution found', lower_bound)\n break # y.value is the optimal solution\n\n if resolution > upper_bound:\n self.logger.error('Solution %g > upper bound %g!', resolution, upper_bound)\n break\n\n Gi = self.graph.copy()\n Gi.remove_edges_from(current_fes)\n if nx.is_directed_acyclic_graph(Gi):\n self.logger.info('Graph is acyclic, optimal solution found')\n break # y.value is the optimal solution\n\n # The solution is not yet ideal. So we take G^(i), the graph still containing some feedback edges,\n # calculate a heuristic on it and use the heuristic (= over-estimation) to adjust upper bound and\n # determine additional simple cycles (= constraints)\n Fi = eades(Gi, self.force_forward_edges)\n yi = self.edge_vector(Fi) | current_solution\n zi = np.sum(yi @ self.weights)\n if zi < upper_bound:\n upper_bound = zi\n current_solution = yi\n simple_cycles |= set(induced_cycles(Gi, Fi))\n\n self.solution_vector = current_solution\n self.solution = self.edges_for_vector(current_solution)\n self.objective = objective.value\n self.iterations = iteration\n self.simple_cycles = simple_cycles\n return self.solution","def initiateVMatrixes():\n global v, vNew, vExact\n # Initialize the grid to 0\n v = np.zeros((n+1, n+1)) # matrix of v, index are i: row, j:column\n # Set the boundary conditions\n for i in range(1,n):\n v[0,i] = 10\n v[n,i] = 10\n v[i,0] = 10\n v[i,n] = 10\n # Exact solution\n vExact = np.copy(v)\n for i in range(1,n):\n for j in range(1,n):\n vExact[i,j] = 10\n # Initial guess\n for i in range(1,n):\n for j in range(1,n):\n v[i,j] = 0.9*vExact[i,j]\n vNew = np.copy(v)","def run(self):\n\t\tfrom loc import loc as Loc\n\t\tfor r in range(1,self.size):\n\t\t\tfor c in range(self.size): \n\t\t\t\tthis = Loc(r,c)\n\t\t\t\tself.state.set_cell(this, self.rule(self.neighbor_vals(this), self.__prob))\n\t\tself.__ran = True","def _update_local_solution(self, x: np.ndarray, x_neigh: dict, stepsize: float, **kwargs):\r\n for j, x_j in x_neigh.items():\r\n self.lambd[j] += stepsize * (x - x_j)\r\n \r\n self.x = x","def IterateValues(self):\n agrid = self.agrid\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n for l in range(self.Na): \n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\n self.v[-1][l] = self.util(self.c[-1][l],0)\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n m0 = 0 \n for l in range(self.Na):\n # Find a bracket within which optimal a' lies\n m = max(0, m0-1)\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\n # Define objective function for optimal a'\n def objfn(a1):\n v = self.value(y, agrid[l], a1)\n return -v\n # Find optimal a' using Golden Section Search\n if a == b:\n self.a[y][l] = 0\n elif b == c:\n self.a[y][l] = agrid[-1]\n else:\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\n #‘Brent’,‘Bounded’,‘Golden’\n self.a[y][l] = result.x\n # Computing consumption and labor\n if y >= -self.R:\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\n else:\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')","def relax(self,n=1):\n # print(\"putin\", self.level.rhs.reshape(-1)[:])\n # print(\"getout\", self.solver(self.level.rhs.reshape(-1)))\n for i in range(n):\n self.level.mid[:] += (self.solver(self.level.rhs.reshape(-1)) -\n self.solver(self.stencil.eval_convolve(\n self.level.evaluable_view(self.stencil)).reshape(-1))).reshape(self.level.mid.shape)","def _relax_loop(self, n=1):\n tmp = self.lvl_view.copy()\n flat_iter = self.lvl_view.flat\n # print(\"Stencil :\", self.stencil.arr)\n # print(\"LevelView:\", self.lvl_view)\n # print(\"relative Posistions :\", self.stencil.relative_positions)\n # print(\"Size of lvl_view: \", self.lvl_view.size)\n for i in range(self.lvl_view.size):\n if not self.is_on_border(flat_iter.coords):\n # apply L_minus on u\n # print(\"The coords \", flat_iter.coords, \"are not on the border\")\n # print(\"And the relative coordinates used are:\")\n my_sum = self.center_value * (1.0-1.0/self.omega) * self.lvl_view[flat_iter.coords]\n for st_pos in self.stencil.relative_positions_woc:\n coords = tuple(np.asarray(flat_iter.coords) + np.asarray(st_pos))\n # print(\"relative_coords: \", coords)\n # print(\"coords_in_stencil: \", st_pos + self.stencil.center)\n my_sum += self.stencil.arr[tuple(st_pos + self.stencil.center)] * \\\n self.lvl_view[coords]\n\n tmp[flat_iter.coords] = -my_sum * self.omega / self.center_value\n # print(self.lvl_view[flat_iter.coords])\n next(flat_iter)\n self.lvl_view.reshape(-1)[:] = tmp.reshape(-1)[:]","def update_gol(arr):\n nxt = np.zeros(arr.shape)\n rows,cols = nxt.shape\n for i in range(rows):\n for j in range(cols):\n nn = sum_vonneuman_nn(arr,i,j)\n if arr[i][j]==1:\n if nn==2 or nn==3:\n nxt[i][j]=1\n else:\n if nn==3:\n nxt[i][j]=1\n return nxt","def one_step(self):\r\n assert (self.uv_vol is not None)\r\n assert (self.guv_vol is not None)\r\n assert (self.uv_bound is not None)\r\n assert (self.vf_vect_bound is not None)\r\n assert (self.vF_vect_vol is not None)\r\n # Shape checks\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\r\n assert (self.uv_vol.shape == self.guv_vol.shape)\r\n assert (self.uv_vol.shape == self.uv_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\r\n \r\n if self.step == 0:\r\n self.check_k_matrix_stability()\r\n # print(\"Epsilon is :\"+str(self.Epsilon))\r\n # print(\"Beta is :\"+str(self.Beta))\r\n\r\n # Form \"Stiffness\" matrix:\r\n K = self.make_k_matrix()\r\n # Form \"Force\" vector: \r\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\r\n\r\n # print(\"FORCE VECTOR:\")\r\n # print(f)\r\n # print(\"STIFFNESS MATRIX\")\r\n # print(K)\r\n # print(\"UV_VOL\")\r\n # print(self.uv_vol)\r\n # print(\"EPSILON * GUV_VOL\")\r\n # print(self.Epsilon * self.guv_vol)\r\n # print(\"UV_BOUND * COEFF\")\r\n # print((self.Epsilon / self.Beta) * self.uv_bound)\r\n sol = scipy_sparse_linsolve(K, f)\r\n # print(\"SOLUTION\")\r\n # print(sol)\r\n return sol","def test_numbers_can_substitute_vectors(free_alg, full_balance):\n\n dr = free_alg\n p = dr.names\n\n x = IndexedBase('x')\n y = IndexedBase('y')\n r = p.R\n i, j, k, l = symbols('i j k l')\n v = p.v\n w = Vec('w')\n\n orig = dr.sum((i, r), (j, r), x[i, j] * v[i] * w[j] + y[i, j] * v[i] * v[j])\n\n res = orig.subst(v[k], 0, full_balance=full_balance).simplify()\n assert res == 0\n res = orig.subst(v[i], 1, full_balance=full_balance).simplify()\n assert res == dr.sum((i, r), (j, r), x[j, i] * w[i] + y[i, j])","def value_iteration(r,terminal_states_mask, not_slipping_prob=1,\n initial_policy=None,\n eps=0.1):\n V = np.copy(r).astype(np.float)\n for _ in range(200):\n Vdet_u = np.copy(V)\n Vdet_r = np.copy(V)\n Vdet_l = np.copy(V)\n Vdet_d = np.copy(V)\n\n Vdet_u[1:, :] = V[:-1, :]\n Vdet_r[:, :-1] = V[:, 1:]\n Vdet_l[:, 1:] = V[:, :-1]\n Vdet_d[:-1, :] = V[1:, :]\n\n nsp = not_slipping_prob\n Vnext = np.zeros((4, )+r.shape, dtype=float)\n Vnext[UP, :, :] = nsp * Vdet_u + 0.5 * (1-nsp) * Vdet_l + 0.5 * (\n 1-nsp) * Vdet_r\n Vnext[DOWN, :, :] = nsp * Vdet_d + 0.5 * (1-nsp) * Vdet_l + 0.5 * (\n 1-nsp) * Vdet_r\n Vnext[LEFT, :, :] = nsp * Vdet_l + 0.5 * (1-nsp) * Vdet_u + 0.5 * (\n 1-nsp) * Vdet_d\n Vnext[RIGHT, :, :] = nsp * Vdet_r + 0.5 * (1-nsp) * Vdet_u + 0.5 * (\n 1-nsp) * Vdet_d\n if initial_policy is None:\n policy = np.argmax(r[None, :, :] + Vnext, axis=0)\n else:\n policy = np.copy(initial_policy)\n\n Vnew = np.copy(V)\n for a in [UP, DOWN, LEFT, RIGHT]:\n ind = np.logical_and(policy == a, ~ terminal_states_mask)\n Vnew[ind] = r[ind] + Vnext[a][ind]\n if np.linalg.norm(V - Vnew, ord=np.inf) < eps:\n break\n V[:, :] = Vnew\n return policy, V","def relu(self, v):\n if v > 0:\n solution = v\n else:\n solution = 0\n return solution","def ObserveEvidence(self,E):\r\n for v,e in E.iteritems():\r\n indx, = (self.var==v).nonzero() # find i where f.var[i]=v\r\n if indx.size != 0:\r\n A = I2A(range(len(self.val)), self.card) # all assignments\r\n A = A[:,indx].flatten() # only interested in 'indx' element of each row\r\n self.val[A != e] = 0","def do_relax(self):\n raise NotImplementedError","def relax(self, n=1):\n\n for i in range(n):\n rhs = self.lvl.rhs - self.st_minus.eval_convolve(self.evaluable_view, self.convolve_control)\n self.lvl.mid[:] = self.l_plus_solver(rhs.reshape(-1)).reshape(self.lvl.mid.shape)","def vectorized_result(j):\n\te = np.zeros((3, 1))\n\te[j] = 1.0\n\treturn e","def runIteration(self, task, Sol, Fitness, xb, fxb, A, S, Q, v, **dparams):\n\t\tfor i in range(self.NP):\n\t\t\tQ[i] = self.Qmin + (self.Qmax - self.Qmin) * self.uniform(0, 1)\n\t\t\tv[i] += (Sol[i] - xb) * Q[i]\n\t\t\tif self.rand() > self.r: S[i] = self.localSearch(best=xb, A=A[i], task=task, i=i, Sol=Sol)\n\t\t\telse: S[i] = task.repair(Sol[i] + v[i], rnd=self.Rand)\n\t\t\tFnew = task.eval(S[i])\n\t\t\tif (Fnew <= Fitness[i]) and (self.rand() < A[i]): Sol[i], Fitness[i] = S[i], Fnew\n\t\t\tif Fnew <= fxb: xb, fxb, A[i] = S[i].copy(), Fnew, self.updateLoudness(A[i])\n\t\treturn Sol, Fitness, xb, fxb, {'A': A, 'S': S, 'Q': Q, 'v': v}","def equiangulate(self,x,mask):\n\n timeout = 100\n k = 0\n while (not mask.all())and(k<timeout):\n\n changed_tris,j = np.nonzero(~mask)\n chosen_cell = changed_tris[0]\n cell_mask = np.zeros(3,dtype=np.bool)\n cell_mask[j[0]] = True\n chosen_opposite_cell = self.v_neighbours[chosen_cell,cell_mask][0]\n\n\n cells = np.roll(self.tris[chosen_cell],-j[0])\n opposite_cells = self.tris[chosen_opposite_cell]\n opposite_cells = np.roll(opposite_cells, - self.k2s[chosen_cell,cell_mask])\n\n\n self.tris[chosen_cell] = cells[0], opposite_cells[0],cells[2]\n self.tris[chosen_opposite_cell] = opposite_cells[0],cells[0], opposite_cells[2]\n\n self.Angles[[chosen_cell,chosen_opposite_cell]] = tri_angles_periodic(x, self.tris[[chosen_cell,chosen_opposite_cell]], self.L)\n # self.Angles = tri_angles_periodic(x,self.tris,self.L)\n self.Cents = x[self.tris]\n self.vs = self.get_vertex_periodic()\n\n\n modify_neighbours = np.concatenate([self.v_neighbours[chosen_cell],self.v_neighbours[chosen_opposite_cell]])\n modify_neighbours.sort()\n self.v_neighbours[modify_neighbours] = -1\n\n\n n_neigh = get_neighbours(self.tris,self.v_neighbours,Range = modify_neighbours)\n self.v_neighbours = n_neigh\n self.neighbours = self.vs[n_neigh]\n\n self.k2s = get_k2(self.tris, self.v_neighbours)\n if (self.k2s>=3).sum()!=0:\n self._triangulate_periodic(x)\n self.k2s = get_k2(self.tris, self.v_neighbours)\n mask[:] = True\n else:\n mask = ((self.Angles[self.v_neighbours, self.k2s] + self.Angles) < np.pi)\n k+=1\n if k == timeout:\n self._triangulate_periodic(x)\n self.k2s = get_k2(self.tris, self.v_neighbours)","def _dfs_iteration(self, v):\n stack1 = [v]\n self._visited[v] = True\n while stack1:\n curr = stack1.pop()\n for w in self._G.adj(curr):\n if not self._visited[w]:\n stack1.append(w)\n self._visited[w] = True\n self._pre[w] = curr\n elif self._pre[w] != curr:\n self.cycle = True","def distort_vxs(self):\n self.dvxs = self.vxs.copy()\n self.dvxs[:, 0] += self.perlin()\n self.dvxs[:, 1] += self.perlin()","def vectorized_result(j):\n e = np.zeros((10,))\n e[j] = 1.0\n return e","def vectorized_result(j):\n e = np.zeros((6, 1))\n e[j] = 1.0\n return e","def _estimate_velocity_by_neigh(\n x_coords_metres, y_coords_metres, x_velocities_m_s01,\n y_velocities_m_s01, e_folding_radius_metres):\n\n if numpy.isnan(e_folding_radius_metres):\n neigh_radius_metres = numpy.inf\n else:\n neigh_radius_metres = 3 * e_folding_radius_metres\n\n orig_x_velocities_m_s01 = x_velocities_m_s01 + 0.\n orig_y_velocities_m_s01 = y_velocities_m_s01 + 0.\n\n nan_flags = numpy.logical_or(\n numpy.isnan(orig_x_velocities_m_s01),\n numpy.isnan(orig_y_velocities_m_s01)\n )\n nan_indices = numpy.where(nan_flags)[0]\n\n for this_index in nan_indices:\n if numpy.isnan(e_folding_radius_metres):\n these_neighbour_indices = numpy.where(numpy.invert(nan_flags))[0]\n if len(these_neighbour_indices) == 0:\n continue\n\n x_velocities_m_s01[this_index] = numpy.mean(\n orig_x_velocities_m_s01[these_neighbour_indices]\n )\n\n y_velocities_m_s01[this_index] = numpy.mean(\n orig_y_velocities_m_s01[these_neighbour_indices]\n )\n\n continue\n\n these_x_diffs_metres = numpy.absolute(\n x_coords_metres[this_index] - x_coords_metres)\n these_y_diffs_metres = numpy.absolute(\n y_coords_metres[this_index] - y_coords_metres)\n\n these_neighbour_flags = numpy.logical_and(\n these_x_diffs_metres <= neigh_radius_metres,\n these_y_diffs_metres <= neigh_radius_metres)\n\n these_neighbour_flags = numpy.logical_and(\n these_neighbour_flags, numpy.invert(nan_flags)\n )\n\n these_neighbour_indices = numpy.where(these_neighbour_flags)[0]\n if len(these_neighbour_indices) == 0:\n continue\n\n these_neighbour_dist_metres = numpy.sqrt(\n these_x_diffs_metres[these_neighbour_indices] ** 2 +\n these_y_diffs_metres[these_neighbour_indices] ** 2\n )\n\n these_neighbour_subindices = numpy.where(\n these_neighbour_dist_metres <= neigh_radius_metres\n )[0]\n if len(these_neighbour_subindices) == 0:\n continue\n\n these_neighbour_indices = these_neighbour_indices[\n these_neighbour_subindices]\n these_neighbour_dist_metres = these_neighbour_dist_metres[\n these_neighbour_subindices]\n\n these_weights = numpy.exp(\n -these_neighbour_dist_metres / e_folding_radius_metres\n )\n these_weights = these_weights / numpy.sum(these_weights)\n\n x_velocities_m_s01[this_index] = numpy.sum(\n these_weights * orig_x_velocities_m_s01[these_neighbour_indices]\n )\n\n y_velocities_m_s01[this_index] = numpy.sum(\n these_weights * orig_y_velocities_m_s01[these_neighbour_indices]\n )\n\n return x_velocities_m_s01, y_velocities_m_s01","def solute(self, puzzle):\r\n \"\"\"suppose that ax = c, where a is a matrix, c and x are vectors.\"\"\"\r\n \"\"\"The aim is to figure out x, which indicates the solution.\"\"\"\r\n A, a, c = [], [], []\r\n for i in range(puzzle.row):\r\n for j in range(puzzle.column):\r\n # create a puzzle.row * puzzle.column by puzzle.row * puzzle.column matrix.\r\n # each column represents a cell in the puzzle.\r\n # each row represents the changed cell if column c is selected.\r\n if puzzle.lights[i][j] == -1:\r\n c.append(1)\r\n else:\r\n c.append(0)\r\n for m in range(puzzle.row):\r\n for n in range(puzzle.column):\r\n if self.is_adjecent([m, n], [i, j]):\r\n # if [m, n] is adjecent to [i, j], then a[ij][mn] should be 1.\r\n a.append(1)\r\n else:\r\n a.append(0)\r\n a.append(c[i * puzzle.column + j])\r\n A.append(a)\r\n a = []\r\n\r\n self.eliminate(A)\r\n x = [item[len(item) - 1] for item in A]\r\n # x is the last column of A.\r\n # if x[i] is 1, cell i should be selected.\r\n i = 0\r\n for m in range(puzzle.row):\r\n for n in range(puzzle.column):\r\n if x[i] == 1:\r\n puzzle.selection.add((m, n))\r\n i += 1\r\n\r\n return puzzle.selection","def problem_reduction_single(self, i, val):\n y_update = - val * self.A.getcol(i).toarray().flatten()\n self.y += y_update\n self.A = sparse.hstack([self.A[:, :i], self.A[:, i + 1:]], format='csr')\n z_index = self.mask.searchsorted(i)\n self.mask = np.insert(self.mask, z_index, i)\n self.z = np.insert(self.z, z_index, val)","def runIteration(self, task, Sol, Fitness, xb, fxb, A, r, S, Q, v, **dparams):\n\t\tfor i in range(self.NP):\n\t\t\tA[i], r[i] = self.selfAdaptation(A[i], r[i])\n\t\t\tQ[i] = self.Qmin + (self.Qmax - self.Qmin) * self.uniform(0, 1)\n\t\t\tv[i] += (Sol[i] - xb) * Q[i]\n\t\t\tif self.rand() > r[i]: S[i] = self.localSearch(best=xb, A=A[i], task=task, i=i, Sol=Sol)\n\t\t\telse: S[i] = task.repair(Sol[i] + v[i], rnd=self.Rand)\n\t\t\tFnew = task.eval(S[i])\n\t\t\tif (Fnew <= Fitness[i]) and (self.rand() < (self.A_l - A[i]) / self.A): Sol[i], Fitness[i] = S[i], Fnew\n\t\t\tif Fnew <= fxb: xb, fxb = S[i].copy(), Fnew\n\t\treturn Sol, Fitness, xb, fxb, {'A': A, 'r': r, 'S': S, 'Q': Q, 'v': v}","def vj(vj, pol, ant) :\n s.vj(pol, vj, ant)","def vectorized_result(j):\n print(j)\n e = np.zeros([10])\n e[j] = 1.0\n return e","def vectorized_result(j):\n e = np.zeros((10, 1))\n e[j] = 1.0\n return e","def vectorized_result(j):\n e = np.zeros((10, 1))\n e[j] = 1.0\n return e","def vectorized_result(j):\n e = np.zeros((10, 1))\n e[j] = 1.0\n return e","def vectorized_result(j):\n e = np.zeros((10, 1))\n e[j] = 1.0\n return e","def LD_Vx_I(self, x):\n\t\tfor i in range(0, x + 1):\n\t\t\tself.V[i] = self.ram[self.I + i]","def _eval(self, v):\n Kv = np.zeros(self.K.output_size)\n self.K.forward(v.ravel(), Kv)\n return super(least_squares, self)._eval(Kv - self.offset)","def LD_I_Vx(self, x):\n\t\tfor i in range(0, x + 1):\n\t\t\tself.ram[self.I + i] = self.V[i]","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 vectorized_result(j):\n e = np.zeros(shape=(10, 1))\n e[j] = 1.0\n\n return e","def _triangulate(self,x):\n\n t = tr.triangulate({\"vertices\": x},\"-n\")\n tri = t[\"triangles\"]\n neighbours = t[\"neighbors\"]\n\n b_cells = np.zeros(self.n_c)\n b_cells[self.n_C:] = 1\n\n three_b_cell_mask = b_cells[tri].sum(axis=1)==3\n tri = tri[~three_b_cell_mask]\n\n neigh_map = np.cumsum(~three_b_cell_mask)-1\n neigh_map[three_b_cell_mask] = -1\n neigh_map = np.concatenate((neigh_map,[-1]))\n\n neighbours = neighbours[~three_b_cell_mask]\n neighbours = neigh_map[neighbours]\n\n #6. Store outputs\n self.tris = tri\n self.n_v = tri.shape[0]\n self.Cents = x[self.tris]\n self.vs = self.get_vertex()\n\n\n #7. Manually calculate the neighbours. See doc_string for conventions.\n self.v_neighbours = neighbours\n self.neighbours = self.vs[neighbours]\n self.neighbours[neighbours == -1] = np.nan\n\n self.reset_k2s()","def iterations(self):\n i = 0\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\n n = len(self.model.stateVector)\n self.answer = None\n \n while ((i < self.maxiter) \n and (stateVectorConv > self.stateVectorConvThreshold)\n ):\n \n F, K = self.model()\n \n if np.any(np.isnan(F)) or np.any(np.isnan(K)):\n m = \"Iteration {0} failure of model.\"\n raise OptimalEstimationException(m.format(i))\n \n if self.model.verbose > 0:\n self.model.plot(i+1, stateVectorConv)\n \n try:\n self.DecomposeJacobian(K)\n except np.linalg.LinAlgError:\n m = \"Iteration {0} failure in decomposition.\"\n raise OptimalEstimationException(m.format(i))\n \n statevectorOffset = (self.V.T * self.priorSinvh * \n np.matrix(np.array(self.model.stateVector) - np.array(self.model.prior) ).T)\n measurementOffset = (self.U.T * self.errSinvh * \n np.matrix(self.model.observation - F).T)\n \n newState = np.matrix((self.w * \n (measurementOffset.A1 + \n self.w * statevectorOffset.A1))/(self.w**2+1.0)).T\n newState = self.priorSh * self.V * newState\n newState = newState.A1 + self.model.prior\n \n stateVectorConv = ((np.matrix(newState - self.model.stateVector) * \n self.Sinv * np.matrix(newState - self.model.stateVector).T)/n)[0,0]\n self.model.stateVector = newState\n\n if i == 0:\n \n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\n \n print('cost Function for iteration {}:'.format(i), self.costFunction)\n\n i += 1\n \n F, K = self.model()\n if self.model.verbose > 0:\n self.model.plot(i+1, stateVectorConv)\n \n try:\n self.DecomposeJacobian(K)\n except np.linalg.LinAlgError:\n raise OptimalEstimationException(\"Failure in decomposition.\")\n \n Wplus2 = np.matrix(np.diag(1.0/(self.w**2+1.0)))\n self.model.covariance = (self.priorSh * self.V * Wplus2 * \n self.V.T * self.priorSh)\n \n\n \n return i, stateVectorConv","def stabilizer_vector(v, g, n):\n vg = v.copy()\n w = v.copy()\n for i in range(1, n):\n vg *= g \n w += vg\n assert v == vg * g\n if (w['B'] == 0).all():\n return None\n return w","def dp_alex(v_space, num_frames_r, num_frames_q, bov_flag, prev_ref=5,\n next_ref=0):\n t1 = float(cv2.getTickCount())\n\n common.DebugPrint(\"Entered dp_alex(): Running dynamic programming...\")\n\n r, c, d = v_space.shape\n\n # We substitute all NaN's of v_space\n for i in range(d):\n v_temp = v_space[:, :, i]\n v_temp[np.isnan(v_temp)] = 0\n v_space[:, :, i] = v_temp\n\n vv = np.zeros((r, c))\n for j in range(d):\n vv += v_space[:, :, j]\n\n # Checking that vv has positive elements\n assert np.nonzero(vv < 0.0)[0].size == 0\n\n print_matrices = True\n\n if common.MY_DEBUG_STDOUT and print_matrices:\n print(\"dp_alex(): r = %d, c = %d\" % (r, c))\n print(\"dp_alex(): vv = \\n%s\" % str(vv))\n sys.stdout.flush()\n\n D = np.zeros((r, c))\n tback = np.zeros((r, c))\n\n for ref in range(r):\n D[ref, 0] = vv[ref, 0]\n tback[ref, 0] = -1\n\n for qry in range(1, c):\n for ref in range(r):\n # We enumerate a few reference frames to find the one with\n # highest votes\n lb = ref - prev_ref\n ub = ref + next_ref\n\n if lb < 0:\n lb = 0\n if lb >= r:\n lb = r - 1\n\n if ub < 0:\n ub = 1\n if ub >= r:\n ub = r - 1\n\n max_pos = lb\n for i in range(lb + 1, ub + 1):\n \"\"\"\n We use <= --> we break ties by going forward in the\n reference video (incrementing the reference frame for\n the next query frame).\n \"\"\"\n if D[max_pos, qry - 1] <= D[i, qry - 1]:\n max_pos = i\n # max_pos is the maximum vote reference frame for query frame qry\n\n D[ref, qry] += D[max_pos, qry - 1] + vv[ref, qry]\n tback[ref, qry] = max_pos\n\n if common.MY_DEBUG_STDOUT and print_matrices:\n print(\"D = \\n%s\" % str(D))\n print(\"tback = \\n%s\" % str(tback))\n\n crossref = np.zeros((num_frames_q, 2))\n\n # Find max-cost path (the critical path) for the last query frame:\n max_pos = 0\n for ref in range(1, r):\n \"\"\"\n We use <= --> we break ties by going forward in the\n reference video (incrementing the reference frame for\n the next query frame) - debatable if this is a good idea!!!!TODO.\n \"\"\"\n if D[max_pos, c - 1] <= D[ref, c - 1]:\n max_pos = ref\n print(\"max_pos = %d\" % max_pos)\n\n print(\"dp_alex(): cost critical path = %s\" % str(D[max_pos, c - 1]))\n\n pos_ref = max_pos\n for qry in range(c - 1, 0-1, -1):\n crossref[qry][0] = qry\n crossref[qry][1] = pos_ref\n\n common.DebugPrint(\"qry=%d, pos_ref=%d\" % (qry, pos_ref))\n pos_ref = tback[pos_ref, qry]\n\n # time took\n common.DebugPrint(\"dp_alex(): crossref = %s\" % str(crossref))\n compute_cost(crossref, vv, \"crossref_dp_Alex.txt\")\n # TODO: assert cost computed is = D[max_pos,...]\n\n t2 = float(cv2.getTickCount())\n my_time = (t2 - t1) / cv2.getTickFrequency()\n print(\"dp_alex() took %.6f [sec]\" % my_time)\n\n y = None\n x = None\n return y, x, D, tback, crossref","def _redef_sp1_vars(self):\r\n\r\n if len(self.fq_list) == 0:\r\n no_rad = True\r\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \r\n (self.lst_tmp.size, 1)))\r\n else: no_rad = False\r\n # The practically constants...\r\n # Big Epsilon:\r\n if self.cond == True:\r\n self.Epsilon = self.d_T * self.thermal_conductivity\r\n else:\r\n self.Epsilon = (self.diff_scale ** 2) / \\\r\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\r\n # Beta:\r\n if self.cond == True:\r\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\r\n (self.convect_coeff)\r\n else:\r\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\r\n ((1.0 - 2.0 * self.r1) * (\r\n 3.0 * self.absorb_coeffs[self.rad]))\r\n\r\n # The feild solutions at the last timestep.\r\n # The integral vF:\r\n if self.cond == True:\r\n # The horrifically complicated F:\r\n def F_func_cond(elem, eta):\r\n F = 0.0\r\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n F += Tn\r\n for k in range(0, len(self.fq_list)):\r\n vk = self.fq_list[k]\r\n try:\r\n vk_m = self.fq_list[k - 1]\r\n except:\r\n vk_m = self.v0_frequency\r\n absorbtion = self.absorb_coeffs[k]\r\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\r\n [eta])[0]\r\n inter1 = phi - 4.0 * sconst.pi * \\\r\n self.B_int_function(Tn, self.refr_idx_vol,\r\n vk, vk_m)\r\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\r\n F += inter2 * inter1\r\n return elem.funcs(eta) * F\r\n if not no_rad:\r\n # We're integrating something non-linear for SP1\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func_cond,\r\n self.node_map)\r\n else:\r\n # Or something easier if we're only looking at heat.\r\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\r\n else:\r\n def F_func_radiative(elem, eta):\r\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n vk = self.fq_list[self.rad]\r\n try:\r\n vk_minus = self.fq_list[self.rad - 1]\r\n except:\r\n vk_minus = self.v0_frequency\r\n n = self.refr_idx_vol\r\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\r\n return elem.funcs(eta) * F\r\n\r\n self.vF_vect_vol = et.elems_2_array(self.mesh,\r\n F_func_radiative,\r\n self.node_map)\r\n # The path integral vf:\r\n if self.cond == True:\r\n def f_func_cond(elem, eta):\r\n Tb = self.background_temperature\r\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\r\n n = self.refr_idx_background\r\n vk = self.v0_frequency\r\n vk_minus = 0\r\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\r\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\r\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\r\n f = Tb + B_coeff * (Bb0 - Bn0)\r\n return elem.funcs(eta) * f\r\n if not no_rad:\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func_cond,\r\n self.node_map)\r\n else:\r\n try:\r\n self.vf_vect_bound = self.cache_tb_integral_array\r\n except AttributeError:\r\n def elem_functor(elem, eta): return elem.funcs(eta)\r\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n elem_functor,\r\n self.node_map)\r\n self.cache_tb_integral_array *= self.background_temperature\r\n self.vf_vect_bound = self.cache_tb_integral_array\r\n \r\n else:\r\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\r\n def f_func_radiative(elem, eta):\r\n T = self.background_temperature\r\n vk = self.fq_list[self.rad]\r\n try:\r\n vk_minus = self.fq_list[self.rad - 1]\r\n except:\r\n vk_minus = self.v0_frequency\r\n n = self.refr_idx_vol\r\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\r\n return elem.funcs(eta) * f\r\n\r\n self.vf_vect_bound = et.edge_2_array(self.mesh,\r\n \"Boundary\",\r\n f_func_radiative,\r\n self.node_map)\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vf_vect_bound.shape[0] == \\\r\n self.vF_vect_vol.shape[0])","def v(resistances, r_i, applied_voltages, **kwargs):\n if r_i.word_line > 0 or r_i.bit_line > 0:\n g = fill.g(resistances, r_i)\n i = fill.i(applied_voltages, resistances, r_i)\n\n utils.message('Started solving for v.', **kwargs)\n v_matrix = linalg.spsolve(g.tocsc(), i)\n utils.message('Solved for v.', **kwargs)\n\n # if `num_examples == 1`, it can result in 1D array.\n if v_matrix.ndim == 1:\n v_matrix = v_matrix.reshape(v_matrix.shape[0], 1)\n\n # if one of the interconnect resistances is zero, only half of the\n # matrix_v had to be solved. The other half can be filled without\n # solving because the node voltages are known.\n if r_i.word_line == 0:\n new_v_matrix = np.zeros(\n (2*resistances.size, applied_voltages.shape[1]))\n new_v_matrix[:resistances.size, ] = np.repeat(\n applied_voltages, resistances.shape[1], axis=0)\n new_v_matrix[resistances.size:, ] = v_matrix\n v_matrix = new_v_matrix\n if r_i.bit_line == 0:\n new_v_matrix = np.zeros(\n (2*resistances.size, applied_voltages.shape[1]))\n new_v_matrix[:resistances.size, ] = v_matrix\n v_matrix = new_v_matrix\n else:\n # if both interconnect resistances are zero, all node voltages are\n # known.\n v_matrix = np.zeros(\n (2*resistances.size, applied_voltages.shape[1]))\n v_matrix[:resistances.size, ] = np.repeat(\n applied_voltages, resistances.shape[1], axis=0)\n\n return v_matrix","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 f_v(self, v):\n\n return self.f(v[:, 0], v[:, 1], v[:, 2])","def v(self, i):\n\n\t # Check whether the node is already active\n\t if self.active_nodes[i] == True:\n\t return 0\n\n\t self.active_nodes[i] = True\n\t contrib = 0\n\n\t for j in self.adj_list[i]:\n\t if self.thresh_f(j) >= self.theta[j] and self.active_nodes[j] == False:\n\t self.active_nodes[j] = True\n\t contrib += 1 + self.v(j)\n\n\t return contrib","def exhaust(self):\n svr = self.svr\n for it, fluid in enumerate(svr.fluids):\n assert np.allclose(svr.soln[svr.blk.shclgrp==it,0], fluid.rho)\n vel = svr.velocities[it]\n for idim in range(svr.ndim):\n val = fluid.rho * vel[idim]\n assert np.allclose(svr.soln[svr.blk.shclgrp==it,idim+1], val)","def on_iteration_start(self):\n\n self.Xfprv = self.Xf.copy()\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\n BacktrackRobust)):\n self.Yfprv = self.Yf.copy()\n\n if self.opt['Monotone']:\n if self.k == 0:\n self.objfn = self.eval_objfn()\n self.objfn_prev = self.objfn","def _update_local_solution(self, x: np.ndarray, z: np.ndarray, z_neigh: dict, rho: float, **kwargs):\r\n self.z_neigh = z_neigh\r\n\r\n # update dual variables\r\n self.lambd[self.agent.id] += rho * (x - z)\r\n for j, z_j in z_neigh.items():\r\n self.lambd[j] += rho * (x - z_j)\r\n\r\n # update primal variables\r\n self.x = x\r\n self.z = z","def vectorized_result(j):\r\n e = zeros((10))\r\n e[j] = 1.0\r\n return e","def potentialSolver(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 # solve potential\n for it in np.arange(1,max_it+1):\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 #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 #check for convergence*/\n if it%25==0:\n sum = 0;\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 R = -self.phi[i][j][k]*(2*dx2+2*dy2+2*dz2) +\\\n 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])\n\n sum += R*R;\n\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 value_iteration(self):\n #Create a utility function of the environment shape\n gamma = 0.9\n epsilon = 0.01\n iteration = 0\n\n #create a utility function that matches the size of the number of states\n u = np.zeros(self.env.observation_space.n, dtype=float)\n\n u_copy = u.copy()\n\n #Create the reward grid\n reward = np.array([state_map.get(sublist) for state in frozen_lake.MAPS[self.env.spec._kwargs.get('map_name')] for sublist in state])\n\n T = self.frozen_transition()\n\n graph_list = list()\n\n #keep track of the convergence\n policy_convergence = list()\n\n while True:\n delta = 0\n iteration += 1\n u = u_copy.copy()\n graph_list.append(u)\n start_time = time()\n for s in range(self.env.observation_space.n):\n r = reward[s]\n v = np.zeros((1, self.env.observation_space.n), dtype=float)\n v[0, s] = 1.0\n u_copy[s] = self.return_state_utility(v, T, u, r, gamma)\n delta = max(delta, np.abs(u_copy[s] - u[s]))\n policy_convergence.append({'iter': iteration, 'delta': delta})\n if delta < epsilon * (1 - gamma) / gamma:\n print(\"Total Iterations: {}\".format(iteration))\n print(\"=================== VALUE ITERATION RESULT ==================\")\n print(\"Iterations: \" + str(iteration))\n print(\"Delta: \" + str(delta))\n print(\"Gamma: \" + str(gamma))\n print(\"Epsilon: \" + str(epsilon))\n print(\"Time to converge: {} seconds\".format(time() - start_time))\n print(\"===================================================\")\n utility_reshape = np.reshape(u, (int(np.sqrt(self.env.observation_space.n)), int(np.sqrt(self.env.observation_space.n))))\n print (np.array(utility_reshape, dtype=float))\n print(\"===================================================\")\n break\n\n return u","def f(t, x, n, v):\n total = 0\n for i in range(n+1):\n for j in range(n+1):\n for k in range(v):\n total = t[i][j] * x[i][j][k]","def relax(self):\n # print(\"putin\", self.level.rhs.reshape(-1)[:])\n # print(\"getout\", self.solver(self.level.rhs.reshape(-1)))\n\n self.level.mid[:] = self.solver(self.level.rhs.reshape(-1)).reshape(self.level.mid.shape)","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 atualizaVertice(self, v = []):\r\n\r\n #reseta as arestas para d0\r\n #for a in self.arestas:\r\n # a.peso = a.d0\r\n\r\n for vertice in v:\r\n for a in self.arestas:\r\n if (vertice.id == a.v1.id):\r\n #print (\"atualiza aresta\", a.id)\r\n if (a.v2.atualizado):\r\n a.peso = a.d2\r\n else:\r\n a.peso = a.d1\r\n\r\n\r\n if (vertice.id == a.v2.id):\r\n #print (\"atualiza aresta\", a.id)\r\n if (a.v1.atualizado):\r\n a.peso = a.d2\r\n else:\r\n a.peso = a.d1\r\n \r\n vertice.atualizado = True\r\n \r\n for vertice in v:\r\n vertice.atualizado = False","def vectorized_result(j):\n j=int(j)\n e = np.zeros((10, 1))\n e[j] = 1.0\n return e","def value_iteration(iterations):\n for _ in range(0, iterations):\n for i in range(0, 3):\n for j in range(0, 4):\n # We don't need values for start/end/non-reachable states\n if [i, j] == [1, 1] or [i, j] == [0, 3] or [i, j] == [1, 3]:\n None\n else:\n value([i, j])\n\n print(utilities)","def vcycle(v, b):\n if (len(v) - 1) & (len(v) - 2) != 0:\n raise ValueError(\"Lenth of v must be 2**n + 1.\")\n\n for i in range(3):\n jacobi23(v, b)\n\n if len(v) <= 3:\n return\n\n r = b - Amul(v)\n r2 = 4. * restrict(r)\n e2 = np.zeros_like(r2)\n vcycle(e2, r2)\n v += prolong(e2)\n\n for i in range(3):\n jacobi23(v, b)","def test_grad_vector(func, motion, optimized, preserve_result, x):\n utils.test_reverse_array(func, motion, optimized, preserve_result, x)","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","def DFSU(graph, v, a):\n a[v]= True # mark the current node as visited\n\n for i in graph[v]: # recursively check for all vertices adjacent.\n if a[i]==False:\n self.DFS(i,a)","def run(self, x):\n T = len(x)\n self.x = x\n self.s = np.zeros((T, self.hidden_size))\n for t in xrange(T):\n self.s[t] = np.dot(self.nodes.u, x[t])\n if self.en_bias: self.s[t] += self.nodes.b\n self.s[t] = self.acfun.compute(np.clip(self.s[t], -50, 50))\n return self.s","def on_iteration_start(self):\n\n self.Xprv = self.X.copy()\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\n BacktrackRobust)):\n self.Yprv = self.Y.copy()\n\n if self.opt['Monotone']:\n if self.k == 0:\n self.objfn = self.eval_objfn()\n self.objfn_prev = self.objfn","def apply(self, v):\n u = np.zeros(self.Dimension, dtype=complex)\n for me in self.Elements:\n for index in range(v.Elements.size):\n if index == me.j:\n u[me.i] += me.val * v.Elements[index]\n u = Vector(u) \n return u","def apply_optimization_vector(self, vector: np.ndarray) -> None:\n # we are going to iterate through the given vector;\n # an iterator allows us to next()\n # (aka `pop`) the values only when desired;\n # we only update the current vector where the mask is True\n vector_iterator = iter(vector)\n updated_vector = [v if not m else next(vector_iterator)\n for v, m in zip(self.vector,\n self.optimization_mask)]\n updated_links = self.array_2_links(np.array(updated_vector),\n self.convention)\n self.links = updated_links","def adj_to(self, v):\n\n neighbours = set()\n\n for (x, y) in self._edges:\n if x == v: neighbours.add(y)\n if y == v: neighbours.add(x)\n\n return neighbours","def firstNeighbor(v):\n for u in ranks:\n if u in matched or not self.adjacent(u, v):\n continue\n\n return u","def remove_route(self, A, v):\n A[:,v] = self.INFINITY","def run(self):\n self.errList = []\n self.initialize()\n\n for i in range(self.maxiter):\n # update U\n for k in range(self.K):\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\n full_matrices=False)\n self.U[k] = q.T.dot(p.T)\n self.U[k] = self.U[k].real\n\n # calculate temporal variable y\n y = np.zeros([self.rank, self.L, self.K])\n for k in range(self.K):\n y[:, :, k] = self.U[k].T.dot(self.X[k])\n\n # get H, V, and temps by running a single iteration of CP_ALS\n if i == 0:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1, printitn=0)\n else:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1,\n init=[self.H, self.V, temps], printitn=0)\n self.H = cp.Us[0]\n self.V = cp.Us[1]\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\n\n # update S\n for k in range(self.K):\n self.S[:, :, k] = np.diag(temps[k, :])\n\n # checking the stop criteria\n # error = 0\n for k in range(self.K):\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\n\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\n self.errList.append(error)\n if (i + 1) % self.printitn == 0:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n elif error < self.tol:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n\n if error < self.tol:\n break\n else:\n self.sigma_old = self.sigma_new\n self.sigma_new = 0\n\n for k in range(self.K):\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)","def edge_velocity(self):\n #reflext x values at x edges\n self.u[1,:,0] = -self.u[1,:,1]\n self.u[1,:,-1] = -self.u[1,:,-2]\n #mirror x values at y edges \n self.u[1,0,:] = self.u[1,1,:]\n self.u[1,-1,:] = self.u[1,-2,:]\n #mirror y values at x edges\n self.u[0,:,0] = self.u[0,:,1]\n self.u[0,:,-1] = self.u[0,:,-2]\n #mirror y values at y edges \n self.u[0,0,:] = -self.u[0,1,:]\n self.u[0,-1,:] = -self.u[0,-2,:]","def update_floyd_warshall_and_all_vectors(self):\n self.graph.compute_floyd_warshal()\n # Update where agents are\n self.update_agent_location_vector()\n # update deadlines\n self.populate_deadline_vector()\n # update distances to each task and orientation to each task\n self.update_agent_distances_vector()\n self.update_agent_orientation_vector()\n\n self.update_alive_enabled_travel()\n\n return self.graph.is_feasible()","def anneal(solution):\n old_cost = cost(solution)\n T = 1.0\n T_min = 0.00001\n ALPHA = 0.9\n\n while T > T_min:\n i = 1\n while i <= 100:\n new_solution = neighbor(solution)\n new_cost = cost(new_solution)\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\n return solution, old_cost","def gilpin_ne(A, epsilon=1e-4, max_iter=np.inf):\n A = A.T # make compatible with nesterov_ne\n m, n = A.shape\n R = np.vstack((np.hstack((np.zeros((m, m)), -A)),\n np.hstack((A.T, np.zeros((n, n))))))\n norm_R = linalg.norm(R, 2)\n u_ = (1. / m) * np.ones(m)\n v_ = (1. / n) * np.ones(n)\n x = u_.copy()\n y = v_.copy()\n D = 1. - .5 * (1. / m + 1. / n)\n gamma = np.e\n eps = 1.\n gradx_acc = np.zeros(m)\n grady_acc = np.zeros(n)\n values = []\n gaps = []\n k = 0.\n while k < max_iter and eps >= epsilon:\n mu = eps / (2. * D)\n\n # misc\n L = norm_R ** 2 / mu\n stepsize = 1. / L\n\n gradx_acc *= 0.\n gradx_acc *= 0.\n while True:\n # make call to oracle\n aux1 = A.dot(y)\n aux = -aux1 / mu\n aux += u_\n u = proj_simplex(aux)\n aux2 = A.T.dot(x)\n aux = aux2 / mu\n aux += v_\n v = proj_simplex(aux)\n gradx, grady = A.dot(v), -A.T.dot(u)\n gradx_acc += .5 * (k + 1.) * gradx\n grady_acc += .5 * (k + 1.) * grady\n\n value = x.dot(aux1)\n values.append(value)\n gap = aux2.max() - aux1.min()\n gaps.append(gap)\n assert gap + 1e-10 >= 0., \"The world is a weird place!\"\n print (\"%03i: game value <Ax, u> = %g, primal-dual \"\n \"gap=%g\") % (k + 1, value, gap)\n\n # check convergence\n if gap < eps:\n print \"Converged (primal-dual gap < %g).\" % eps\n break\n\n # y update\n yx = proj_simplex(x - stepsize * gradx)\n yy = proj_simplex(y - stepsize * grady)\n\n # z update\n zx = proj_simplex(u_ - stepsize * gradx_acc)\n zy = proj_simplex(v_ - stepsize * grady_acc)\n\n # x update\n factor = 2. / (k + 3.)\n x = factor * zx\n x += (1. - factor) * yx\n y = factor * zy\n y += (1. - factor) * yy\n\n k += 1\n if k >= max_iter: break\n\n # decrease eps\n eps /= gamma\n print \"Decreasing epsilon to %g\" % eps\n\n return x, y, values, gaps","def __init__(self, x0, initial_scale, update_type=None,\n skip_treshold=None):\n\n if not update_type:\n update_type = BroydenSolver.UPDATE_BAD_BROYDEN\n\n self.original_shape = _n.shape(x0)\n \"\"\"Original shape of the iterating vector\"\"\"\n self.n = _n.product(self.original_shape)\n \"\"\"Number of elements in the iterating vector\"\"\"\n\n self.initial_scale = initial_scale\n \"\"\"Initial scaling of the problem Jacobian\"\"\"\n self.update_type = update_type\n \"\"\"The update type\"\"\"\n\n self.x = _n.reshape(_n.array(x0, copy=True), (self.n, 1))\n \"\"\"Current point (latest)\"\"\"\n self.next_x = self.x\n \"\"\"Next point\"\"\"\n\n self.H = _n.identity(self.n) / self.initial_scale\n \"\"\"Approximation to the inverse of the Jacobian (latest)\"\"\"\n self.F = _n.zeros((self.n, 1))\n \"\"\"The target function (latest)\"\"\"\n\n self.iteration = 0\n \"\"\"Current iteration\"\"\"\n self.first_step = True\n \"\"\"Is the next step the first step?\"\"\"\n\n if skip_treshold is None:\n skip_treshold = 2.0\n self.skip_treshold = skip_treshold\n \"\"\"Skip steps that change the residual by less than this factor.\"\"\"\n\n self.max_step = 1.0\n \"\"\"Maximum relative step size\"\"\"\n\n self.last_reset = False","def jacobian(self, v):\n from scipy.special import erf, erfcx\n def integrand(u_arr):\n \"\"\"Integrand of self-consistency equation\"\"\"\n integrand_all = erfcx(-u_arr)\n #integrand_all = np.zeros(u_arr.shape)\n #u_mask = u_arr < -4.0\n #u = u_arr[u_mask]\n #integrand_all[u_mask] = -1. / np.sqrt(np.pi) * (1.0 / u - 1.0 / (2.0 * u**3) + \n #3.0 / (4.0 * u**5) - \n #15.0 / (8.0 * u**7))\n #integrand_all[~u_mask] = np.exp(u_arr[~u_mask]**2) * (1. + erf(u_arr[~u_mask]))\n return integrand_all\n\n\n mu_v = self.mu(v)\n sd_v = self.sd(v)\n low = (self.V_r - mu_v) / sd_v # reduced resting potential\n up = (self.theta - mu_v) / sd_v # reduced threshold\n f_low = integrand(low)\n f_up = integrand(up)\n jac_mat_1 = self.tau_m * 1e-3 * np.sqrt(np.pi) * self.mat_mu\n jac_mat_2 = self.tau_m * 1e-3 * np.sqrt(np.pi) * self.mat_var / (2. * sd_v**2)\n\n jac_T = np.diag(1. / v**2) - \\\n jac_mat_1.T * (f_up - f_low) + \\\n jac_mat_2.T * (f_up * up - f_low * low)\n return jac_T.T","def optimize_self(self):\n self.compute_predicate_values();\n \"\"\" Firstly,adjust the f(x) into > alpha_0; \"\"\"\n for i in range(len(self.RING_PARA_PAIR_CD)):\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CD[i]);\n self.RING_PARA_PAIR_CD[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CD[i][0].WORD_ID]; # 更新内部VECTOR;\n self.RING_PARA_PAIR_CD[i][2] = self.RING_PARA_PAIR_CD[i][0].polynomial_func(self.RING_PARA_PAIR_CD[i][1]); # 更新内部ALPHA;\n for i in range(len(self.RING_PARA_PAIR_CC)):\n # ************** BUG 0627 **********************\n # if self.RING_PARA_PAIR_CC[i][2]<41 and self.RING_PARA_PAIR_CC[i][2]>40: # ---------------------------------------------------------------->>>>>\n # print( RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID] ); # ---------------------------------------------------------------->>>>>\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CC[i]); \n # ************** BUG 0627 **********************\n # if self.RING_PARA_PAIR_CC[i][2]<41 and self.RING_PARA_PAIR_CC[i][2]>40: # ---------------------------------------------------------------->>>>> \n # print(self.RING_PARA_PAIR_CC[i][0].VECTOR); # ---------------------------------------------------------------->>>>>\n # print(RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID]); # ---------------------------------------------------------------->>>>>\n # print(self.RING_PARA_PAIR_CC[i][0].polynomial_func(self.RING_PARA_PAIR_CC[i][1])); # ---------------------------------------------------------------->>>>>\n # print( np.cumprod( self.RING_PARA_PAIR_CC[i][1] - self.RING_PARA_PAIR_CC[i][0].VECTOR )[-1] ); # ---------------------------------------------------------------->>>>>\n self.RING_PARA_PAIR_CC[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID]; # 更新内部VECTOR;\n self.RING_PARA_PAIR_CC[i][2] = self.RING_PARA_PAIR_CC[i][0].polynomial_func(self.RING_PARA_PAIR_CC[i][1]); # 更新内部ALPHA;\n \"\"\" Secondly,adjust the alpha_0 < p_min(y_n) < q_min(x_n)\"\"\" \n P_MIN = 99999999.0; Q_MIN = 99999999.0;P_MAX = 0.0;Q_MAX = 0.0;\n CD_ID = 0;CD_MIN=0;\n # 找到结论中谓词的最小多项式值\n for RING_PARA_PAIR in self.RING_PARA_PAIR_CC:\n if Q_MIN>RING_PARA_PAIR[2]: Q_MIN=RING_PARA_PAIR[2];\n # if Q_MAX<RING_PARA_PAIR[2]: Q_MAX=RING_PARA_PAIR[2];\n # 不满足小于结论最小值的那些环的TARGET_ALPHA更新; \n for RING_PARA_PAIR in self.RING_PARA_PAIR_CD:\n if P_MIN>RING_PARA_PAIR[2]: P_MIN=RING_PARA_PAIR[2];CD_MIN=CD_ID;# self.RING_PARA_PAIR_CD[CD_ID][3]=-Q_MIN;\n # if P_MAX<RING_PARA_PAIR[2]: P_MAX=RING_PARA_PAIR[2];self.RING_PARA_PAIR_CD[CD_ID][3]=-Q_MAX;\n CD_ID+=1;\n self.RING_PARA_PAIR_CD[CD_MIN][3]=-Q_MIN; \n # 优化不满足小于结论最小值的那些环 \n for i in range(len(self.RING_PARA_PAIR_CD)): \n if self.RING_PARA_PAIR_CD[i][3]!=ALPHA:\n if P_MIN>Q_MIN:\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CD[i]); \n self.RING_PARA_PAIR_CD[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CD[i][0].WORD_ID]; # 更新内部VECTOR;\n self.RING_PARA_PAIR_CD[i][2] = self.RING_PARA_PAIR_CD[i][0].polynomial_func(self.RING_PARA_PAIR_CD[i][1]); # 更新内部ALPHA;","def _perform_single_iteration(self):\n self.iteration += 1\n p1 = [self.a * z + self.b * z.conjugate()\n for z in self.points]\n p2 = [self.c * (z - 1) + self.d * (z.conjugate() - 1) + 1\n for z in self.points]\n self.points = p1 + p2","def solve(self):\n\n # Set up display header if verbose operation enabled\n if self.opt['Verbose']:\n hdr = 'Itn DFidX PriResX DuaResX DFidG' + \\\n ' ResG '\n print(hdr)\n print('-' * len(hdr))\n\n # Main iteration loop\n for n in range(self.opt['MaxMainIter']):\n\n # At start of 2nd iteration, set the numbers of inner\n # iterations for the X and G solvers from the options\n # object for the outer solver\n if n == 1:\n self.slvX.opt['MaxMainIter'] = self.opt['XslvIter']\n self.slvG.opt['MaxMainIter'] = self.opt['GslvIter']\n\n # Run the configured number of iterations of the X (CSC)\n # solver and assign the result to X\n self.X = self.slvX.solve()\n\n # Compute the sum of the subpixel shifts of X\n Xhs = np.sum(fftconv(self.H, self.X.squeeze(), axes=(0, 1)),\n axis=-1)\n\n # Set the convolution kernel in the deconvolution solver\n # to the sum of the subpixel shifts of X\n self.slvG.setG(Xhs)\n # Run the configured number of iterations of the G\n # (deconvolution) solver and crop the result to obtain the\n # updated g\n self.g = self.slvG.solve()[0:self.gshp[0], 0:self.gshp[1]]\n\n # Construct a new dictionary for the X (CSC) solver from\n # the updated psf g\n self.D, self.dn = self.getD(self.g)\n self.slvX.setdict(self.D[..., np.newaxis, np.newaxis, :])\n\n # Display iteration statistics if verbose operation enabled\n if self.opt['Verbose']:\n itsX = self.slvX.getitstat()\n itsG = self.slvG.getitstat()\n fmt = '%3d %.3e %.3e %.3e %.3e %.3e'\n tpl = (n, itsX.DFid[-1], itsX.PrimalRsdl[-1],\n itsX.DualRsdl[-1], itsG.DFid[-1], itsG.Rsdl[-1])\n print(fmt % tpl)\n\n # Return the (normalised) psf estimate g\n return self.g / np.linalg.norm(self.g)","def run(self, x):\n T = len(x)\n self.x = x\n self.i = np.zeros((T, self.hidden_size))\n self.f = np.zeros((T, self.hidden_size))\n self.o = np.zeros((T, self.hidden_size))\n self.g = np.zeros((T, self.hidden_size))\n self.h = np.zeros((T, self.hidden_size))\n self.c = np.zeros((T+1, self.hidden_size))\n self.s = np.zeros((T+1, self.hidden_size))\n for t in xrange(T):\n # input gate\n self.i[t] = self.gatefun.compute(np.dot(self.igate.u, x[t])\n + np.dot(self.igate.w, self.s[t-1])\n + np.dot(self.igate.v, self.c[t-1]) + self.igate.b)\n # forget gate\n self.f[t] = self.gatefun.compute(np.dot(self.fgate.u, x[t])\n + np.dot(self.fgate.w, self.s[t-1])\n + np.dot(self.fgate.v, self.c[t-1]) + self.fgate.b)\n # current hidden node state\n self.g[t] = self.acfun.compute(np.dot(self.nodes.u, x[t]) + \n np.dot(self.nodes.w, self.s[t-1]) + self.nodes.b)\n # internal memoery\n self.c[t] = self.f[t] * self.c[t-1] + self.i[t] * self.g[t]\n # output gate\n self.o[t] = self.gatefun.compute(np.dot(self.ogate.u, x[t])\n + np.dot(self.ogate.w, self.s[t-1])\n + np.dot(self.ogate.v, self.c[t]) + self.ogate.b)\n self.h[t] = self.acfun.compute(self.c[t])\n self.s[t] = np.clip(self.o[t] * self.h[t], -50, 50)\n return self.s[:-1]","def solve(self):\n for x in range(9):\n for y in range(9):\n if self.arr[x][y] == 0:\n for value in range(1,10):\n if self.is_possible_value(x,y,value):\n self.arr[x][y] = value\n self.solve()\n self.arr[x][y] = 0 \n return\n print(np.matrix(self.arr))","def obtain_ones_in_the_main_diagonal(self):\r\n for row in range(self.SIZE):\r\n self.check_solvability(self.matrix[row][row], self.matrix[row][-1])\r\n self.matrix[row][-1] = self.divide(self.matrix[row][-1], self.matrix[row][row])\r\n self.matrix[row][row] = self.divide(self.matrix[row][row], self.matrix[row][row])","def assignMoreVectors(self, i):\n return","def solve(self):\r\n while not self.done():\r\n self.no_open_cells()\r\n self.all_cells_are_mines()\r\n self.no_mines()\r\n if not self.done():\r\n self.obvious_cells()\r\n if not self.done():\r\n made_progress = self.safe_neighbour_difference()\r\n if made_progress:\r\n continue\r\n if not self.done():\r\n made_progress = self.adjacent_combinations()\r\n if made_progress:\r\n continue\r\n return","def advect (u, v):\r\n # NOTICE: memory usage might be too high, could optimize\r\n\r\n # Store the values from timestep n\r\n un = u\r\n vn = v\r\n\r\n for i in range (height):\r\n for j in range (width):\r\n oldpos = coord (i,j) - dt * np.stack((u[i,j], v[i,j]))\r\n u[i,j], v[i,j] = interpolate (un, vn, oldpos)\r\n\r\n\r\n # Return values for timestep n+1\r\n return u, v","def prepare(self):\n ls=len(self.v)\n self.S=numpy.zeros(ls)\n self.A=numpy.zeros((ls,ls))\n\n for k,v in self.e.items():\n b,e=k\n bi,ei=self.rv[b],self.rv[e]\n self.A[bi,bi]-=v\n self.A[bi,ei]+=v","def CreateAtrium(L,v,d,seed): \n Neighbours = np.ndarray(L*L, dtype = list)\n rnd.seed(seed)\n Phases = np.ndarray(L*L,dtype = float)\n Phases.fill(4)\n Functionality = np.ndarray([L*L], dtype = bool)\n index = np.indices((1, L*L))[1][0]\n Atrium = index.reshape(L,L) # The index for that site within the long arrays\n for j in index:\n z = rnd.uniform(0,1)\n if d > z: # dysfunctional\n Functionality[j] = False\n if d <= z: # functional\n Functionality[j] = True\n if j in np.arange(0,L*L,L): # first column\n Neighbours[j] = list()\n Neighbours[j].extend([j+1])\n elif j in (np.arange(0,L*L,L)+L-1): # last column\n Neighbours[j] = list()\n Neighbours[j].extend([j-1])\n else: # body columns\n Neighbours[j] = list()\n Neighbours[j].extend([j-1,j+1])\n w = rnd.uniform(0,1)\n for j in np.arange(L*L):\n if w <= v: # transverse connections\n if j in np.arange(L*L-L,L*L):\n Neighbours[j].extend([j-(L*L-L)])\n Neighbours[j-(L*L-L)].extend([j])\n else:\n Neighbours[j].extend([j+L])\n Neighbours[(j+L)].extend([j])\n return Neighbours, Phases, Functionality, Atrium, index","def adj(self, v):\n for e in self._adj[v]:\n yield e","def relax_method(self, step, data, method, verbose, tree, n_jobs, second_pass = False):\n\n unassigned_array_length = len(self.unassigned_data_relax[0,:])\n\n count=0.0\n if verbose and second_pass:\n progress_bar = print_to_terminal(self, step, data, count, \\\n unassigned_array_length,\\\n method, re=False, second_pass=second_pass)\n else:\n progress_bar = print_to_terminal(self, step, data, count, \\\n unassigned_array_length,\\\n method, re=True, second_pass=second_pass)\n\n # Now run the linking again with the relaxed constraints\n for i in range(0, unassigned_array_length):\n\n if verbose and (count % 1 == 0):\n progress_bar + 1\n progress_bar.show_progress()\n\n # Extract the current data point\n data_point = np.array(self.unassigned_data_relax[:,i])\n # Retrieve this data point's location in the data array\n data_idx = get_data_index(self, data, data_point)\n\n current_idx = get_current_index(self, i)\n\n # Every data point starts as a new cluster\n self.cluster_idx = current_idx\n bud_cluster = Cluster(data_point, data_idx, idx=self.cluster_idx, acorns=self)\n\n # Calculate distances between all data points\n link = get_links(self, i, current_idx, tree, n_jobs, re=True)\n\n # Find clusters that are closely associated with the current\n # data point\n linked_clusters = find_linked_clusters(self, data, i, bud_cluster, link, re = True)\n\n if (self.method==1) & (len(linked_clusters) >= 1):\n linked_clusters = check_other_components(self, i, current_idx, data_idx, data, linked_clusters, bud_cluster, tree, n_jobs, re=False)\n\n if not linked_clusters:\n add_to_cluster_dictionary(self, bud_cluster)\n elif len(linked_clusters) == 1:\n merge_into_cluster(self, data, linked_clusters[0], bud_cluster, re = True)\n else:\n resolve_ambiguity(self, data, linked_clusters, bud_cluster, re = True)\n\n if verbose:\n progress_bar.progress = 100 # Done\n progress_bar.show_progress()\n print('')\n print('')\n\n return","def createsolution(self,rows):\r\n l = [0,0]\r\n if not self.findzero(l):\r\n return True\r\n x = l[0]\r\n y = l[1]\r\n for i in range(1,10):\r\n if self.check(i, x, y):\r\n rows[x][y] = i\r\n if self.createsolution(rows):\r\n return True\r\n rows[x][y] = 0\r\n return False","def value_iteration(P, nS, nA, V, gamma=0.9, tol=1e-8):\n \n V_new = V.copy()\n ############################\n # YOUR IMPLEMENTATION HERE #\n while True:\n deltaV=0;\n for state in range(nS):\n # new_value=0;\n action_policy = np.zeros(nA) \n for action in range(nA):\n for p,nextS,r,boolean_v in P[state][action]:\n action_policy[action] += p*( r + gamma* V[nextS])\n V_new[state]=max(action_policy)\n deltaV= max(deltaV, abs(V_new[state]-V[state]))\n V[state] = V_new[state]\n #print(value_function)\n if(deltaV < tol):\n break\n policy_new = policy_improvement(P, nS, nA, V_new, gamma)\n ############################\n return policy_new, V_new","def test_tensors_can_substitute_vectors_simultaneously(\n free_alg, full_balance, full_simplify\n):\n\n dr = free_alg\n p = dr.names\n\n x = IndexedBase('x')\n i, j = p.i, p.j\n v = p.v\n\n orig = dr.einst(x[i, j] * v[i] * v[j])\n v_def = dr.sum(2 * v[i])\n\n dr.full_simplify = full_simplify\n res = orig.subst(v[i], v_def, full_balance=full_balance).simplify()\n dr.full_simplify = True\n\n expected = dr.einst(4 * x[i, j] * v[i] * v[j]).simplify()\n assert res == expected"],"string":"[\n \"def relaxVertex(self, v):\\r\\n for arc in self.graph.getAdj(v):\\r\\n neighbour = arc.getExtremityNode()\\r\\n if neighbour in self.closed_set:\\r\\n continue\\r\\n self.nb_relax_edges += 1\\r\\n new_dist = self.dists_so_far[v] + arc.getWeight()\\r\\n # print(arc.getTravelType(), arc.getWeight(), end=\\\" \\\")\\r\\n if neighbour not in self.preds or new_dist < self.dists_so_far[neighbour]:\\r\\n self.preds[neighbour] = v\\r\\n self.dists_so_far[neighbour] = new_dist\\r\\n self.pushPriorityQueue((new_dist, neighbour))\",\n \"def _relax(self, G, v):\\n for e in G.adj(v):\\n w = e.get_to()\\n if self._distTo[w] > self._distTo[v] + e.weight()):\\n self._distTo[w] = self._distTo[v] + e.weight()\\n self._edgeTo[w] = e\\n if not self._onQueue[w]:\\n self_queue.append(w) # enqueue(w)\\n self._onQueue[w] = True\\n if self._cost%G.V() == 0:\\n self.findNegativeCycle()\\n if self.hasNegativeCycle(): return # found a negative cycle\\n self._cost += 1\",\n \"def iterate_value(self):\\n self.V = np.zeros(self.stateCount)\\n for i in range(self.maxIter):\\n last_V = np.copy(self.V)\\n for state_index in range(self.stateCount):\\n current_state = self.env.statespace[state_index]\\n for action in self.env.actionspace:\\n next_state = self.env.next_state(current_state,action)\\n reward = self.env.compute_reward(next_state)\\n next_state_index = self.env.stateDict[next_state]\\n self.Q[state_index][action] = reward + self.gamma*last_V[next_state_index]\\n if self.mode == 'debug':\\n print(\\\"Q(s={}):{}\\\".format(current_state,self.Q[state_index]))\\n self.V[state_index] = max(self.Q[state_index])\\n if np.sum(np.fabs(last_V - self.V)) <= self.th:\\n print (\\\"Convergene Achieved in {}th iteration. \\\"\\n \\\"Breaking V_Iteration loop!\\\".format(i))\\n break\",\n \"def calculate():\\n global v, vNew, n, stepsToToleranceArray\\n stepsToToleranceArray = []\\n for n in nArray:\\n print('Currently working with n = ', n)\\n initiateVMatrixes()\\n step = 0\\n toleranceAcqurired = False\\n while not toleranceAcqurired:\\n step+=1\\n relax_checker()\\n # Controll accuracy\\n toleranceAcqurired = True # run through v and set false if not acquired\\n for i in range(1,n):\\n for j in range(1,n):\\n if np.abs( (v[i,j]-vExact[i,j])/vExact[i,j] ) > tolerance:\\n toleranceAcqurired = False\\n if toleranceAcqurired:\\n stepsToToleranceArray.append(step)\\n if n in [5,10]: print('n =', n, 'steps =', step)\",\n \"def _arnoldi_fact(matvec, args, v0, krylov_vectors, H, start, num_krylov_vecs,\\n eps):\\n Z = jax.numpy.linalg.norm(v0)\\n v = v0 / Z\\n krylov_vectors = jax.ops.index_update(krylov_vectors,\\n jax.ops.index[start, :],\\n jax.numpy.ravel(v))\\n H = jax.lax.cond(\\n start > 0, start,\\n lambda x: jax.ops.index_update(H, jax.ops.index[x, x - 1], Z), None,\\n lambda x: H)\\n\\n # body of the arnoldi iteration\\n def body(vals):\\n krylov_vectors, H, matvec, vector, _, threshold, i, maxiter = vals\\n Av = matvec(vector, *args)\\n initial_vals = [Av, krylov_vectors, i, H]\\n Av, krylov_vectors, _, H = jax.lax.fori_loop(\\n 0, i + 1, modified_gram_schmidt_step_arnoldi, initial_vals)\\n norm = jax.numpy.linalg.norm(Av)\\n Av /= norm\\n H = jax.ops.index_update(H, jax.ops.index[i + 1, i], norm)\\n krylov_vectors = jax.ops.index_update(krylov_vectors,\\n jax.ops.index[i + 1, :],\\n jax.numpy.ravel(Av))\\n return [krylov_vectors, H, matvec, Av, norm, threshold, i + 1, maxiter]\\n\\n def cond_fun(vals):\\n # Continue loop while iteration < num_krylov_vecs and norm > eps\\n _, _, _, _, norm, _, iteration, _ = vals\\n counter_done = (iteration >= num_krylov_vecs)\\n norm_not_too_small = norm > eps\\n continue_iteration = jax.lax.cond(counter_done,\\n _, lambda x: False,\\n _, lambda x: norm_not_too_small)\\n\\n return continue_iteration\\n initial_norm = v.real.dtype.type(1.0+eps)\\n initial_values = [krylov_vectors, H, matvec, v, initial_norm, eps, start,\\n num_krylov_vecs]\\n final_values = jax.lax.while_loop(cond_fun, body, initial_values)\\n kvfinal, Hfinal, _, _, norm, _, it, _ = final_values\\n return kvfinal, Hfinal, it, norm < eps\",\n \"def solve_VFI(self):\\r\\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \\r\\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\\r\\n tol = self.tol ; Niter = self.Niter ; R = self.R\\r\\n beta = self.beta ; Pi = self.Pi\\r\\n \\r\\n V0 = np.zeros((dimA,dimC,dimW))\\r\\n V1 = np.zeros((dimA,dimC,dimW))\\r\\n Pol = np.zeros((dimA,dimC,dimW))\\r\\n U = np.zeros((dimA,dimC,dimW))\\r\\n \\r\\n t0 = time()\\r\\n diff = 1 ; niter = 0\\r\\n \\r\\n while diff > tol:\\r\\n niter += 1\\r\\n # Value update step\\r\\n for ia in range(dimA):\\r\\n for ic in range(dimC):\\r\\n for iw in range(dimW):\\r\\n c = W[iw] + R*A[ia] - A\\r\\n x = C[ic]\\r\\n \\r\\n c[c < 0] = np.nan \\r\\n if x < 0:\\r\\n x = np.nan\\r\\n \\r\\n u = self.u(c,x) \\r\\n U[:,ic,iw] = u \\r\\n \\r\\n Objective = U + beta * V0 @ Pi.T\\r\\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\\r\\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\\r\\n \\r\\n # Evaluate distance between the value functions\\r\\n diff = np.max(np.max(np.abs(V1 - V0))) \\r\\n V0[:] = V1\\r\\n \\r\\n # Break the while loop if too many iterations\\r\\n #print(\\\"The current error is \\\"+str(diff))\\r\\n if niter > Niter:\\r\\n print('Ops, no convergence')\\r\\n break\\r\\n \\r\\n t1 = time()\\r\\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\\r\\n \\r\\n self.V1 = V1 ; self.Pol = Pol\",\n \"def amalgamate(self,i,j):\\n # conserve momentum\\n self.v[i] = (self.v[i]*self.m[i]+self.v[j]*self.m[j])/ \\\\\\n (self.m[i]+self.m[j])\\n self.r[i] = (self.r[j] - self.r[i])/2 + self.r[j] \\n self.m[i] = self.m[i] + self.m[j]\\n self.r[j] = self.r[self.n-1]\\n self.v[j] = self.v[self.n-1]\\n self.m[j] = self.m[self.n-1]\\n self.n = self.n - 1\",\n \"def solve(self):\\n initial_fes = eades(self.graph, self.force_forward_edges)\\n initial_fes_vec = self.edge_vector(initial_fes)\\n\\n # bounds for the objective\\n lower_bound = 0\\n upper_bound = np.sum(initial_fes_vec @ self.weights)\\n\\n self.logger.info('Calculating FES for graph with %d edges, max %d feedback edges', self.m, len(initial_fes))\\n\\n simple_cycles = set(induced_cycles(self.graph, initial_fes))\\n\\n for iteration in itertools.count(1):\\n self.logger.info('Baharev iteration %d, %g <= objective <= %g, %d simple cycles', iteration, lower_bound,\\n upper_bound, len(simple_cycles))\\n\\n # Formulate and solve the problem for this iteration:\\n y = cp.Variable(self.m, boolean=True, name=\\\"y\\\")\\n objective = cp.Minimize(cp.sum(y @ self.weights))\\n\\n cycle_vectors = [self.edge_vector(nx.utils.pairwise(cycle)) for cycle in simple_cycles]\\n constraints = [cp.sum(a @ y) >= 1 for a in cycle_vectors]\\n constraints.append(cp.sum(y @ self.force_forward_vec) == 0) # no force forward vec may be in the result set\\n problem = cp.Problem(objective, constraints)\\n resolution = problem.solve(**self.solver_args)\\n if problem.status != 'optimal':\\n self.logger.warning('Optimization solution is %s. Try solver != %s?', problem.status,\\n problem.solver_stats.solver_name)\\n self.logger.debug(\\n \\\"Solved optimization problem with %d constraints: %s -> %s (%g + %g seconds, %d iterations, solver %s)\\\",\\n len(constraints), resolution, problem.solution.status,\\n problem.solver_stats.solve_time or 0, problem.solver_stats.setup_time or 0,\\n problem.solver_stats.num_iters or 0, problem.solver_stats.solver_name)\\n current_solution = np.abs(y.value) >= 0.5 # y.value = vector of floats each ≈ 0 or 1\\n current_fes = self.edges_for_vector(current_solution)\\n self.logger.debug('Iteration %d, resolution: %s, %d feedback edges', iteration, resolution,\\n len(current_fes))\\n # S, the feedback edge set calculated using the constraint subset, can be an incomplete solution\\n # (i.e. cycles remain after removing S from the graph). So lets compare this with the upper bound\\n # from the heuristic\\n lower_bound = max(lower_bound, objective.value)\\n if lower_bound == upper_bound:\\n self.logger.info('upper == lower bound == %g, optimal solution found', lower_bound)\\n break # y.value is the optimal solution\\n\\n if resolution > upper_bound:\\n self.logger.error('Solution %g > upper bound %g!', resolution, upper_bound)\\n break\\n\\n Gi = self.graph.copy()\\n Gi.remove_edges_from(current_fes)\\n if nx.is_directed_acyclic_graph(Gi):\\n self.logger.info('Graph is acyclic, optimal solution found')\\n break # y.value is the optimal solution\\n\\n # The solution is not yet ideal. So we take G^(i), the graph still containing some feedback edges,\\n # calculate a heuristic on it and use the heuristic (= over-estimation) to adjust upper bound and\\n # determine additional simple cycles (= constraints)\\n Fi = eades(Gi, self.force_forward_edges)\\n yi = self.edge_vector(Fi) | current_solution\\n zi = np.sum(yi @ self.weights)\\n if zi < upper_bound:\\n upper_bound = zi\\n current_solution = yi\\n simple_cycles |= set(induced_cycles(Gi, Fi))\\n\\n self.solution_vector = current_solution\\n self.solution = self.edges_for_vector(current_solution)\\n self.objective = objective.value\\n self.iterations = iteration\\n self.simple_cycles = simple_cycles\\n return self.solution\",\n \"def initiateVMatrixes():\\n global v, vNew, vExact\\n # Initialize the grid to 0\\n v = np.zeros((n+1, n+1)) # matrix of v, index are i: row, j:column\\n # Set the boundary conditions\\n for i in range(1,n):\\n v[0,i] = 10\\n v[n,i] = 10\\n v[i,0] = 10\\n v[i,n] = 10\\n # Exact solution\\n vExact = np.copy(v)\\n for i in range(1,n):\\n for j in range(1,n):\\n vExact[i,j] = 10\\n # Initial guess\\n for i in range(1,n):\\n for j in range(1,n):\\n v[i,j] = 0.9*vExact[i,j]\\n vNew = np.copy(v)\",\n \"def run(self):\\n\\t\\tfrom loc import loc as Loc\\n\\t\\tfor r in range(1,self.size):\\n\\t\\t\\tfor c in range(self.size): \\n\\t\\t\\t\\tthis = Loc(r,c)\\n\\t\\t\\t\\tself.state.set_cell(this, self.rule(self.neighbor_vals(this), self.__prob))\\n\\t\\tself.__ran = True\",\n \"def _update_local_solution(self, x: np.ndarray, x_neigh: dict, stepsize: float, **kwargs):\\r\\n for j, x_j in x_neigh.items():\\r\\n self.lambd[j] += stepsize * (x - x_j)\\r\\n \\r\\n self.x = x\",\n \"def IterateValues(self):\\n agrid = self.agrid\\n self.w = self.setwage(self.K, self.N)\\n self.r = self.setrate(self.K, self.N)\\n self.b = self.benefit(self.N)\\n\\n for l in range(self.Na): \\n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\\n self.v[-1][l] = self.util(self.c[-1][l],0)\\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\\n\\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\\n m0 = 0 \\n for l in range(self.Na):\\n # Find a bracket within which optimal a' lies\\n m = max(0, m0-1)\\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\\n # Define objective function for optimal a'\\n def objfn(a1):\\n v = self.value(y, agrid[l], a1)\\n return -v\\n # Find optimal a' using Golden Section Search\\n if a == b:\\n self.a[y][l] = 0\\n elif b == c:\\n self.a[y][l] = agrid[-1]\\n else:\\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\\n #‘Brent’,‘Bounded’,‘Golden’\\n self.a[y][l] = result.x\\n # Computing consumption and labor\\n if y >= -self.R:\\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\\n else:\\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')\",\n \"def relax(self,n=1):\\n # print(\\\"putin\\\", self.level.rhs.reshape(-1)[:])\\n # print(\\\"getout\\\", self.solver(self.level.rhs.reshape(-1)))\\n for i in range(n):\\n self.level.mid[:] += (self.solver(self.level.rhs.reshape(-1)) -\\n self.solver(self.stencil.eval_convolve(\\n self.level.evaluable_view(self.stencil)).reshape(-1))).reshape(self.level.mid.shape)\",\n \"def _relax_loop(self, n=1):\\n tmp = self.lvl_view.copy()\\n flat_iter = self.lvl_view.flat\\n # print(\\\"Stencil :\\\", self.stencil.arr)\\n # print(\\\"LevelView:\\\", self.lvl_view)\\n # print(\\\"relative Posistions :\\\", self.stencil.relative_positions)\\n # print(\\\"Size of lvl_view: \\\", self.lvl_view.size)\\n for i in range(self.lvl_view.size):\\n if not self.is_on_border(flat_iter.coords):\\n # apply L_minus on u\\n # print(\\\"The coords \\\", flat_iter.coords, \\\"are not on the border\\\")\\n # print(\\\"And the relative coordinates used are:\\\")\\n my_sum = self.center_value * (1.0-1.0/self.omega) * self.lvl_view[flat_iter.coords]\\n for st_pos in self.stencil.relative_positions_woc:\\n coords = tuple(np.asarray(flat_iter.coords) + np.asarray(st_pos))\\n # print(\\\"relative_coords: \\\", coords)\\n # print(\\\"coords_in_stencil: \\\", st_pos + self.stencil.center)\\n my_sum += self.stencil.arr[tuple(st_pos + self.stencil.center)] * \\\\\\n self.lvl_view[coords]\\n\\n tmp[flat_iter.coords] = -my_sum * self.omega / self.center_value\\n # print(self.lvl_view[flat_iter.coords])\\n next(flat_iter)\\n self.lvl_view.reshape(-1)[:] = tmp.reshape(-1)[:]\",\n \"def update_gol(arr):\\n nxt = np.zeros(arr.shape)\\n rows,cols = nxt.shape\\n for i in range(rows):\\n for j in range(cols):\\n nn = sum_vonneuman_nn(arr,i,j)\\n if arr[i][j]==1:\\n if nn==2 or nn==3:\\n nxt[i][j]=1\\n else:\\n if nn==3:\\n nxt[i][j]=1\\n return nxt\",\n \"def one_step(self):\\r\\n assert (self.uv_vol is not None)\\r\\n assert (self.guv_vol is not None)\\r\\n assert (self.uv_bound is not None)\\r\\n assert (self.vf_vect_bound is not None)\\r\\n assert (self.vF_vect_vol is not None)\\r\\n # Shape checks\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\\r\\n assert (self.uv_vol.shape == self.guv_vol.shape)\\r\\n assert (self.uv_vol.shape == self.uv_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\\r\\n \\r\\n if self.step == 0:\\r\\n self.check_k_matrix_stability()\\r\\n # print(\\\"Epsilon is :\\\"+str(self.Epsilon))\\r\\n # print(\\\"Beta is :\\\"+str(self.Beta))\\r\\n\\r\\n # Form \\\"Stiffness\\\" matrix:\\r\\n K = self.make_k_matrix()\\r\\n # Form \\\"Force\\\" vector: \\r\\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\\r\\n\\r\\n # print(\\\"FORCE VECTOR:\\\")\\r\\n # print(f)\\r\\n # print(\\\"STIFFNESS MATRIX\\\")\\r\\n # print(K)\\r\\n # print(\\\"UV_VOL\\\")\\r\\n # print(self.uv_vol)\\r\\n # print(\\\"EPSILON * GUV_VOL\\\")\\r\\n # print(self.Epsilon * self.guv_vol)\\r\\n # print(\\\"UV_BOUND * COEFF\\\")\\r\\n # print((self.Epsilon / self.Beta) * self.uv_bound)\\r\\n sol = scipy_sparse_linsolve(K, f)\\r\\n # print(\\\"SOLUTION\\\")\\r\\n # print(sol)\\r\\n return sol\",\n \"def test_numbers_can_substitute_vectors(free_alg, full_balance):\\n\\n dr = free_alg\\n p = dr.names\\n\\n x = IndexedBase('x')\\n y = IndexedBase('y')\\n r = p.R\\n i, j, k, l = symbols('i j k l')\\n v = p.v\\n w = Vec('w')\\n\\n orig = dr.sum((i, r), (j, r), x[i, j] * v[i] * w[j] + y[i, j] * v[i] * v[j])\\n\\n res = orig.subst(v[k], 0, full_balance=full_balance).simplify()\\n assert res == 0\\n res = orig.subst(v[i], 1, full_balance=full_balance).simplify()\\n assert res == dr.sum((i, r), (j, r), x[j, i] * w[i] + y[i, j])\",\n \"def value_iteration(r,terminal_states_mask, not_slipping_prob=1,\\n initial_policy=None,\\n eps=0.1):\\n V = np.copy(r).astype(np.float)\\n for _ in range(200):\\n Vdet_u = np.copy(V)\\n Vdet_r = np.copy(V)\\n Vdet_l = np.copy(V)\\n Vdet_d = np.copy(V)\\n\\n Vdet_u[1:, :] = V[:-1, :]\\n Vdet_r[:, :-1] = V[:, 1:]\\n Vdet_l[:, 1:] = V[:, :-1]\\n Vdet_d[:-1, :] = V[1:, :]\\n\\n nsp = not_slipping_prob\\n Vnext = np.zeros((4, )+r.shape, dtype=float)\\n Vnext[UP, :, :] = nsp * Vdet_u + 0.5 * (1-nsp) * Vdet_l + 0.5 * (\\n 1-nsp) * Vdet_r\\n Vnext[DOWN, :, :] = nsp * Vdet_d + 0.5 * (1-nsp) * Vdet_l + 0.5 * (\\n 1-nsp) * Vdet_r\\n Vnext[LEFT, :, :] = nsp * Vdet_l + 0.5 * (1-nsp) * Vdet_u + 0.5 * (\\n 1-nsp) * Vdet_d\\n Vnext[RIGHT, :, :] = nsp * Vdet_r + 0.5 * (1-nsp) * Vdet_u + 0.5 * (\\n 1-nsp) * Vdet_d\\n if initial_policy is None:\\n policy = np.argmax(r[None, :, :] + Vnext, axis=0)\\n else:\\n policy = np.copy(initial_policy)\\n\\n Vnew = np.copy(V)\\n for a in [UP, DOWN, LEFT, RIGHT]:\\n ind = np.logical_and(policy == a, ~ terminal_states_mask)\\n Vnew[ind] = r[ind] + Vnext[a][ind]\\n if np.linalg.norm(V - Vnew, ord=np.inf) < eps:\\n break\\n V[:, :] = Vnew\\n return policy, V\",\n \"def relu(self, v):\\n if v > 0:\\n solution = v\\n else:\\n solution = 0\\n return solution\",\n \"def ObserveEvidence(self,E):\\r\\n for v,e in E.iteritems():\\r\\n indx, = (self.var==v).nonzero() # find i where f.var[i]=v\\r\\n if indx.size != 0:\\r\\n A = I2A(range(len(self.val)), self.card) # all assignments\\r\\n A = A[:,indx].flatten() # only interested in 'indx' element of each row\\r\\n self.val[A != e] = 0\",\n \"def do_relax(self):\\n raise NotImplementedError\",\n \"def relax(self, n=1):\\n\\n for i in range(n):\\n rhs = self.lvl.rhs - self.st_minus.eval_convolve(self.evaluable_view, self.convolve_control)\\n self.lvl.mid[:] = self.l_plus_solver(rhs.reshape(-1)).reshape(self.lvl.mid.shape)\",\n \"def vectorized_result(j):\\n\\te = np.zeros((3, 1))\\n\\te[j] = 1.0\\n\\treturn e\",\n \"def runIteration(self, task, Sol, Fitness, xb, fxb, A, S, Q, v, **dparams):\\n\\t\\tfor i in range(self.NP):\\n\\t\\t\\tQ[i] = self.Qmin + (self.Qmax - self.Qmin) * self.uniform(0, 1)\\n\\t\\t\\tv[i] += (Sol[i] - xb) * Q[i]\\n\\t\\t\\tif self.rand() > self.r: S[i] = self.localSearch(best=xb, A=A[i], task=task, i=i, Sol=Sol)\\n\\t\\t\\telse: S[i] = task.repair(Sol[i] + v[i], rnd=self.Rand)\\n\\t\\t\\tFnew = task.eval(S[i])\\n\\t\\t\\tif (Fnew <= Fitness[i]) and (self.rand() < A[i]): Sol[i], Fitness[i] = S[i], Fnew\\n\\t\\t\\tif Fnew <= fxb: xb, fxb, A[i] = S[i].copy(), Fnew, self.updateLoudness(A[i])\\n\\t\\treturn Sol, Fitness, xb, fxb, {'A': A, 'S': S, 'Q': Q, 'v': v}\",\n \"def equiangulate(self,x,mask):\\n\\n timeout = 100\\n k = 0\\n while (not mask.all())and(k<timeout):\\n\\n changed_tris,j = np.nonzero(~mask)\\n chosen_cell = changed_tris[0]\\n cell_mask = np.zeros(3,dtype=np.bool)\\n cell_mask[j[0]] = True\\n chosen_opposite_cell = self.v_neighbours[chosen_cell,cell_mask][0]\\n\\n\\n cells = np.roll(self.tris[chosen_cell],-j[0])\\n opposite_cells = self.tris[chosen_opposite_cell]\\n opposite_cells = np.roll(opposite_cells, - self.k2s[chosen_cell,cell_mask])\\n\\n\\n self.tris[chosen_cell] = cells[0], opposite_cells[0],cells[2]\\n self.tris[chosen_opposite_cell] = opposite_cells[0],cells[0], opposite_cells[2]\\n\\n self.Angles[[chosen_cell,chosen_opposite_cell]] = tri_angles_periodic(x, self.tris[[chosen_cell,chosen_opposite_cell]], self.L)\\n # self.Angles = tri_angles_periodic(x,self.tris,self.L)\\n self.Cents = x[self.tris]\\n self.vs = self.get_vertex_periodic()\\n\\n\\n modify_neighbours = np.concatenate([self.v_neighbours[chosen_cell],self.v_neighbours[chosen_opposite_cell]])\\n modify_neighbours.sort()\\n self.v_neighbours[modify_neighbours] = -1\\n\\n\\n n_neigh = get_neighbours(self.tris,self.v_neighbours,Range = modify_neighbours)\\n self.v_neighbours = n_neigh\\n self.neighbours = self.vs[n_neigh]\\n\\n self.k2s = get_k2(self.tris, self.v_neighbours)\\n if (self.k2s>=3).sum()!=0:\\n self._triangulate_periodic(x)\\n self.k2s = get_k2(self.tris, self.v_neighbours)\\n mask[:] = True\\n else:\\n mask = ((self.Angles[self.v_neighbours, self.k2s] + self.Angles) < np.pi)\\n k+=1\\n if k == timeout:\\n self._triangulate_periodic(x)\\n self.k2s = get_k2(self.tris, self.v_neighbours)\",\n \"def _dfs_iteration(self, v):\\n stack1 = [v]\\n self._visited[v] = True\\n while stack1:\\n curr = stack1.pop()\\n for w in self._G.adj(curr):\\n if not self._visited[w]:\\n stack1.append(w)\\n self._visited[w] = True\\n self._pre[w] = curr\\n elif self._pre[w] != curr:\\n self.cycle = True\",\n \"def distort_vxs(self):\\n self.dvxs = self.vxs.copy()\\n self.dvxs[:, 0] += self.perlin()\\n self.dvxs[:, 1] += self.perlin()\",\n \"def vectorized_result(j):\\n e = np.zeros((10,))\\n e[j] = 1.0\\n return e\",\n \"def vectorized_result(j):\\n e = np.zeros((6, 1))\\n e[j] = 1.0\\n return e\",\n \"def _estimate_velocity_by_neigh(\\n x_coords_metres, y_coords_metres, x_velocities_m_s01,\\n y_velocities_m_s01, e_folding_radius_metres):\\n\\n if numpy.isnan(e_folding_radius_metres):\\n neigh_radius_metres = numpy.inf\\n else:\\n neigh_radius_metres = 3 * e_folding_radius_metres\\n\\n orig_x_velocities_m_s01 = x_velocities_m_s01 + 0.\\n orig_y_velocities_m_s01 = y_velocities_m_s01 + 0.\\n\\n nan_flags = numpy.logical_or(\\n numpy.isnan(orig_x_velocities_m_s01),\\n numpy.isnan(orig_y_velocities_m_s01)\\n )\\n nan_indices = numpy.where(nan_flags)[0]\\n\\n for this_index in nan_indices:\\n if numpy.isnan(e_folding_radius_metres):\\n these_neighbour_indices = numpy.where(numpy.invert(nan_flags))[0]\\n if len(these_neighbour_indices) == 0:\\n continue\\n\\n x_velocities_m_s01[this_index] = numpy.mean(\\n orig_x_velocities_m_s01[these_neighbour_indices]\\n )\\n\\n y_velocities_m_s01[this_index] = numpy.mean(\\n orig_y_velocities_m_s01[these_neighbour_indices]\\n )\\n\\n continue\\n\\n these_x_diffs_metres = numpy.absolute(\\n x_coords_metres[this_index] - x_coords_metres)\\n these_y_diffs_metres = numpy.absolute(\\n y_coords_metres[this_index] - y_coords_metres)\\n\\n these_neighbour_flags = numpy.logical_and(\\n these_x_diffs_metres <= neigh_radius_metres,\\n these_y_diffs_metres <= neigh_radius_metres)\\n\\n these_neighbour_flags = numpy.logical_and(\\n these_neighbour_flags, numpy.invert(nan_flags)\\n )\\n\\n these_neighbour_indices = numpy.where(these_neighbour_flags)[0]\\n if len(these_neighbour_indices) == 0:\\n continue\\n\\n these_neighbour_dist_metres = numpy.sqrt(\\n these_x_diffs_metres[these_neighbour_indices] ** 2 +\\n these_y_diffs_metres[these_neighbour_indices] ** 2\\n )\\n\\n these_neighbour_subindices = numpy.where(\\n these_neighbour_dist_metres <= neigh_radius_metres\\n )[0]\\n if len(these_neighbour_subindices) == 0:\\n continue\\n\\n these_neighbour_indices = these_neighbour_indices[\\n these_neighbour_subindices]\\n these_neighbour_dist_metres = these_neighbour_dist_metres[\\n these_neighbour_subindices]\\n\\n these_weights = numpy.exp(\\n -these_neighbour_dist_metres / e_folding_radius_metres\\n )\\n these_weights = these_weights / numpy.sum(these_weights)\\n\\n x_velocities_m_s01[this_index] = numpy.sum(\\n these_weights * orig_x_velocities_m_s01[these_neighbour_indices]\\n )\\n\\n y_velocities_m_s01[this_index] = numpy.sum(\\n these_weights * orig_y_velocities_m_s01[these_neighbour_indices]\\n )\\n\\n return x_velocities_m_s01, y_velocities_m_s01\",\n \"def solute(self, puzzle):\\r\\n \\\"\\\"\\\"suppose that ax = c, where a is a matrix, c and x are vectors.\\\"\\\"\\\"\\r\\n \\\"\\\"\\\"The aim is to figure out x, which indicates the solution.\\\"\\\"\\\"\\r\\n A, a, c = [], [], []\\r\\n for i in range(puzzle.row):\\r\\n for j in range(puzzle.column):\\r\\n # create a puzzle.row * puzzle.column by puzzle.row * puzzle.column matrix.\\r\\n # each column represents a cell in the puzzle.\\r\\n # each row represents the changed cell if column c is selected.\\r\\n if puzzle.lights[i][j] == -1:\\r\\n c.append(1)\\r\\n else:\\r\\n c.append(0)\\r\\n for m in range(puzzle.row):\\r\\n for n in range(puzzle.column):\\r\\n if self.is_adjecent([m, n], [i, j]):\\r\\n # if [m, n] is adjecent to [i, j], then a[ij][mn] should be 1.\\r\\n a.append(1)\\r\\n else:\\r\\n a.append(0)\\r\\n a.append(c[i * puzzle.column + j])\\r\\n A.append(a)\\r\\n a = []\\r\\n\\r\\n self.eliminate(A)\\r\\n x = [item[len(item) - 1] for item in A]\\r\\n # x is the last column of A.\\r\\n # if x[i] is 1, cell i should be selected.\\r\\n i = 0\\r\\n for m in range(puzzle.row):\\r\\n for n in range(puzzle.column):\\r\\n if x[i] == 1:\\r\\n puzzle.selection.add((m, n))\\r\\n i += 1\\r\\n\\r\\n return puzzle.selection\",\n \"def problem_reduction_single(self, i, val):\\n y_update = - val * self.A.getcol(i).toarray().flatten()\\n self.y += y_update\\n self.A = sparse.hstack([self.A[:, :i], self.A[:, i + 1:]], format='csr')\\n z_index = self.mask.searchsorted(i)\\n self.mask = np.insert(self.mask, z_index, i)\\n self.z = np.insert(self.z, z_index, val)\",\n \"def runIteration(self, task, Sol, Fitness, xb, fxb, A, r, S, Q, v, **dparams):\\n\\t\\tfor i in range(self.NP):\\n\\t\\t\\tA[i], r[i] = self.selfAdaptation(A[i], r[i])\\n\\t\\t\\tQ[i] = self.Qmin + (self.Qmax - self.Qmin) * self.uniform(0, 1)\\n\\t\\t\\tv[i] += (Sol[i] - xb) * Q[i]\\n\\t\\t\\tif self.rand() > r[i]: S[i] = self.localSearch(best=xb, A=A[i], task=task, i=i, Sol=Sol)\\n\\t\\t\\telse: S[i] = task.repair(Sol[i] + v[i], rnd=self.Rand)\\n\\t\\t\\tFnew = task.eval(S[i])\\n\\t\\t\\tif (Fnew <= Fitness[i]) and (self.rand() < (self.A_l - A[i]) / self.A): Sol[i], Fitness[i] = S[i], Fnew\\n\\t\\t\\tif Fnew <= fxb: xb, fxb = S[i].copy(), Fnew\\n\\t\\treturn Sol, Fitness, xb, fxb, {'A': A, 'r': r, 'S': S, 'Q': Q, 'v': v}\",\n \"def vj(vj, pol, ant) :\\n s.vj(pol, vj, ant)\",\n \"def vectorized_result(j):\\n print(j)\\n e = np.zeros([10])\\n e[j] = 1.0\\n return e\",\n \"def vectorized_result(j):\\n e = np.zeros((10, 1))\\n e[j] = 1.0\\n return e\",\n \"def vectorized_result(j):\\n e = np.zeros((10, 1))\\n e[j] = 1.0\\n return e\",\n \"def vectorized_result(j):\\n e = np.zeros((10, 1))\\n e[j] = 1.0\\n return e\",\n \"def vectorized_result(j):\\n e = np.zeros((10, 1))\\n e[j] = 1.0\\n return e\",\n \"def LD_Vx_I(self, x):\\n\\t\\tfor i in range(0, x + 1):\\n\\t\\t\\tself.V[i] = self.ram[self.I + i]\",\n \"def _eval(self, v):\\n Kv = np.zeros(self.K.output_size)\\n self.K.forward(v.ravel(), Kv)\\n return super(least_squares, self)._eval(Kv - self.offset)\",\n \"def LD_I_Vx(self, x):\\n\\t\\tfor i in range(0, x + 1):\\n\\t\\t\\tself.ram[self.I + i] = self.V[i]\",\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 vectorized_result(j):\\n e = np.zeros(shape=(10, 1))\\n e[j] = 1.0\\n\\n return e\",\n \"def _triangulate(self,x):\\n\\n t = tr.triangulate({\\\"vertices\\\": x},\\\"-n\\\")\\n tri = t[\\\"triangles\\\"]\\n neighbours = t[\\\"neighbors\\\"]\\n\\n b_cells = np.zeros(self.n_c)\\n b_cells[self.n_C:] = 1\\n\\n three_b_cell_mask = b_cells[tri].sum(axis=1)==3\\n tri = tri[~three_b_cell_mask]\\n\\n neigh_map = np.cumsum(~three_b_cell_mask)-1\\n neigh_map[three_b_cell_mask] = -1\\n neigh_map = np.concatenate((neigh_map,[-1]))\\n\\n neighbours = neighbours[~three_b_cell_mask]\\n neighbours = neigh_map[neighbours]\\n\\n #6. Store outputs\\n self.tris = tri\\n self.n_v = tri.shape[0]\\n self.Cents = x[self.tris]\\n self.vs = self.get_vertex()\\n\\n\\n #7. Manually calculate the neighbours. See doc_string for conventions.\\n self.v_neighbours = neighbours\\n self.neighbours = self.vs[neighbours]\\n self.neighbours[neighbours == -1] = np.nan\\n\\n self.reset_k2s()\",\n \"def iterations(self):\\n i = 0\\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\\n n = len(self.model.stateVector)\\n self.answer = None\\n \\n while ((i < self.maxiter) \\n and (stateVectorConv > self.stateVectorConvThreshold)\\n ):\\n \\n F, K = self.model()\\n \\n if np.any(np.isnan(F)) or np.any(np.isnan(K)):\\n m = \\\"Iteration {0} failure of model.\\\"\\n raise OptimalEstimationException(m.format(i))\\n \\n if self.model.verbose > 0:\\n self.model.plot(i+1, stateVectorConv)\\n \\n try:\\n self.DecomposeJacobian(K)\\n except np.linalg.LinAlgError:\\n m = \\\"Iteration {0} failure in decomposition.\\\"\\n raise OptimalEstimationException(m.format(i))\\n \\n statevectorOffset = (self.V.T * self.priorSinvh * \\n np.matrix(np.array(self.model.stateVector) - np.array(self.model.prior) ).T)\\n measurementOffset = (self.U.T * self.errSinvh * \\n np.matrix(self.model.observation - F).T)\\n \\n newState = np.matrix((self.w * \\n (measurementOffset.A1 + \\n self.w * statevectorOffset.A1))/(self.w**2+1.0)).T\\n newState = self.priorSh * self.V * newState\\n newState = newState.A1 + self.model.prior\\n \\n stateVectorConv = ((np.matrix(newState - self.model.stateVector) * \\n self.Sinv * np.matrix(newState - self.model.stateVector).T)/n)[0,0]\\n self.model.stateVector = newState\\n\\n if i == 0:\\n \\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\\n \\n print('cost Function for iteration {}:'.format(i), self.costFunction)\\n\\n i += 1\\n \\n F, K = self.model()\\n if self.model.verbose > 0:\\n self.model.plot(i+1, stateVectorConv)\\n \\n try:\\n self.DecomposeJacobian(K)\\n except np.linalg.LinAlgError:\\n raise OptimalEstimationException(\\\"Failure in decomposition.\\\")\\n \\n Wplus2 = np.matrix(np.diag(1.0/(self.w**2+1.0)))\\n self.model.covariance = (self.priorSh * self.V * Wplus2 * \\n self.V.T * self.priorSh)\\n \\n\\n \\n return i, stateVectorConv\",\n \"def stabilizer_vector(v, g, n):\\n vg = v.copy()\\n w = v.copy()\\n for i in range(1, n):\\n vg *= g \\n w += vg\\n assert v == vg * g\\n if (w['B'] == 0).all():\\n return None\\n return w\",\n \"def dp_alex(v_space, num_frames_r, num_frames_q, bov_flag, prev_ref=5,\\n next_ref=0):\\n t1 = float(cv2.getTickCount())\\n\\n common.DebugPrint(\\\"Entered dp_alex(): Running dynamic programming...\\\")\\n\\n r, c, d = v_space.shape\\n\\n # We substitute all NaN's of v_space\\n for i in range(d):\\n v_temp = v_space[:, :, i]\\n v_temp[np.isnan(v_temp)] = 0\\n v_space[:, :, i] = v_temp\\n\\n vv = np.zeros((r, c))\\n for j in range(d):\\n vv += v_space[:, :, j]\\n\\n # Checking that vv has positive elements\\n assert np.nonzero(vv < 0.0)[0].size == 0\\n\\n print_matrices = True\\n\\n if common.MY_DEBUG_STDOUT and print_matrices:\\n print(\\\"dp_alex(): r = %d, c = %d\\\" % (r, c))\\n print(\\\"dp_alex(): vv = \\\\n%s\\\" % str(vv))\\n sys.stdout.flush()\\n\\n D = np.zeros((r, c))\\n tback = np.zeros((r, c))\\n\\n for ref in range(r):\\n D[ref, 0] = vv[ref, 0]\\n tback[ref, 0] = -1\\n\\n for qry in range(1, c):\\n for ref in range(r):\\n # We enumerate a few reference frames to find the one with\\n # highest votes\\n lb = ref - prev_ref\\n ub = ref + next_ref\\n\\n if lb < 0:\\n lb = 0\\n if lb >= r:\\n lb = r - 1\\n\\n if ub < 0:\\n ub = 1\\n if ub >= r:\\n ub = r - 1\\n\\n max_pos = lb\\n for i in range(lb + 1, ub + 1):\\n \\\"\\\"\\\"\\n We use <= --> we break ties by going forward in the\\n reference video (incrementing the reference frame for\\n the next query frame).\\n \\\"\\\"\\\"\\n if D[max_pos, qry - 1] <= D[i, qry - 1]:\\n max_pos = i\\n # max_pos is the maximum vote reference frame for query frame qry\\n\\n D[ref, qry] += D[max_pos, qry - 1] + vv[ref, qry]\\n tback[ref, qry] = max_pos\\n\\n if common.MY_DEBUG_STDOUT and print_matrices:\\n print(\\\"D = \\\\n%s\\\" % str(D))\\n print(\\\"tback = \\\\n%s\\\" % str(tback))\\n\\n crossref = np.zeros((num_frames_q, 2))\\n\\n # Find max-cost path (the critical path) for the last query frame:\\n max_pos = 0\\n for ref in range(1, r):\\n \\\"\\\"\\\"\\n We use <= --> we break ties by going forward in the\\n reference video (incrementing the reference frame for\\n the next query frame) - debatable if this is a good idea!!!!TODO.\\n \\\"\\\"\\\"\\n if D[max_pos, c - 1] <= D[ref, c - 1]:\\n max_pos = ref\\n print(\\\"max_pos = %d\\\" % max_pos)\\n\\n print(\\\"dp_alex(): cost critical path = %s\\\" % str(D[max_pos, c - 1]))\\n\\n pos_ref = max_pos\\n for qry in range(c - 1, 0-1, -1):\\n crossref[qry][0] = qry\\n crossref[qry][1] = pos_ref\\n\\n common.DebugPrint(\\\"qry=%d, pos_ref=%d\\\" % (qry, pos_ref))\\n pos_ref = tback[pos_ref, qry]\\n\\n # time took\\n common.DebugPrint(\\\"dp_alex(): crossref = %s\\\" % str(crossref))\\n compute_cost(crossref, vv, \\\"crossref_dp_Alex.txt\\\")\\n # TODO: assert cost computed is = D[max_pos,...]\\n\\n t2 = float(cv2.getTickCount())\\n my_time = (t2 - t1) / cv2.getTickFrequency()\\n print(\\\"dp_alex() took %.6f [sec]\\\" % my_time)\\n\\n y = None\\n x = None\\n return y, x, D, tback, crossref\",\n \"def _redef_sp1_vars(self):\\r\\n\\r\\n if len(self.fq_list) == 0:\\r\\n no_rad = True\\r\\n lst_tmp = np.matrix(np.reshape(self.lst_tmp, \\r\\n (self.lst_tmp.size, 1)))\\r\\n else: no_rad = False\\r\\n # The practically constants...\\r\\n # Big Epsilon:\\r\\n if self.cond == True:\\r\\n self.Epsilon = self.d_T * self.thermal_conductivity\\r\\n else:\\r\\n self.Epsilon = (self.diff_scale ** 2) / \\\\\\r\\n (3.0 * self.absorb_coeffs[self.rad] ** 2)\\r\\n # Beta:\\r\\n if self.cond == True:\\r\\n self.Beta = (self.diff_scale * self.thermal_conductivity) / \\\\\\r\\n (self.convect_coeff)\\r\\n else:\\r\\n self.Beta = (1.0 + 3.0 * self.r2) * (2.0 * self.diff_scale) / \\\\\\r\\n ((1.0 - 2.0 * self.r1) * (\\r\\n 3.0 * self.absorb_coeffs[self.rad]))\\r\\n\\r\\n # The feild solutions at the last timestep.\\r\\n # The integral vF:\\r\\n if self.cond == True:\\r\\n # The horrifically complicated F:\\r\\n def F_func_cond(elem, eta):\\r\\n F = 0.0\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n F += Tn\\r\\n for k in range(0, len(self.fq_list)):\\r\\n vk = self.fq_list[k]\\r\\n try:\\r\\n vk_m = self.fq_list[k - 1]\\r\\n except:\\r\\n vk_m = self.v0_frequency\\r\\n absorbtion = self.absorb_coeffs[k]\\r\\n phi = elem.eval_elem(self.node_map, self.lst_rad[k],\\r\\n [eta])[0]\\r\\n inter1 = phi - 4.0 * sconst.pi * \\\\\\r\\n self.B_int_function(Tn, self.refr_idx_vol,\\r\\n vk, vk_m)\\r\\n inter2 = absorbtion * self.d_T / (self.diff_scale ** 2)\\r\\n F += inter2 * inter1\\r\\n return elem.funcs(eta) * F\\r\\n if not no_rad:\\r\\n # We're integrating something non-linear for SP1\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n # Or something easier if we're only looking at heat.\\r\\n self.vF_vect_vol = np.array(self.uv_vol * lst_tmp).reshape(-1)\\r\\n else:\\r\\n def F_func_radiative(elem, eta):\\r\\n T = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n F = 4.0 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * F\\r\\n\\r\\n self.vF_vect_vol = et.elems_2_array(self.mesh,\\r\\n F_func_radiative,\\r\\n self.node_map)\\r\\n # The path integral vf:\\r\\n if self.cond == True:\\r\\n def f_func_cond(elem, eta):\\r\\n Tb = self.background_temperature\\r\\n Tn = elem.eval_elem(self.node_map, self.lst_tmp, [eta])[0]\\r\\n n = self.refr_idx_background\\r\\n vk = self.v0_frequency\\r\\n vk_minus = 0\\r\\n Bb0 = self.B_int_function(Tb, n, vk, vk_minus)\\r\\n Bn0 = self.B_int_function(Tn, n, vk, vk_minus)\\r\\n B_coeff = (self.alpha * sconst.pi) / self.convect_coeff\\r\\n f = Tb + B_coeff * (Bb0 - Bn0)\\r\\n return elem.funcs(eta) * f\\r\\n if not no_rad:\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_cond,\\r\\n self.node_map)\\r\\n else:\\r\\n try:\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n except AttributeError:\\r\\n def elem_functor(elem, eta): return elem.funcs(eta)\\r\\n self.cache_tb_integral_array = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n elem_functor,\\r\\n self.node_map)\\r\\n self.cache_tb_integral_array *= self.background_temperature\\r\\n self.vf_vect_bound = self.cache_tb_integral_array\\r\\n \\r\\n else:\\r\\n # Radiation f = 4*pi*B^{(k)}(T_b, n_g)\\r\\n def f_func_radiative(elem, eta):\\r\\n T = self.background_temperature\\r\\n vk = self.fq_list[self.rad]\\r\\n try:\\r\\n vk_minus = self.fq_list[self.rad - 1]\\r\\n except:\\r\\n vk_minus = self.v0_frequency\\r\\n n = self.refr_idx_vol\\r\\n f = 4 * sconst.pi * self.B_int_function(T, n, vk, vk_minus)\\r\\n return elem.funcs(eta) * f\\r\\n\\r\\n self.vf_vect_bound = et.edge_2_array(self.mesh,\\r\\n \\\"Boundary\\\",\\r\\n f_func_radiative,\\r\\n self.node_map)\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vf_vect_bound.shape[0] == \\\\\\r\\n self.vF_vect_vol.shape[0])\",\n \"def v(resistances, r_i, applied_voltages, **kwargs):\\n if r_i.word_line > 0 or r_i.bit_line > 0:\\n g = fill.g(resistances, r_i)\\n i = fill.i(applied_voltages, resistances, r_i)\\n\\n utils.message('Started solving for v.', **kwargs)\\n v_matrix = linalg.spsolve(g.tocsc(), i)\\n utils.message('Solved for v.', **kwargs)\\n\\n # if `num_examples == 1`, it can result in 1D array.\\n if v_matrix.ndim == 1:\\n v_matrix = v_matrix.reshape(v_matrix.shape[0], 1)\\n\\n # if one of the interconnect resistances is zero, only half of the\\n # matrix_v had to be solved. The other half can be filled without\\n # solving because the node voltages are known.\\n if r_i.word_line == 0:\\n new_v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n new_v_matrix[:resistances.size, ] = np.repeat(\\n applied_voltages, resistances.shape[1], axis=0)\\n new_v_matrix[resistances.size:, ] = v_matrix\\n v_matrix = new_v_matrix\\n if r_i.bit_line == 0:\\n new_v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n new_v_matrix[:resistances.size, ] = v_matrix\\n v_matrix = new_v_matrix\\n else:\\n # if both interconnect resistances are zero, all node voltages are\\n # known.\\n v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n v_matrix[:resistances.size, ] = np.repeat(\\n applied_voltages, resistances.shape[1], axis=0)\\n\\n return v_matrix\",\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 f_v(self, v):\\n\\n return self.f(v[:, 0], v[:, 1], v[:, 2])\",\n \"def v(self, i):\\n\\n\\t # Check whether the node is already active\\n\\t if self.active_nodes[i] == True:\\n\\t return 0\\n\\n\\t self.active_nodes[i] = True\\n\\t contrib = 0\\n\\n\\t for j in self.adj_list[i]:\\n\\t if self.thresh_f(j) >= self.theta[j] and self.active_nodes[j] == False:\\n\\t self.active_nodes[j] = True\\n\\t contrib += 1 + self.v(j)\\n\\n\\t return contrib\",\n \"def exhaust(self):\\n svr = self.svr\\n for it, fluid in enumerate(svr.fluids):\\n assert np.allclose(svr.soln[svr.blk.shclgrp==it,0], fluid.rho)\\n vel = svr.velocities[it]\\n for idim in range(svr.ndim):\\n val = fluid.rho * vel[idim]\\n assert np.allclose(svr.soln[svr.blk.shclgrp==it,idim+1], val)\",\n \"def on_iteration_start(self):\\n\\n self.Xfprv = self.Xf.copy()\\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\\n BacktrackRobust)):\\n self.Yfprv = self.Yf.copy()\\n\\n if self.opt['Monotone']:\\n if self.k == 0:\\n self.objfn = self.eval_objfn()\\n self.objfn_prev = self.objfn\",\n \"def _update_local_solution(self, x: np.ndarray, z: np.ndarray, z_neigh: dict, rho: float, **kwargs):\\r\\n self.z_neigh = z_neigh\\r\\n\\r\\n # update dual variables\\r\\n self.lambd[self.agent.id] += rho * (x - z)\\r\\n for j, z_j in z_neigh.items():\\r\\n self.lambd[j] += rho * (x - z_j)\\r\\n\\r\\n # update primal variables\\r\\n self.x = x\\r\\n self.z = z\",\n \"def vectorized_result(j):\\r\\n e = zeros((10))\\r\\n e[j] = 1.0\\r\\n return e\",\n \"def potentialSolver(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 # solve potential\\n for it in np.arange(1,max_it+1):\\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 #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 #check for convergence*/\\n if it%25==0:\\n sum = 0;\\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 R = -self.phi[i][j][k]*(2*dx2+2*dy2+2*dz2) +\\\\\\n 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])\\n\\n sum += R*R;\\n\\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 value_iteration(self):\\n #Create a utility function of the environment shape\\n gamma = 0.9\\n epsilon = 0.01\\n iteration = 0\\n\\n #create a utility function that matches the size of the number of states\\n u = np.zeros(self.env.observation_space.n, dtype=float)\\n\\n u_copy = u.copy()\\n\\n #Create the reward grid\\n reward = np.array([state_map.get(sublist) for state in frozen_lake.MAPS[self.env.spec._kwargs.get('map_name')] for sublist in state])\\n\\n T = self.frozen_transition()\\n\\n graph_list = list()\\n\\n #keep track of the convergence\\n policy_convergence = list()\\n\\n while True:\\n delta = 0\\n iteration += 1\\n u = u_copy.copy()\\n graph_list.append(u)\\n start_time = time()\\n for s in range(self.env.observation_space.n):\\n r = reward[s]\\n v = np.zeros((1, self.env.observation_space.n), dtype=float)\\n v[0, s] = 1.0\\n u_copy[s] = self.return_state_utility(v, T, u, r, gamma)\\n delta = max(delta, np.abs(u_copy[s] - u[s]))\\n policy_convergence.append({'iter': iteration, 'delta': delta})\\n if delta < epsilon * (1 - gamma) / gamma:\\n print(\\\"Total Iterations: {}\\\".format(iteration))\\n print(\\\"=================== VALUE ITERATION RESULT ==================\\\")\\n print(\\\"Iterations: \\\" + str(iteration))\\n print(\\\"Delta: \\\" + str(delta))\\n print(\\\"Gamma: \\\" + str(gamma))\\n print(\\\"Epsilon: \\\" + str(epsilon))\\n print(\\\"Time to converge: {} seconds\\\".format(time() - start_time))\\n print(\\\"===================================================\\\")\\n utility_reshape = np.reshape(u, (int(np.sqrt(self.env.observation_space.n)), int(np.sqrt(self.env.observation_space.n))))\\n print (np.array(utility_reshape, dtype=float))\\n print(\\\"===================================================\\\")\\n break\\n\\n return u\",\n \"def f(t, x, n, v):\\n total = 0\\n for i in range(n+1):\\n for j in range(n+1):\\n for k in range(v):\\n total = t[i][j] * x[i][j][k]\",\n \"def relax(self):\\n # print(\\\"putin\\\", self.level.rhs.reshape(-1)[:])\\n # print(\\\"getout\\\", self.solver(self.level.rhs.reshape(-1)))\\n\\n self.level.mid[:] = self.solver(self.level.rhs.reshape(-1)).reshape(self.level.mid.shape)\",\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 atualizaVertice(self, v = []):\\r\\n\\r\\n #reseta as arestas para d0\\r\\n #for a in self.arestas:\\r\\n # a.peso = a.d0\\r\\n\\r\\n for vertice in v:\\r\\n for a in self.arestas:\\r\\n if (vertice.id == a.v1.id):\\r\\n #print (\\\"atualiza aresta\\\", a.id)\\r\\n if (a.v2.atualizado):\\r\\n a.peso = a.d2\\r\\n else:\\r\\n a.peso = a.d1\\r\\n\\r\\n\\r\\n if (vertice.id == a.v2.id):\\r\\n #print (\\\"atualiza aresta\\\", a.id)\\r\\n if (a.v1.atualizado):\\r\\n a.peso = a.d2\\r\\n else:\\r\\n a.peso = a.d1\\r\\n \\r\\n vertice.atualizado = True\\r\\n \\r\\n for vertice in v:\\r\\n vertice.atualizado = False\",\n \"def vectorized_result(j):\\n j=int(j)\\n e = np.zeros((10, 1))\\n e[j] = 1.0\\n return e\",\n \"def value_iteration(iterations):\\n for _ in range(0, iterations):\\n for i in range(0, 3):\\n for j in range(0, 4):\\n # We don't need values for start/end/non-reachable states\\n if [i, j] == [1, 1] or [i, j] == [0, 3] or [i, j] == [1, 3]:\\n None\\n else:\\n value([i, j])\\n\\n print(utilities)\",\n \"def vcycle(v, b):\\n if (len(v) - 1) & (len(v) - 2) != 0:\\n raise ValueError(\\\"Lenth of v must be 2**n + 1.\\\")\\n\\n for i in range(3):\\n jacobi23(v, b)\\n\\n if len(v) <= 3:\\n return\\n\\n r = b - Amul(v)\\n r2 = 4. * restrict(r)\\n e2 = np.zeros_like(r2)\\n vcycle(e2, r2)\\n v += prolong(e2)\\n\\n for i in range(3):\\n jacobi23(v, b)\",\n \"def test_grad_vector(func, motion, optimized, preserve_result, x):\\n utils.test_reverse_array(func, motion, optimized, preserve_result, x)\",\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 \"def DFSU(graph, v, a):\\n a[v]= True # mark the current node as visited\\n\\n for i in graph[v]: # recursively check for all vertices adjacent.\\n if a[i]==False:\\n self.DFS(i,a)\",\n \"def run(self, x):\\n T = len(x)\\n self.x = x\\n self.s = np.zeros((T, self.hidden_size))\\n for t in xrange(T):\\n self.s[t] = np.dot(self.nodes.u, x[t])\\n if self.en_bias: self.s[t] += self.nodes.b\\n self.s[t] = self.acfun.compute(np.clip(self.s[t], -50, 50))\\n return self.s\",\n \"def on_iteration_start(self):\\n\\n self.Xprv = self.X.copy()\\n if (not self.opt['FastSolve'] or isinstance(self.backtrack,\\n BacktrackRobust)):\\n self.Yprv = self.Y.copy()\\n\\n if self.opt['Monotone']:\\n if self.k == 0:\\n self.objfn = self.eval_objfn()\\n self.objfn_prev = self.objfn\",\n \"def apply(self, v):\\n u = np.zeros(self.Dimension, dtype=complex)\\n for me in self.Elements:\\n for index in range(v.Elements.size):\\n if index == me.j:\\n u[me.i] += me.val * v.Elements[index]\\n u = Vector(u) \\n return u\",\n \"def apply_optimization_vector(self, vector: np.ndarray) -> None:\\n # we are going to iterate through the given vector;\\n # an iterator allows us to next()\\n # (aka `pop`) the values only when desired;\\n # we only update the current vector where the mask is True\\n vector_iterator = iter(vector)\\n updated_vector = [v if not m else next(vector_iterator)\\n for v, m in zip(self.vector,\\n self.optimization_mask)]\\n updated_links = self.array_2_links(np.array(updated_vector),\\n self.convention)\\n self.links = updated_links\",\n \"def adj_to(self, v):\\n\\n neighbours = set()\\n\\n for (x, y) in self._edges:\\n if x == v: neighbours.add(y)\\n if y == v: neighbours.add(x)\\n\\n return neighbours\",\n \"def firstNeighbor(v):\\n for u in ranks:\\n if u in matched or not self.adjacent(u, v):\\n continue\\n\\n return u\",\n \"def remove_route(self, A, v):\\n A[:,v] = self.INFINITY\",\n \"def run(self):\\n self.errList = []\\n self.initialize()\\n\\n for i in range(self.maxiter):\\n # update U\\n for k in range(self.K):\\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\\n full_matrices=False)\\n self.U[k] = q.T.dot(p.T)\\n self.U[k] = self.U[k].real\\n\\n # calculate temporal variable y\\n y = np.zeros([self.rank, self.L, self.K])\\n for k in range(self.K):\\n y[:, :, k] = self.U[k].T.dot(self.X[k])\\n\\n # get H, V, and temps by running a single iteration of CP_ALS\\n if i == 0:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1, printitn=0)\\n else:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1,\\n init=[self.H, self.V, temps], printitn=0)\\n self.H = cp.Us[0]\\n self.V = cp.Us[1]\\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\\n\\n # update S\\n for k in range(self.K):\\n self.S[:, :, k] = np.diag(temps[k, :])\\n\\n # checking the stop criteria\\n # error = 0\\n for k in range(self.K):\\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\\n\\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\\n self.errList.append(error)\\n if (i + 1) % self.printitn == 0:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n elif error < self.tol:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n\\n if error < self.tol:\\n break\\n else:\\n self.sigma_old = self.sigma_new\\n self.sigma_new = 0\\n\\n for k in range(self.K):\\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\",\n \"def edge_velocity(self):\\n #reflext x values at x edges\\n self.u[1,:,0] = -self.u[1,:,1]\\n self.u[1,:,-1] = -self.u[1,:,-2]\\n #mirror x values at y edges \\n self.u[1,0,:] = self.u[1,1,:]\\n self.u[1,-1,:] = self.u[1,-2,:]\\n #mirror y values at x edges\\n self.u[0,:,0] = self.u[0,:,1]\\n self.u[0,:,-1] = self.u[0,:,-2]\\n #mirror y values at y edges \\n self.u[0,0,:] = -self.u[0,1,:]\\n self.u[0,-1,:] = -self.u[0,-2,:]\",\n \"def update_floyd_warshall_and_all_vectors(self):\\n self.graph.compute_floyd_warshal()\\n # Update where agents are\\n self.update_agent_location_vector()\\n # update deadlines\\n self.populate_deadline_vector()\\n # update distances to each task and orientation to each task\\n self.update_agent_distances_vector()\\n self.update_agent_orientation_vector()\\n\\n self.update_alive_enabled_travel()\\n\\n return self.graph.is_feasible()\",\n \"def anneal(solution):\\n old_cost = cost(solution)\\n T = 1.0\\n T_min = 0.00001\\n ALPHA = 0.9\\n\\n while T > T_min:\\n i = 1\\n while i <= 100:\\n new_solution = neighbor(solution)\\n new_cost = cost(new_solution)\\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\\n return solution, old_cost\",\n \"def gilpin_ne(A, epsilon=1e-4, max_iter=np.inf):\\n A = A.T # make compatible with nesterov_ne\\n m, n = A.shape\\n R = np.vstack((np.hstack((np.zeros((m, m)), -A)),\\n np.hstack((A.T, np.zeros((n, n))))))\\n norm_R = linalg.norm(R, 2)\\n u_ = (1. / m) * np.ones(m)\\n v_ = (1. / n) * np.ones(n)\\n x = u_.copy()\\n y = v_.copy()\\n D = 1. - .5 * (1. / m + 1. / n)\\n gamma = np.e\\n eps = 1.\\n gradx_acc = np.zeros(m)\\n grady_acc = np.zeros(n)\\n values = []\\n gaps = []\\n k = 0.\\n while k < max_iter and eps >= epsilon:\\n mu = eps / (2. * D)\\n\\n # misc\\n L = norm_R ** 2 / mu\\n stepsize = 1. / L\\n\\n gradx_acc *= 0.\\n gradx_acc *= 0.\\n while True:\\n # make call to oracle\\n aux1 = A.dot(y)\\n aux = -aux1 / mu\\n aux += u_\\n u = proj_simplex(aux)\\n aux2 = A.T.dot(x)\\n aux = aux2 / mu\\n aux += v_\\n v = proj_simplex(aux)\\n gradx, grady = A.dot(v), -A.T.dot(u)\\n gradx_acc += .5 * (k + 1.) * gradx\\n grady_acc += .5 * (k + 1.) * grady\\n\\n value = x.dot(aux1)\\n values.append(value)\\n gap = aux2.max() - aux1.min()\\n gaps.append(gap)\\n assert gap + 1e-10 >= 0., \\\"The world is a weird place!\\\"\\n print (\\\"%03i: game value <Ax, u> = %g, primal-dual \\\"\\n \\\"gap=%g\\\") % (k + 1, value, gap)\\n\\n # check convergence\\n if gap < eps:\\n print \\\"Converged (primal-dual gap < %g).\\\" % eps\\n break\\n\\n # y update\\n yx = proj_simplex(x - stepsize * gradx)\\n yy = proj_simplex(y - stepsize * grady)\\n\\n # z update\\n zx = proj_simplex(u_ - stepsize * gradx_acc)\\n zy = proj_simplex(v_ - stepsize * grady_acc)\\n\\n # x update\\n factor = 2. / (k + 3.)\\n x = factor * zx\\n x += (1. - factor) * yx\\n y = factor * zy\\n y += (1. - factor) * yy\\n\\n k += 1\\n if k >= max_iter: break\\n\\n # decrease eps\\n eps /= gamma\\n print \\\"Decreasing epsilon to %g\\\" % eps\\n\\n return x, y, values, gaps\",\n \"def __init__(self, x0, initial_scale, update_type=None,\\n skip_treshold=None):\\n\\n if not update_type:\\n update_type = BroydenSolver.UPDATE_BAD_BROYDEN\\n\\n self.original_shape = _n.shape(x0)\\n \\\"\\\"\\\"Original shape of the iterating vector\\\"\\\"\\\"\\n self.n = _n.product(self.original_shape)\\n \\\"\\\"\\\"Number of elements in the iterating vector\\\"\\\"\\\"\\n\\n self.initial_scale = initial_scale\\n \\\"\\\"\\\"Initial scaling of the problem Jacobian\\\"\\\"\\\"\\n self.update_type = update_type\\n \\\"\\\"\\\"The update type\\\"\\\"\\\"\\n\\n self.x = _n.reshape(_n.array(x0, copy=True), (self.n, 1))\\n \\\"\\\"\\\"Current point (latest)\\\"\\\"\\\"\\n self.next_x = self.x\\n \\\"\\\"\\\"Next point\\\"\\\"\\\"\\n\\n self.H = _n.identity(self.n) / self.initial_scale\\n \\\"\\\"\\\"Approximation to the inverse of the Jacobian (latest)\\\"\\\"\\\"\\n self.F = _n.zeros((self.n, 1))\\n \\\"\\\"\\\"The target function (latest)\\\"\\\"\\\"\\n\\n self.iteration = 0\\n \\\"\\\"\\\"Current iteration\\\"\\\"\\\"\\n self.first_step = True\\n \\\"\\\"\\\"Is the next step the first step?\\\"\\\"\\\"\\n\\n if skip_treshold is None:\\n skip_treshold = 2.0\\n self.skip_treshold = skip_treshold\\n \\\"\\\"\\\"Skip steps that change the residual by less than this factor.\\\"\\\"\\\"\\n\\n self.max_step = 1.0\\n \\\"\\\"\\\"Maximum relative step size\\\"\\\"\\\"\\n\\n self.last_reset = False\",\n \"def jacobian(self, v):\\n from scipy.special import erf, erfcx\\n def integrand(u_arr):\\n \\\"\\\"\\\"Integrand of self-consistency equation\\\"\\\"\\\"\\n integrand_all = erfcx(-u_arr)\\n #integrand_all = np.zeros(u_arr.shape)\\n #u_mask = u_arr < -4.0\\n #u = u_arr[u_mask]\\n #integrand_all[u_mask] = -1. / np.sqrt(np.pi) * (1.0 / u - 1.0 / (2.0 * u**3) + \\n #3.0 / (4.0 * u**5) - \\n #15.0 / (8.0 * u**7))\\n #integrand_all[~u_mask] = np.exp(u_arr[~u_mask]**2) * (1. + erf(u_arr[~u_mask]))\\n return integrand_all\\n\\n\\n mu_v = self.mu(v)\\n sd_v = self.sd(v)\\n low = (self.V_r - mu_v) / sd_v # reduced resting potential\\n up = (self.theta - mu_v) / sd_v # reduced threshold\\n f_low = integrand(low)\\n f_up = integrand(up)\\n jac_mat_1 = self.tau_m * 1e-3 * np.sqrt(np.pi) * self.mat_mu\\n jac_mat_2 = self.tau_m * 1e-3 * np.sqrt(np.pi) * self.mat_var / (2. * sd_v**2)\\n\\n jac_T = np.diag(1. / v**2) - \\\\\\n jac_mat_1.T * (f_up - f_low) + \\\\\\n jac_mat_2.T * (f_up * up - f_low * low)\\n return jac_T.T\",\n \"def optimize_self(self):\\n self.compute_predicate_values();\\n \\\"\\\"\\\" Firstly,adjust the f(x) into > alpha_0; \\\"\\\"\\\"\\n for i in range(len(self.RING_PARA_PAIR_CD)):\\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CD[i]);\\n self.RING_PARA_PAIR_CD[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CD[i][0].WORD_ID]; # 更新内部VECTOR;\\n self.RING_PARA_PAIR_CD[i][2] = self.RING_PARA_PAIR_CD[i][0].polynomial_func(self.RING_PARA_PAIR_CD[i][1]); # 更新内部ALPHA;\\n for i in range(len(self.RING_PARA_PAIR_CC)):\\n # ************** BUG 0627 **********************\\n # if self.RING_PARA_PAIR_CC[i][2]<41 and self.RING_PARA_PAIR_CC[i][2]>40: # ---------------------------------------------------------------->>>>>\\n # print( RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID] ); # ---------------------------------------------------------------->>>>>\\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CC[i]); \\n # ************** BUG 0627 **********************\\n # if self.RING_PARA_PAIR_CC[i][2]<41 and self.RING_PARA_PAIR_CC[i][2]>40: # ---------------------------------------------------------------->>>>> \\n # print(self.RING_PARA_PAIR_CC[i][0].VECTOR); # ---------------------------------------------------------------->>>>>\\n # print(RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID]); # ---------------------------------------------------------------->>>>>\\n # print(self.RING_PARA_PAIR_CC[i][0].polynomial_func(self.RING_PARA_PAIR_CC[i][1])); # ---------------------------------------------------------------->>>>>\\n # print( np.cumprod( self.RING_PARA_PAIR_CC[i][1] - self.RING_PARA_PAIR_CC[i][0].VECTOR )[-1] ); # ---------------------------------------------------------------->>>>>\\n self.RING_PARA_PAIR_CC[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CC[i][0].WORD_ID]; # 更新内部VECTOR;\\n self.RING_PARA_PAIR_CC[i][2] = self.RING_PARA_PAIR_CC[i][0].polynomial_func(self.RING_PARA_PAIR_CC[i][1]); # 更新内部ALPHA;\\n \\\"\\\"\\\" Secondly,adjust the alpha_0 < p_min(y_n) < q_min(x_n)\\\"\\\"\\\" \\n P_MIN = 99999999.0; Q_MIN = 99999999.0;P_MAX = 0.0;Q_MAX = 0.0;\\n CD_ID = 0;CD_MIN=0;\\n # 找到结论中谓词的最小多项式值\\n for RING_PARA_PAIR in self.RING_PARA_PAIR_CC:\\n if Q_MIN>RING_PARA_PAIR[2]: Q_MIN=RING_PARA_PAIR[2];\\n # if Q_MAX<RING_PARA_PAIR[2]: Q_MAX=RING_PARA_PAIR[2];\\n # 不满足小于结论最小值的那些环的TARGET_ALPHA更新; \\n for RING_PARA_PAIR in self.RING_PARA_PAIR_CD:\\n if P_MIN>RING_PARA_PAIR[2]: P_MIN=RING_PARA_PAIR[2];CD_MIN=CD_ID;# self.RING_PARA_PAIR_CD[CD_ID][3]=-Q_MIN;\\n # if P_MAX<RING_PARA_PAIR[2]: P_MAX=RING_PARA_PAIR[2];self.RING_PARA_PAIR_CD[CD_ID][3]=-Q_MAX;\\n CD_ID+=1;\\n self.RING_PARA_PAIR_CD[CD_MIN][3]=-Q_MIN; \\n # 优化不满足小于结论最小值的那些环 \\n for i in range(len(self.RING_PARA_PAIR_CD)): \\n if self.RING_PARA_PAIR_CD[i][3]!=ALPHA:\\n if P_MIN>Q_MIN:\\n self.adjust_to_excepted_value(self.RING_PARA_PAIR_CD[i]); \\n self.RING_PARA_PAIR_CD[i][0].VECTOR = RUNNING_DATA[self.RING_PARA_PAIR_CD[i][0].WORD_ID]; # 更新内部VECTOR;\\n self.RING_PARA_PAIR_CD[i][2] = self.RING_PARA_PAIR_CD[i][0].polynomial_func(self.RING_PARA_PAIR_CD[i][1]); # 更新内部ALPHA;\",\n \"def _perform_single_iteration(self):\\n self.iteration += 1\\n p1 = [self.a * z + self.b * z.conjugate()\\n for z in self.points]\\n p2 = [self.c * (z - 1) + self.d * (z.conjugate() - 1) + 1\\n for z in self.points]\\n self.points = p1 + p2\",\n \"def solve(self):\\n\\n # Set up display header if verbose operation enabled\\n if self.opt['Verbose']:\\n hdr = 'Itn DFidX PriResX DuaResX DFidG' + \\\\\\n ' ResG '\\n print(hdr)\\n print('-' * len(hdr))\\n\\n # Main iteration loop\\n for n in range(self.opt['MaxMainIter']):\\n\\n # At start of 2nd iteration, set the numbers of inner\\n # iterations for the X and G solvers from the options\\n # object for the outer solver\\n if n == 1:\\n self.slvX.opt['MaxMainIter'] = self.opt['XslvIter']\\n self.slvG.opt['MaxMainIter'] = self.opt['GslvIter']\\n\\n # Run the configured number of iterations of the X (CSC)\\n # solver and assign the result to X\\n self.X = self.slvX.solve()\\n\\n # Compute the sum of the subpixel shifts of X\\n Xhs = np.sum(fftconv(self.H, self.X.squeeze(), axes=(0, 1)),\\n axis=-1)\\n\\n # Set the convolution kernel in the deconvolution solver\\n # to the sum of the subpixel shifts of X\\n self.slvG.setG(Xhs)\\n # Run the configured number of iterations of the G\\n # (deconvolution) solver and crop the result to obtain the\\n # updated g\\n self.g = self.slvG.solve()[0:self.gshp[0], 0:self.gshp[1]]\\n\\n # Construct a new dictionary for the X (CSC) solver from\\n # the updated psf g\\n self.D, self.dn = self.getD(self.g)\\n self.slvX.setdict(self.D[..., np.newaxis, np.newaxis, :])\\n\\n # Display iteration statistics if verbose operation enabled\\n if self.opt['Verbose']:\\n itsX = self.slvX.getitstat()\\n itsG = self.slvG.getitstat()\\n fmt = '%3d %.3e %.3e %.3e %.3e %.3e'\\n tpl = (n, itsX.DFid[-1], itsX.PrimalRsdl[-1],\\n itsX.DualRsdl[-1], itsG.DFid[-1], itsG.Rsdl[-1])\\n print(fmt % tpl)\\n\\n # Return the (normalised) psf estimate g\\n return self.g / np.linalg.norm(self.g)\",\n \"def run(self, x):\\n T = len(x)\\n self.x = x\\n self.i = np.zeros((T, self.hidden_size))\\n self.f = np.zeros((T, self.hidden_size))\\n self.o = np.zeros((T, self.hidden_size))\\n self.g = np.zeros((T, self.hidden_size))\\n self.h = np.zeros((T, self.hidden_size))\\n self.c = np.zeros((T+1, self.hidden_size))\\n self.s = np.zeros((T+1, self.hidden_size))\\n for t in xrange(T):\\n # input gate\\n self.i[t] = self.gatefun.compute(np.dot(self.igate.u, x[t])\\n + np.dot(self.igate.w, self.s[t-1])\\n + np.dot(self.igate.v, self.c[t-1]) + self.igate.b)\\n # forget gate\\n self.f[t] = self.gatefun.compute(np.dot(self.fgate.u, x[t])\\n + np.dot(self.fgate.w, self.s[t-1])\\n + np.dot(self.fgate.v, self.c[t-1]) + self.fgate.b)\\n # current hidden node state\\n self.g[t] = self.acfun.compute(np.dot(self.nodes.u, x[t]) + \\n np.dot(self.nodes.w, self.s[t-1]) + self.nodes.b)\\n # internal memoery\\n self.c[t] = self.f[t] * self.c[t-1] + self.i[t] * self.g[t]\\n # output gate\\n self.o[t] = self.gatefun.compute(np.dot(self.ogate.u, x[t])\\n + np.dot(self.ogate.w, self.s[t-1])\\n + np.dot(self.ogate.v, self.c[t]) + self.ogate.b)\\n self.h[t] = self.acfun.compute(self.c[t])\\n self.s[t] = np.clip(self.o[t] * self.h[t], -50, 50)\\n return self.s[:-1]\",\n \"def solve(self):\\n for x in range(9):\\n for y in range(9):\\n if self.arr[x][y] == 0:\\n for value in range(1,10):\\n if self.is_possible_value(x,y,value):\\n self.arr[x][y] = value\\n self.solve()\\n self.arr[x][y] = 0 \\n return\\n print(np.matrix(self.arr))\",\n \"def obtain_ones_in_the_main_diagonal(self):\\r\\n for row in range(self.SIZE):\\r\\n self.check_solvability(self.matrix[row][row], self.matrix[row][-1])\\r\\n self.matrix[row][-1] = self.divide(self.matrix[row][-1], self.matrix[row][row])\\r\\n self.matrix[row][row] = self.divide(self.matrix[row][row], self.matrix[row][row])\",\n \"def assignMoreVectors(self, i):\\n return\",\n \"def solve(self):\\r\\n while not self.done():\\r\\n self.no_open_cells()\\r\\n self.all_cells_are_mines()\\r\\n self.no_mines()\\r\\n if not self.done():\\r\\n self.obvious_cells()\\r\\n if not self.done():\\r\\n made_progress = self.safe_neighbour_difference()\\r\\n if made_progress:\\r\\n continue\\r\\n if not self.done():\\r\\n made_progress = self.adjacent_combinations()\\r\\n if made_progress:\\r\\n continue\\r\\n return\",\n \"def advect (u, v):\\r\\n # NOTICE: memory usage might be too high, could optimize\\r\\n\\r\\n # Store the values from timestep n\\r\\n un = u\\r\\n vn = v\\r\\n\\r\\n for i in range (height):\\r\\n for j in range (width):\\r\\n oldpos = coord (i,j) - dt * np.stack((u[i,j], v[i,j]))\\r\\n u[i,j], v[i,j] = interpolate (un, vn, oldpos)\\r\\n\\r\\n\\r\\n # Return values for timestep n+1\\r\\n return u, v\",\n \"def prepare(self):\\n ls=len(self.v)\\n self.S=numpy.zeros(ls)\\n self.A=numpy.zeros((ls,ls))\\n\\n for k,v in self.e.items():\\n b,e=k\\n bi,ei=self.rv[b],self.rv[e]\\n self.A[bi,bi]-=v\\n self.A[bi,ei]+=v\",\n \"def CreateAtrium(L,v,d,seed): \\n Neighbours = np.ndarray(L*L, dtype = list)\\n rnd.seed(seed)\\n Phases = np.ndarray(L*L,dtype = float)\\n Phases.fill(4)\\n Functionality = np.ndarray([L*L], dtype = bool)\\n index = np.indices((1, L*L))[1][0]\\n Atrium = index.reshape(L,L) # The index for that site within the long arrays\\n for j in index:\\n z = rnd.uniform(0,1)\\n if d > z: # dysfunctional\\n Functionality[j] = False\\n if d <= z: # functional\\n Functionality[j] = True\\n if j in np.arange(0,L*L,L): # first column\\n Neighbours[j] = list()\\n Neighbours[j].extend([j+1])\\n elif j in (np.arange(0,L*L,L)+L-1): # last column\\n Neighbours[j] = list()\\n Neighbours[j].extend([j-1])\\n else: # body columns\\n Neighbours[j] = list()\\n Neighbours[j].extend([j-1,j+1])\\n w = rnd.uniform(0,1)\\n for j in np.arange(L*L):\\n if w <= v: # transverse connections\\n if j in np.arange(L*L-L,L*L):\\n Neighbours[j].extend([j-(L*L-L)])\\n Neighbours[j-(L*L-L)].extend([j])\\n else:\\n Neighbours[j].extend([j+L])\\n Neighbours[(j+L)].extend([j])\\n return Neighbours, Phases, Functionality, Atrium, index\",\n \"def adj(self, v):\\n for e in self._adj[v]:\\n yield e\",\n \"def relax_method(self, step, data, method, verbose, tree, n_jobs, second_pass = False):\\n\\n unassigned_array_length = len(self.unassigned_data_relax[0,:])\\n\\n count=0.0\\n if verbose and second_pass:\\n progress_bar = print_to_terminal(self, step, data, count, \\\\\\n unassigned_array_length,\\\\\\n method, re=False, second_pass=second_pass)\\n else:\\n progress_bar = print_to_terminal(self, step, data, count, \\\\\\n unassigned_array_length,\\\\\\n method, re=True, second_pass=second_pass)\\n\\n # Now run the linking again with the relaxed constraints\\n for i in range(0, unassigned_array_length):\\n\\n if verbose and (count % 1 == 0):\\n progress_bar + 1\\n progress_bar.show_progress()\\n\\n # Extract the current data point\\n data_point = np.array(self.unassigned_data_relax[:,i])\\n # Retrieve this data point's location in the data array\\n data_idx = get_data_index(self, data, data_point)\\n\\n current_idx = get_current_index(self, i)\\n\\n # Every data point starts as a new cluster\\n self.cluster_idx = current_idx\\n bud_cluster = Cluster(data_point, data_idx, idx=self.cluster_idx, acorns=self)\\n\\n # Calculate distances between all data points\\n link = get_links(self, i, current_idx, tree, n_jobs, re=True)\\n\\n # Find clusters that are closely associated with the current\\n # data point\\n linked_clusters = find_linked_clusters(self, data, i, bud_cluster, link, re = True)\\n\\n if (self.method==1) & (len(linked_clusters) >= 1):\\n linked_clusters = check_other_components(self, i, current_idx, data_idx, data, linked_clusters, bud_cluster, tree, n_jobs, re=False)\\n\\n if not linked_clusters:\\n add_to_cluster_dictionary(self, bud_cluster)\\n elif len(linked_clusters) == 1:\\n merge_into_cluster(self, data, linked_clusters[0], bud_cluster, re = True)\\n else:\\n resolve_ambiguity(self, data, linked_clusters, bud_cluster, re = True)\\n\\n if verbose:\\n progress_bar.progress = 100 # Done\\n progress_bar.show_progress()\\n print('')\\n print('')\\n\\n return\",\n \"def createsolution(self,rows):\\r\\n l = [0,0]\\r\\n if not self.findzero(l):\\r\\n return True\\r\\n x = l[0]\\r\\n y = l[1]\\r\\n for i in range(1,10):\\r\\n if self.check(i, x, y):\\r\\n rows[x][y] = i\\r\\n if self.createsolution(rows):\\r\\n return True\\r\\n rows[x][y] = 0\\r\\n return False\",\n \"def value_iteration(P, nS, nA, V, gamma=0.9, tol=1e-8):\\n \\n V_new = V.copy()\\n ############################\\n # YOUR IMPLEMENTATION HERE #\\n while True:\\n deltaV=0;\\n for state in range(nS):\\n # new_value=0;\\n action_policy = np.zeros(nA) \\n for action in range(nA):\\n for p,nextS,r,boolean_v in P[state][action]:\\n action_policy[action] += p*( r + gamma* V[nextS])\\n V_new[state]=max(action_policy)\\n deltaV= max(deltaV, abs(V_new[state]-V[state]))\\n V[state] = V_new[state]\\n #print(value_function)\\n if(deltaV < tol):\\n break\\n policy_new = policy_improvement(P, nS, nA, V_new, gamma)\\n ############################\\n return policy_new, V_new\",\n \"def test_tensors_can_substitute_vectors_simultaneously(\\n free_alg, full_balance, full_simplify\\n):\\n\\n dr = free_alg\\n p = dr.names\\n\\n x = IndexedBase('x')\\n i, j = p.i, p.j\\n v = p.v\\n\\n orig = dr.einst(x[i, j] * v[i] * v[j])\\n v_def = dr.sum(2 * v[i])\\n\\n dr.full_simplify = full_simplify\\n res = orig.subst(v[i], v_def, full_balance=full_balance).simplify()\\n dr.full_simplify = True\\n\\n expected = dr.einst(4 * x[i, j] * v[i] * v[j]).simplify()\\n assert res == expected\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58130586","0.5767384","0.5755898","0.56656975","0.55695224","0.5568701","0.54769075","0.5428179","0.532105","0.5316448","0.5302247","0.529143","0.5271398","0.5224567","0.52211946","0.52183616","0.5149348","0.5143607","0.51420367","0.512446","0.5123433","0.5114281","0.5099043","0.50904304","0.5061556","0.5060128","0.5050242","0.5045282","0.50400764","0.5037044","0.5033145","0.503078","0.502533","0.50242925","0.50147635","0.50106","0.50106","0.50106","0.50106","0.5008677","0.5003998","0.49872524","0.4982512","0.49752212","0.49660924","0.49483228","0.49282575","0.49223435","0.4916001","0.49068","0.4906416","0.49027058","0.48901606","0.48895332","0.48890647","0.48851207","0.4884887","0.48767692","0.48765597","0.48721242","0.48712608","0.48633823","0.48633823","0.48632154","0.48550642","0.48435366","0.48392937","0.48337772","0.482856","0.48279542","0.48268846","0.48212573","0.48148048","0.48100543","0.47982293","0.4795585","0.47923648","0.47909534","0.4785546","0.47848704","0.4779977","0.47746894","0.47720313","0.477181","0.4770452","0.47658578","0.47647694","0.476219","0.4759567","0.47551525","0.47532168","0.47375596","0.4729596","0.47256693","0.47250062","0.47222415","0.47126907","0.47107315","0.46992207","0.46910143"],"string":"[\n \"0.58130586\",\n \"0.5767384\",\n \"0.5755898\",\n \"0.56656975\",\n \"0.55695224\",\n \"0.5568701\",\n \"0.54769075\",\n \"0.5428179\",\n \"0.532105\",\n \"0.5316448\",\n \"0.5302247\",\n \"0.529143\",\n \"0.5271398\",\n \"0.5224567\",\n \"0.52211946\",\n \"0.52183616\",\n \"0.5149348\",\n \"0.5143607\",\n \"0.51420367\",\n \"0.512446\",\n \"0.5123433\",\n \"0.5114281\",\n \"0.5099043\",\n \"0.50904304\",\n \"0.5061556\",\n \"0.5060128\",\n \"0.5050242\",\n \"0.5045282\",\n \"0.50400764\",\n \"0.5037044\",\n \"0.5033145\",\n \"0.503078\",\n \"0.502533\",\n \"0.50242925\",\n \"0.50147635\",\n \"0.50106\",\n \"0.50106\",\n \"0.50106\",\n \"0.50106\",\n \"0.5008677\",\n \"0.5003998\",\n \"0.49872524\",\n \"0.4982512\",\n \"0.49752212\",\n \"0.49660924\",\n \"0.49483228\",\n \"0.49282575\",\n \"0.49223435\",\n \"0.4916001\",\n \"0.49068\",\n \"0.4906416\",\n \"0.49027058\",\n \"0.48901606\",\n \"0.48895332\",\n \"0.48890647\",\n \"0.48851207\",\n \"0.4884887\",\n \"0.48767692\",\n \"0.48765597\",\n \"0.48721242\",\n \"0.48712608\",\n \"0.48633823\",\n \"0.48633823\",\n \"0.48632154\",\n \"0.48550642\",\n \"0.48435366\",\n \"0.48392937\",\n \"0.48337772\",\n \"0.482856\",\n \"0.48279542\",\n \"0.48268846\",\n \"0.48212573\",\n \"0.48148048\",\n \"0.48100543\",\n \"0.47982293\",\n \"0.4795585\",\n \"0.47923648\",\n \"0.47909534\",\n \"0.4785546\",\n \"0.47848704\",\n \"0.4779977\",\n \"0.47746894\",\n \"0.47720313\",\n \"0.477181\",\n \"0.4770452\",\n \"0.47658578\",\n \"0.47647694\",\n \"0.476219\",\n \"0.4759567\",\n \"0.47551525\",\n \"0.47532168\",\n \"0.47375596\",\n \"0.4729596\",\n \"0.47256693\",\n \"0.47250062\",\n \"0.47222415\",\n \"0.47126907\",\n \"0.47107315\",\n \"0.46992207\",\n \"0.46910143\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64761513"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81595,"cells":{"query":{"kind":"string","value":"Main calculation function that first initalizes with initiateVMatrixes() and then uses relax() until v is within tolerance. 1. Iterate for n = 5, 10 2. Iterate for the range of n in nArray"},"document":{"kind":"string","value":"def calculate():\n global v, vNew, n, stepsToToleranceArray\n stepsToToleranceArray = []\n for n in nArray:\n print('Currently working with n = ', n)\n initiateVMatrixes()\n step = 0\n toleranceAcqurired = False\n while not toleranceAcqurired:\n step+=1\n relax_checker()\n # Controll accuracy\n toleranceAcqurired = True # run through v and set false if not acquired\n for i in range(1,n):\n for j in range(1,n):\n if np.abs( (v[i,j]-vExact[i,j])/vExact[i,j] ) > tolerance:\n toleranceAcqurired = False\n if toleranceAcqurired:\n stepsToToleranceArray.append(step)\n if n in [5,10]: print('n =', n, 'steps =', step)"},"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 initiateVMatrixes():\n global v, vNew, vExact\n # Initialize the grid to 0\n v = np.zeros((n+1, n+1)) # matrix of v, index are i: row, j:column\n # Set the boundary conditions\n for i in range(1,n):\n v[0,i] = 10\n v[n,i] = 10\n v[i,0] = 10\n v[i,n] = 10\n # Exact solution\n vExact = np.copy(v)\n for i in range(1,n):\n for j in range(1,n):\n vExact[i,j] = 10\n # Initial guess\n for i in range(1,n):\n for j in range(1,n):\n v[i,j] = 0.9*vExact[i,j]\n vNew = np.copy(v)","def solve_VFI(self):\r\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \r\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\r\n tol = self.tol ; Niter = self.Niter ; R = self.R\r\n beta = self.beta ; Pi = self.Pi\r\n \r\n V0 = np.zeros((dimA,dimC,dimW))\r\n V1 = np.zeros((dimA,dimC,dimW))\r\n Pol = np.zeros((dimA,dimC,dimW))\r\n U = np.zeros((dimA,dimC,dimW))\r\n \r\n t0 = time()\r\n diff = 1 ; niter = 0\r\n \r\n while diff > tol:\r\n niter += 1\r\n # Value update step\r\n for ia in range(dimA):\r\n for ic in range(dimC):\r\n for iw in range(dimW):\r\n c = W[iw] + R*A[ia] - A\r\n x = C[ic]\r\n \r\n c[c < 0] = np.nan \r\n if x < 0:\r\n x = np.nan\r\n \r\n u = self.u(c,x) \r\n U[:,ic,iw] = u \r\n \r\n Objective = U + beta * V0 @ Pi.T\r\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\r\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\r\n \r\n # Evaluate distance between the value functions\r\n diff = np.max(np.max(np.abs(V1 - V0))) \r\n V0[:] = V1\r\n \r\n # Break the while loop if too many iterations\r\n #print(\"The current error is \"+str(diff))\r\n if niter > Niter:\r\n print('Ops, no convergence')\r\n break\r\n \r\n t1 = time()\r\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\r\n \r\n self.V1 = V1 ; self.Pol = Pol","def relax_checker():\n checker = 2\n global v, vNew, n\n for check in range(0,2):\n for x in range(1,n):\n for y in range(1,n):\n if (x*(n+1) + y) % 2 == check:\n v[x,y] = (v[x-1][y] + v[x+1][y] + v[x][y-1] + v[x][y+1])*0.25","def VFI(method) :\n iteration=0 # Iteration Counter\n converged = 0 # Convergence Flag|\n \n#----- Initial Settings \n v_update = zeros(n_grid)\n v_func = empty(n_grid)\n k_next_vec = empty(n_grid)\n run_time = empty(2)\n \n def obj(k_next) :\n \"\"\"\n This function is used in value function iteration.\n It represents the objective function to be maximized for one node (state) of current capitals.\n Resulting value is maximized one corresponding to next period's capital as a maximizer. \n Next period's value is computed by interpolation.\n \n Input : k_next (next period's capital)\n \n Output : value_vec (maximized value resulting from choosing optimal capital in the next period)\n \"\"\" \n \n if method==1 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*linear_interp(k_grid,v_update,k_next))\n elif method==2 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*quad_interp(k_grid,v_update,k_next))\n elif method==3 :\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*cubic_interp(k_grid,v_update,k_next))\n \n return value_vec\n\n#----- Value function iteration\n start = time.time() # start time\n while converged==0 :\n index = 0\n for k_current in k_grid :\n k_next = fminbound(obj,k_grid[0],k_grid[-1])\n v_func[index] = (-1) * obj(k_next)\n k_next_vec[index] = k_next\n index = index + 1\n dist = abs(max(v_func - v_update))\n if dist<tol :\n converged = 1\n v_k, g_k = v_func, k_next_vec\n v_update = v_func\n print \"Iteration : \",iteration,\"\",\"Distance : \",dist # convergence process\n iteration = iteration + 1\n v_func = empty(n_grid) \n k_next_vec = empty(n_grid)\n \n end = time.time() # end time\n run_time[0],run_time[1] = runtime_cal(start,end) # total running time\n \n return v_k, g_k, run_time, iteration","def 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 voltage_update(n):\n global t\n t = dt*(n-0.5)\n\n cv = dt / (C * dx)\n\n # recursively update the line voltage at all interior nodes\n for k in range(0, nx - 1):\n V[k] = V[k] - cv * (I[k] - I[k - 1])","def eigenalgo(self, accuracy: float = 0, cap: int = 50000, version: str = \"Givens\", not_skip: bool = True):\n j, temps, verify_accuracy = 0, 0, np.ones((self.N, self.N), dtype=bool) ^ np.eye(self.N, dtype=bool)\n if version == \"Gram-Schmidt\":\n temps = time()\n while np.any(abs(self.vap[verify_accuracy]) > accuracy) and j < cap:\n j += 1\n q, r = self.gram_schmidt_qr()\n self.vap, self.vep = r @ q, self.vep @ q\n\n elif version == \"Givens\":\n verify_accuracy = np.ones((self.N, self.N), dtype=bool) ^ np.eye(self.N, dtype=bool)\n temps = time()\n while np.any(abs(self.vap[verify_accuracy]) > accuracy) and j < cap:\n j += 1\n q, r = self.givens_qr()\n self.vap, self.vep = r @ q, self.vep @ q\n\n elif version == \"Rayleigh\":\n not_sing, diff, cond, j = True, accuracy + 1, True, 0\n temps = time()\n while cond: # Stop condition, all eigenvalues must be different\n while diff > accuracy and j < cap and not_sing:\n j += 1\n self.rvap, self.vep, diff, not_sing = self.rayleigh_iteration(self.rvap, self.vep)\n\n cond = False\n if j < cap:\n self.calc, first, not_sing = np.zeros(self.N, dtype=bool), True, True\n for i in range(self.N):\n if np.sum(np.less(np.abs(self.rvap - self.rvap[i]), 10 ** -6)) != 1:\n self.rvap[i + 1:] += self.memorize[i]\n if first:\n self.memorize[i] += 0.5\n self.vep[i + 1:, i + 1:] = np.eye(self.N - i - 1)\n first, cond, diff = False, True, accuracy + 1\n self.calc[i + 1:] = 1\n temps = time() - temps\n return self.rvap, self.vep, diff, j, temps\n\n else:\n print(\"Please select an appropriate value for the version parameter\")\n\n temps = time() - temps\n diff = np.max(abs(self.vap[verify_accuracy]))\n return np.diag(self.vap), self.vep, diff, j, temps","def FigA7(case):\n \n #set the parameter, arrays\n \n n_array=np.array([1,2,3])\n\n #set the result arrays\n if case==0:\n class_number=5\n elif case==1:\n class_number=6\n fate=np.zeros([class_number])#number of evolutionary fate\n fate_matrix=np.zeros([np.size(n_array),np.size(fate)])\n \n time=np.linspace(0,100000, 1000000)\n loop=10**6\n \"\"\"\n 0 Co and/or Ch cannot survive in mono-culture\n 1 Co cannot invade\n 2 Only equilibrium of exclusion is stable\n 3 Only equilibrium of coexistence is stable\n 4 Two equilibria are UNstable\n 5 two Equilibrium are stable (which may occur only when sCO vs rCh)\n \"\"\"\n for tri in range(np.size(n_array)):\n counter=0\n n=n_array[tri]\n print(str(\"Hill coefficient is %d\" %(n)))\n fate=np.zeros([class_number])#number of evolutionary fate should be reset\n if case==0 or case==1:\n fname=str('parameter-sweep-MC-n%d-case%d' %(n, case))\n else:\n print(\"Error in case\")\n return 1\n \n for i in range(loop):\n if(i+1)%10000==0:\n print(i+1)\n Ks,cd,T0, alpha,=np.random.uniform(0,1,4)\n Kr,cr=np.random.uniform([Ks,0],[1,1],2)#Kr>Ks and cr.cd\n #check whether r is positive or not\n if case==0:\n r1=rmax*(1-cr-cd)#rCO\n r2=rmax#sCH\n W0Co=r1-dmax*T0**n/(T0**n+Kr**n)-alpha#initial growth of Cooperator\n W0Ch=r2-dmax*T0**n/(T0**n+Ks**n)-alpha#initial growth of Cheater\n elif case==1:\n r1=rmax*(1-cd)#sCo\n r2=rmax*(1-cr)#rCh\n W0Co=r1-dmax*T0**n/(T0**n+Ks**n)-alpha\n W0Ch=r2-dmax*T0**n/(T0**n+Kr**n)-alpha\n stab_e=0#initialize the falgs of stability\n stab_c=0\n if W0Co<0 or W0Ch<0:\n fate[0]+=1\n res=0\n else:\n #succeed in mono-culture \n init=np.array([T0,10**(-6)])\n if case==0: \n solCo=odeint(DyCoop, init, time, args=(T0, r1, Kr, alpha, n))\n Ts=solCo[-1,0]\n #x1s=solCo[-1,1]\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Ks, alpha, n))\n x2s=solCh[-1,1]\n else:\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Ks, alpha, n))\n Ts=solCo[-1,0]\n #x1s=solCo[-1,1]\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Kr, alpha, n))\n x2s=solCh[-1,1]\n \n #Evolutionary dynamics \n if case==0:\n K=Kr\n else:\n K=Ks\n if r1*(1-x2s)-dmax*T0**n/(T0**n+K**n)<alpha:\n #Co cannot invade\n fate[1]+=1\n res=1\n else:\n #Co can invade\n #calculate Tdagger Td and check whether coexist or exclude\n if case==0:\n #rCo vs sCh\n #in this case, at most one equilbrium is stable\n tau=Quad(case,alpha,cr+cd,0,Kr, Ks, n)\n Td=tau**(1/n)\n if Td<Ts:\n #Co exclude Ch\n fate[2]+=1\n res=2\n else:\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\n #check the stability condition\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\n if stab==0:\n #stable coexistence\n fate[3]+=1\n res=3\n else:\n #unstable coexistence nor exclusion\n fate[4]+=1\n res=4\n print(Td, x1d, x2d)\n else:\n #sCo vs rCh\n # in this case two equilibria can be stable at the same time\n [tau_p,tau_m]=Quad(case,alpha,cd,cr,Ks, Kr, n)\n if tau_m>Ts**n or tau_p<Ts**n:\n # cexclusion is stable\n stab_e=1\n # stability in coexistence \n if tau_p<0:\n stab_c=0\n else:\n Td=tau_p**(1/n)\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\n #check the stability condition\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\n if stab==0:\n #stable coexistence\n stab_c=1\n #classify\n if stab_e==1 and stab_c==1:\n # two stable equilbria\n fate[5]+=1\n res=5\n elif stab_e==1 and stab_c==0:\n #only stable cexclusion\n fate[2]+=1\n res=2\n elif stab_e==0 and stab_c==1:\n #stable coexistence\n fate[3]+=1\n res=3\n else:\n #both unstable\n fate[4]+=1\n res=4\n \n #save the results\n if counter==0:\n result=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\n #save the result with parameter values\n \n else:\n #add array of results\n R=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\n result=np.concatenate((result, R), axis=0)\n counter+=1\n \n #save csv file and graph\n np.savetxt(fname+'.csv',result, delimiter=',', header='Ks, Kr, cr, cd, alpha, T0, class', fmt='%.6f') \n print(fate)\n fate_matrix[tri,:]=fate \n if case==0: \n np.savetxt('parameter_sweep_MC_total_case0.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4', fmt='%d')\n else:\n np.savetxt('parameter_sweep_MC_total_case1.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4,cl5', fmt='%d')\n Plot(case)","def mmb_secuencial(n, tol):\n if n <= 1:\n return \"El parametro n debe ser mayor a 1\"\n\n # Se crea la matriz tridiagonal y la matriz de resultados\n matriz_a = crear_matriz_a(n)\n matriz_b = crear_matriz_b(n)\n\n # Se crea el vector inicial\n vec_x = matrix(ones((n, 1), dtype='object'))\n\n # Se crean las variables simbolicas\n simbolos = [MatrixSymbol('A', n, n),\n MatrixSymbol('b', n, 1),\n MatrixSymbol('x', n, 1)]\n\n simb_a = simbolos[0] # Variable simbolica de la matriz A\n simb_b = simbolos[1] # Variable simbolica de la matriz b\n simb_x = simbolos[2] # Variable simbolica de la matriz x\n\n # Se crea la funcion que debe ser evaluada\n f = 1/2 * simb_x.T * simb_a * simb_x - simb_b.T * simb_x\n funcion = lambdify(simbolos, f) # f(A, b, x)\n\n z = Symbol('z')\n\n vec_x_simbolico = []\n # Se crean todas las variables simbolicas del vector\n for i in range(0, n):\n vec_x_simbolico.append([Symbol('x' + str(i))])\n\n # Se construye una np.matrix a partir del vector obtenido\n vec_x_simbolico = matrix(vec_x_simbolico)\n\n gradiente = calcular_gradiente(funcion, matriz_a, matriz_b, vec_x_simbolico)\n\n # Se crean los vectores para las iteraciones\n vec_x1_aux = matrix(zeros((n, 1), dtype='object'))\n vec_error = matrix(zeros((n, 1), dtype='object'))\n\n # Se crean las listas para graficar el error\n lista_iter = []\n lista_error = []\n\n itr = 1 # Contador de iteraciones\n\n while 1:\n # Se calcula el vector k+1 utilizando la regla de Jacobi\n for j in range(0, n):\n copia_vec_x = vec_x.copy()\n copia_vec_x[j] = z\n\n # Se evalua la funcion con el vec_x con la variable simbolica\n ecuacion = funcion(matriz_a, matriz_b, copia_vec_x)\n\n # Se crea la funcion a minimizar\n fun_minimizar = lambdify(z, ecuacion.item(0))\n\n # Se minimiza la funcion\n resultado = optimize.minimize_scalar(fun_minimizar).x\n\n # Se actualiza el vector de la iteracion actual\n vec_x1_aux[j] = resultado\n\n # Se calcula el valor para el vector de error\n copia_vec_x[j] = resultado\n vec_error[j] = funcion(matriz_a, matriz_b, copia_vec_x)\n\n # Se obtiene la posicion del menor elemento en el vector de error\n i = vec_error.argmin()\n\n # Se actualiza el valor en la posicion minima\n vec_x[i] = vec_x1_aux[i]\n\n # Se calcula el vector para verificar la condicion de parada\n vec_parada = evaluar_gradiente(gradiente, vec_x_simbolico, vec_x)\n vec_parada = matrix(vec_parada, dtype='float')\n\n norma_2 = linalg.norm(vec_parada, 2)\n\n lista_iter.append(itr)\n lista_error.append(norma_2)\n\n # Se verifica la condicion de parada\n if norma_2 < tol:\n break\n\n itr += 1\n\n graficar_error(lista_iter, lista_error)\n\n return vec_x","def runpower(matrix, n, tolerance, max_num=None, return_vector=True):\n\tcalculate_next = True\n\teigenvalue_list = []\n\teigenvector_list = []\n\tleading_eigenvalue = np.nan\n\twhile(calculate_next):\t\n\t\tnew_eigenvalue, v = runpower_one(matrix, n)\n\t\tif np.isnan(leading_eigenvalue):\n\t\t\tleading_eigenvalue = new_eigenvalue\n\t\teigenvalue_list.append(new_eigenvalue)\n\t\teigenvector_list.append(v)\n\t\tif max_num is not None and len(eigenvalue_list) == max_num:\n\t\t\tbreak\n\t\tif abs(1.0 * new_eigenvalue / leading_eigenvalue) < tolerance:\n\t\t\tcalculate_next = False\n\t\telse:\n\t\t\tmatrix = matrix - new_eigenvalue * np.outer(v,v)\n\tif return_vector:\n\t\treturn eigenvalue_list, np.asarray(eigenvector_list).T\n\telse:\n\t\treturn eigenvalue_list","def main():\n print 'Running the power method...'\n dim = input('Give the dimension : ')\n nbit = input('How many iterations ? ')\n j = complex(0, 1)\n rnd = np.random.normal(0, 1, (dim, dim)) \\\n + np.random.normal(0, 1, (dim, dim))*j\n nbs = np.random.normal(0, 1, (dim, 1)) \\\n + np.random.normal(0, 1, (dim, 1))*j\n rndmat = np.matrix(rnd)\n rndvec = np.matrix(nbs)\n eigmax = power_method(rndmat, rndvec, nbit)\n check(rndmat, eigmax)","def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\n mask, max_iter=100, init=None,\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\n\n # shape of image box\n \n alpha = 1\n\n flat_mask = mask.ravel()\n volume_shape = mask.shape\n H_size = len(Hurst_init)\n\n if lipschitz_constant == 0:\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\n\n #init[\"z\"] = Hurst_init.copy()\n #init[\"t\"] = 1\n #ini[\"stepsize\"] = 1 / lipschitz_constant\n\n def total_energy(x):\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\n\n def unmaskvec(w):\n return _unmask(w, mask)\n\n def maskvec(w):\n return w[flat_mask]\n\n def f1_grad(x):\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\n\n def f2_prox(w, stepsize, dgap_tol, init):\n out, info = _prox_tvl1(unmaskvec(w),\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\n dgap_tol=dgap_tol, init=unmaskvec(init),\n max_iter=prox_max_iter, fista = False,\n verbose=verbose)\n #pdb.set_trace()\n return maskvec(out.ravel()), info\n\n w, obj, init = mfista(\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\n max_iter=max_iter, callback=None)\n \n return w, obj, init","def test_solver1(N, version='scalar'):\n def I(x): return sin(2*x*pi/L)\n def f(x,t): return 0\n solutions = []\n # Need time_level_counter as global variable since\n # it is assigned in the action function (that makes\n # a variable local to that block otherwise).\n # The manager class below provides a cleaner solution.\n global time_level_counter\n time_level_counter = 0\n\n def action(u, t, x):\n global time_level_counter\n if time_level_counter % N == 0:\n solutions.append(u.copy())\n time_level_counter += 1\n\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(solutions[-1])","def simulating_verlet(n,N,D,t,Rv,sigma,epsilon,dt,m,T,dim,kb,V,steps_r):\n Ekinv = np.zeros((n,1))\n Epotv = np.zeros((n,1))\n Ev = np.zeros((n,1))\n Gpc = np.zeros((steps_r,n))\n for k in range(len(t)):\n F = particle_forceV(Rv[-1], N, sigma, epsilon, D)\n Rv.append(particle_positionV(copy.deepcopy(Rv[-1]), V, dt, F, D)) \n V = particle_velocityV(V, F, dt, Rv, sigma, epsilon, D, N)\n Ekinv[k] = np.sum(1/(2*m)*(V**2))\n \n #Calibration\n if (int(k%(10)) == int(0) & int(k)<int(len(t)/2)):\n V = calibration(N, kb,T,Ekinv[k],V)\n Ekinv[k] = np.sum(1/(2*m)*(V**2))\n if int(k)> int(len(t)-50):\n Gpc[:,k], dist, dr = pair_correlation(N,Rv[-1],D,steps_r)\n Uv = particle_LJV(Rv[-1], N, D) \n Epotv[k] = abs(Uv)/2 \n Ev[k] = Ekinv[k]+Epotv[k]\n return Rv, Ekinv, Epotv, Ev, Gpc","def test_euler():\n for nsteps in [1, 5]:\n solver = EulerSolver(nsteps)\n integration_testing(solver)","def calculate_vn_eta(eta_array, dN_array, vn_array, eta_min, eta_max):\n nev, neta = dN_array.shape\n dN_array = dN_array.reshape((nev, 1, neta))\n idx = (eta_array > eta_min) & (eta_array < eta_max)\n vn_ref = (sum(dN_array[:, :, idx]*vn_array[:, :, idx], axis=2)\n /(sum(dN_array[:, :, idx], axis=2) + 1e-15))\n vnshape = vn_ref.shape\n nvn = vnshape[1]\n vn_ref = vn_ref.reshape((vnshape[0], vnshape[1], 1))\n vn_SP_ev = real(vn_array*conj(vn_ref))\n vn_SP_array = zeros([nev, nvn, neta])\n for iev in range(nev):\n array_idx = [True]*nev\n array_idx[iev] = False\n array_idx = array(array_idx)\n vn_den = mean((absolute(vn_ref[array_idx, :, :]))**2., axis=0)\n vn_SP = (mean(vn_SP_ev[array_idx, :, :], axis=0)\n /(sqrt(vn_den) + 1e-16))\n vn_SP_array[iev, :, :] = vn_SP\n vn_SP_mean = mean(vn_SP_array, axis=0)\n vn_SP_err = sqrt((nev - 1.)/nev*sum((vn_SP_array - vn_SP_mean)**2., axis=0))\n return([vn_SP_mean, vn_SP_err])","def run_test(d):\n\n ######### Problem Specification\n\n # Data generation parameters\n prior_mu_z = np.zeros(d, dtype=np.float32) # Prior mean\n prior_sigma_z = np.eye(d, dtype=np.float32) # Prior covariance matrix\n\n # True model parameters\n num_range = np.arange(-(d-1)/2, (d+1)/2, dtype=np.float32)\n\n t_delta = num_range / 5 \n\n if d == 1:\n t_sigma = np.ones(1)\n else: \n # Allow sigma to range from 0.1 to 1\n t_sigma = 36/(10*(d-1)**2) * num_range**2 + 0.1 \n\n ######### Variable Initialization\n\n # Initial model parameters - same across all methods\n init_delta = prior_mu_z.copy()\n init_log_sigma = 3 * np.ones(d)\n\n # Initial HVAE variational parameters\n init_T = 5.\n init_eps = 0.005 * np.ones(d)\n max_eps = params['max_eps'] * np.ones(d)\n init_logit_eps = np.log(init_eps/(max_eps - init_eps))\n init_log_T_0 = np.log(init_T - 1)\n\n # Initial NF variational parameters\n init_u_pre_reparam = scipy.stats.truncnorm.rvs(-2, 2, scale=0.1, size=d)\n init_w = scipy.stats.truncnorm.rvs(-2, 2, scale=0.1, size=d)\n init_b = 0.1\n\n # Initial VAE parameters\n init_mu_z = prior_mu_z.copy()\n init_log_sigma_z = np.ones(d)\n\n ######### Set up models\n\n HVAE_model_1 = HVAE(\n ['delta', 'log_sigma', 'logit_eps', 'log_T_0'],\n [init_delta, init_log_sigma, init_logit_eps, init_log_T_0], \n 'HVAE_1', d, params['HVAE_K_1'])\n HVAE_model_2 = HVAE(\n ['delta', 'log_sigma', 'logit_eps', 'log_T_0'],\n [init_delta, init_log_sigma, init_logit_eps, init_log_T_0], \n 'HVAE_2', d, params['HVAE_K_2'])\n\n HVAE_model_notemp_1 = HVAE(\n ['delta', 'log_sigma', 'logit_eps'],\n [init_delta, init_log_sigma, init_logit_eps], \n 'HVAE_notemp_1', d, params['HVAE_K_1'])\n HVAE_model_notemp_2 = HVAE(\n ['delta', 'log_sigma', 'logit_eps'], \n [init_delta, init_log_sigma, init_logit_eps],\n 'HVAE_notemp_2', d, params['HVAE_K_2'])\n\n NF_model_1 = NF(\n ['delta', 'log_sigma', 'u_pre_reparam', 'w', 'b'],\n [init_delta, init_log_sigma, init_u_pre_reparam, init_w, init_b],\n 'NF_1', d, params['NF_K_1'])\n NF_model_2 = NF(\n ['delta', 'log_sigma', 'u_pre_reparam', 'w', 'b'],\n [init_delta, init_log_sigma, init_u_pre_reparam, init_w, init_b],\n 'NF_2', d, params['NF_K_2'])\n\n VB_model = VB(['delta', 'log_sigma', 'mu_z', 'log_sigma_z'], \n [init_delta, init_log_sigma, init_mu_z, init_log_sigma_z], 'VB', d)\n\n model_list = [HVAE_model_1, HVAE_model_2, HVAE_model_notemp_1, \n HVAE_model_notemp_2, NF_model_1, NF_model_2, VB_model]\n \n ######### Generate Training Data & Save - One for each test\n\n train_data_list = []\n\n for i in range(params['n_tests']):\n z = np.random.multivariate_normal(prior_mu_z, prior_sigma_z)\n x = np.random.multivariate_normal(z + t_delta, np.diag(t_sigma**2), \n size=params['n_data'])\n train_data_list.append(x)\n\n # Folder should have already been created in the initializations\n data_path = os.path.join('save', str(d), 'train_data.p')\n pickle.dump(train_data_list, open(data_path, 'wb')) \n\n ######### Train models\n\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n\n # Store the final parameter values for all test runs in this dictionary\n final_params = {}\n\n for m in model_list:\n\n final_values = []\n\n for i in range(params['n_tests']):\n (delta, sigma) = m.train(sess, train_data_list[i], i)\n final_values.append((delta, sigma))\n\n final_params[m.model_name] = final_values.copy()\n\n ######### Test models using difference between parameters\n\n param_diffs = {}\n\n for m in model_list:\n\n diffs = []\n\n for i in range(params['n_tests']):\n delta = final_params[m.model_name][i][0]\n sigma = final_params[m.model_name][i][1]\n\n delta_diff = np.sum((delta - t_delta)**2)\n sigma_diff = np.sum((sigma - t_sigma)**2)\n\n diffs.append((delta_diff, sigma_diff))\n\n param_diffs[m.model_name] = diffs.copy()\n\n # Save parameter differences in a pickle file\n diff_path = os.path.join('save', str(d), 'all_diffs.p')\n pickle.dump(param_diffs, open(diff_path, 'wb'))","def davidson_solver(ax_function, preconditioner, guess, e_conv=1.0E-8, r_conv=None, no_eigs=1, max_vecs_per_root=10, maxiter=100):\n\n if r_conv == None:\n r_conv = e_conv * 100\n d_tol = 1.0E-8\n\n # using the shape of the guess vectors to set the dimension of the matrix\n N = guess.shape[0]\n\n #sanity check, guess subspace must be at least equal to number of eigenvalues\n nli = guess.shape[1]\n if nli < no_eigs:\n raise ValueError(\"Not enough guess vectors provided!\")\n\n nl = nli\n converged=False\n count = 0\n sub_count = nli\n A_w_old = np.ones(nli)\n max_ss_size = nli * max_vecs_per_root\n B = np.zeros((N,N))\n B[:,:nli] = guess\n\n ### begin loop\n while count < maxiter:\n active_mask = [True for x in range(nl)]\n # Apply QR decomposition on B to orthogonalize the new vectors wrto all other subspace vectors\n ## orthogonalize preconditioned residuals against all other vectors in the search subspace\n B, r = np.linalg.qr(B)\n\n # compute sigma vectors corresponding to the new vectors sigma_i = A B_i\n sigma = np.zeros((N,nl))\n for i in range(nl):\n bvec = B[:,i]\n sigma[:,i] = ax_function(B[:,i])\n\n # compute subspace matrix A_b = Btranspose sigma\n A_b = np.dot(B[:,:nl].T, sigma)\n\n # solve eigenvalue problem for subspace matrix; choose n lowest eigenvalue eigpairs\n A_w, A_v = np.linalg.eig(A_b)\n\n # sorting eigenvalues and corresponding eigenvectors\n A_v = A_v[:, A_w.argsort()]\n A_w = A_w[A_w.argsort()]\n\n # here, check if no residuals > max no residuals, if so, collapse subspace\n sub_count = A_v.shape[0]\n if sub_count >= max_ss_size:\n print(\"Subspace too big. Collapsing.\\n\")\n Bnew = np.zeros((N,N))\n Bnew[:,:nli] = np.dot(B[:,:nl], A_v[:,:nli])\n B = Bnew\n nl = nli\n continue\n # else, build residual matrix\n ## residual_i = sigma * eigvec - eigval * B * eigvec\n norm = np.zeros(nli)\n for i in range(0, nli):\n mat = A - A_w[i] * np.identity(N) \n residual = np.dot(mat, np.dot(B[:,:sub_count], A_v[:,i]))\n\n ## check for convergence by norm of residuals\n norm[i] = np.linalg.norm(residual)\n ##apply the preconditioner (A_ii - A_v_i)^-1\n precon_resid = preconditioner(residual, i, A, A_w)\n\n ## normalize and add to search subspace if they're larger than a threshold\n if np.linalg.norm(precon_resid) > d_tol:\n B[:,nl+1] = precon_resid\n nl += 1\n\n # check for convergence by diff of eigvals and residual norms\n check = norm < r_conv\n eig_norm = np.linalg.norm(A_w[:no_eigs] - A_w_old[:no_eigs])\n A_w_old = A_w\n if(check.all() == True and eig_norm < e_conv):\n converged = True\n break\n count += 1 \n\n if converged:\n print(\"Davidson converged at iteration number {}. \\n Eigenvalues: {} \\n Eigenvectors: {}\".format(count, A_w[:no_eigs], A_v[:,:no_eigs]))\n else:\n print(\"Davidson did not converge. Max iterations exceeded.\")","def run(self):\n self.errList = []\n self.initialize()\n\n for i in range(self.maxiter):\n # update U\n for k in range(self.K):\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\n full_matrices=False)\n self.U[k] = q.T.dot(p.T)\n self.U[k] = self.U[k].real\n\n # calculate temporal variable y\n y = np.zeros([self.rank, self.L, self.K])\n for k in range(self.K):\n y[:, :, k] = self.U[k].T.dot(self.X[k])\n\n # get H, V, and temps by running a single iteration of CP_ALS\n if i == 0:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1, printitn=0)\n else:\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\n self.rank, tol=self.tol, maxiter=1,\n init=[self.H, self.V, temps], printitn=0)\n self.H = cp.Us[0]\n self.V = cp.Us[1]\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\n\n # update S\n for k in range(self.K):\n self.S[:, :, k] = np.diag(temps[k, :])\n\n # checking the stop criteria\n # error = 0\n for k in range(self.K):\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\n\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\n self.errList.append(error)\n if (i + 1) % self.printitn == 0:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n elif error < self.tol:\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\n self.sigma_new)\n\n if error < self.tol:\n break\n else:\n self.sigma_old = self.sigma_new\n self.sigma_new = 0\n\n for k in range(self.K):\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)","def iterations(self):\n i = 0\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\n n = len(self.model.stateVector)\n self.answer = None\n \n while ((i < self.maxiter) \n and (stateVectorConv > self.stateVectorConvThreshold)\n ):\n \n F, K = self.model()\n \n if np.any(np.isnan(F)) or np.any(np.isnan(K)):\n m = \"Iteration {0} failure of model.\"\n raise OptimalEstimationException(m.format(i))\n \n if self.model.verbose > 0:\n self.model.plot(i+1, stateVectorConv)\n \n try:\n self.DecomposeJacobian(K)\n except np.linalg.LinAlgError:\n m = \"Iteration {0} failure in decomposition.\"\n raise OptimalEstimationException(m.format(i))\n \n statevectorOffset = (self.V.T * self.priorSinvh * \n np.matrix(np.array(self.model.stateVector) - np.array(self.model.prior) ).T)\n measurementOffset = (self.U.T * self.errSinvh * \n np.matrix(self.model.observation - F).T)\n \n newState = np.matrix((self.w * \n (measurementOffset.A1 + \n self.w * statevectorOffset.A1))/(self.w**2+1.0)).T\n newState = self.priorSh * self.V * newState\n newState = newState.A1 + self.model.prior\n \n stateVectorConv = ((np.matrix(newState - self.model.stateVector) * \n self.Sinv * np.matrix(newState - self.model.stateVector).T)/n)[0,0]\n self.model.stateVector = newState\n\n if i == 0:\n \n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\n \n print('cost Function for iteration {}:'.format(i), self.costFunction)\n\n i += 1\n \n F, K = self.model()\n if self.model.verbose > 0:\n self.model.plot(i+1, stateVectorConv)\n \n try:\n self.DecomposeJacobian(K)\n except np.linalg.LinAlgError:\n raise OptimalEstimationException(\"Failure in decomposition.\")\n \n Wplus2 = np.matrix(np.diag(1.0/(self.w**2+1.0)))\n self.model.covariance = (self.priorSh * self.V * Wplus2 * \n self.V.T * self.priorSh)\n \n\n \n return i, stateVectorConv","def calculate_nonlinear_reponse(vn_array, outputFileName):\n chi_422, chi_422_err = calculate_chi_422(vn_array)\n v4_Psi2, v4_Psi2_err = calculate_v4_Psi2(chi_422, chi_422_err, vn_array)\n rho_422, rho_422_err = calculate_rho_422(v4_Psi2, v4_Psi2_err, vn_array)\n v4_L, v4_L_err = calculate_v4_L(v4_Psi2, v4_Psi2_err, vn_array)\n\n chi_523, chi_523_err = calculate_chi_523(vn_array)\n v5_Psi23, v5_Psi23_err = calculate_v5_Psi23(chi_523, chi_523_err, vn_array)\n rho_523, rho_523_err = calculate_rho_523(v5_Psi23, v5_Psi23_err, vn_array)\n v5_L, v5_L_err = calculate_v5_L(v5_Psi23, v5_Psi23_err, vn_array)\n\n chi_6222, chi_6222_err = calculate_chi_6222(vn_array)\n v6_Psi2, v6_Psi2_err = calculate_v6_Psi2(chi_6222, chi_6222_err, vn_array)\n rho_6222, rho_6222_err = calculate_rho_6222(v6_Psi2, v6_Psi2_err, vn_array)\n\n chi_633, chi_633_err = calculate_chi_633(vn_array)\n v6_Psi3, v6_Psi3_err = calculate_v6_Psi3(chi_633, chi_633_err, vn_array)\n rho_633, rho_633_err = calculate_rho_633(v6_Psi3, v6_Psi3_err, vn_array)\n v6_L, v6_L_err = calculate_v6_L(chi_6222, chi_6222_err,\n chi_633, chi_633_err, vn_array)\n\n results = [v4_L, v4_L_err, v4_Psi2, v4_Psi2_err, rho_422, rho_422_err,\n chi_422, chi_422_err,\n v5_L, v5_L_err, v5_Psi23, v5_Psi23_err, rho_523, rho_523_err,\n chi_523, chi_523_err,\n v6_L, v6_L_err, v6_Psi2, v6_Psi2_err, v6_Psi3, v6_Psi3_err,\n rho_6222, rho_6222_err, rho_633, rho_633_err,\n chi_6222, chi_6222_err, chi_633, chi_633_err]\n f = open(outputFileName, 'w')\n f.write(\"# type value stat. err\\n\")\n for i in range(len(nonlinear_reponse_correlator_name_list)):\n f.write(\"%s %.10e %.10e\\n\"\n % (nonlinear_reponse_correlator_name_list[i],\n results[2*i], results[2*i+1]))\n f.close()\n return","def calculate_rn_eta(eta_array, dN_array, vn_array, outputFileName):\n nev, neta = dN_array.shape\n dN_array = dN_array.reshape((nev, 1, neta))\n Qn_array = vn_array\n Qnshape = Qn_array.shape\n nQn = Qnshape[1]\n\n # calculate the reference flow vector for every event\n eta_b_min = 2.5\n eta_b_max = 4.0\n eta_ref1_tmp = linspace(eta_b_min, eta_b_max, 16)\n eta_ref2_tmp = linspace(-eta_b_max, -eta_b_min, 16)\n Qn_ref1 = [] \n Qn_ref2 = [] \n for iev in range(nev):\n dN1_interp = interp(eta_ref1_tmp, eta_array, dN_array[iev, 0, :])\n dN2_interp = interp(eta_ref2_tmp, eta_array, dN_array[iev, 0, :])\n Qn_ref1_vec = []\n Qn_ref2_vec = []\n for iorder in range(nQn):\n Qn1_interp = interp(eta_ref1_tmp, eta_array,\n Qn_array[iev, iorder, :])\n Qn2_interp = interp(eta_ref2_tmp, eta_array,\n Qn_array[iev, iorder, :])\n Qn_ref1_vec.append(sum(dN1_interp*Qn1_interp)\n /(sum(dN1_interp) + 1e-15))\n Qn_ref2_vec.append(sum(dN2_interp*Qn2_interp)\n /(sum(dN2_interp) + 1e-15))\n Qn_ref1.append(Qn_ref1_vec)\n Qn_ref2.append(Qn_ref2_vec)\n Qn_ref1 = array(Qn_ref1).reshape((nev, nQn, 1))\n Qn_ref2 = array(Qn_ref2).reshape((nev, nQn, 1))\n\n rn_num = real(Qn_array[:, :, ::-1]*conj(Qn_ref1))\n rn_den = real(Qn_array*conj(Qn_ref1))\n rnn_num = real((Qn_ref2*conj(Qn_array))\n *(Qn_array[:, :, ::-1]*conj(Qn_ref1)))\n rnn_den = real((Qn_ref2*conj(Qn_array[:, :, ::-1]))\n *(Qn_array*conj(Qn_ref1)))\n\n # compute the error using jack-knife\n rn_array = zeros([nev, nQn, neta])\n rnn_array = zeros([nev, nQn, neta])\n for iev in range(nev):\n array_idx = [True]*nev\n array_idx[iev] = False\n array_idx = array(array_idx)\n rn_ev = (mean(rn_num[array_idx], axis=0)\n /(mean(rn_den[array_idx], axis=0) + 1e-15))\n rnn_ev = (mean(rnn_num[array_idx], axis=0)\n /(mean(rnn_den[array_idx], axis=0) + 1e-15))\n rn_array[iev, :, :] = rn_ev\n rnn_array[iev, :, :] = rnn_ev\n rn_mean = mean(rn_array, axis=0)\n rn_err = sqrt((nev - 1.)/nev*sum((rn_array - rn_mean)**2., axis=0))\n rnn_mean = mean(rnn_array, axis=0)\n rnn_err = sqrt((nev - 1.)/nev*sum((rnn_array - rnn_mean)**2., axis=0))\n\n f = open(outputFileName, 'w')\n f.write(\"#eta rn(eta) rn_err(eta) rnn(eta) rnn_err(eta)\\n\")\n for ieta in range(len(eta_array)-1):\n f.write(\"%.10e \" % eta_array[ieta])\n for iorder in range(0, n_order-1):\n f.write(\"%.10e %.10e %.10e %.10e \"\n % (rn_mean[iorder, ieta], rn_err[iorder, ieta],\n rnn_mean[iorder, ieta], rnn_err[iorder, ieta]))\n f.write(\"\\n\")\n f.close()\n return","def test_solvers():\n # With P1 elements we have an error E-15 with Krylov solver\n # tolerances of 1E-12, but with P2 elements the error is E-6.\n # P3 elements drive the tolerance down to E-3.\n # For higher mesh resolution we also need reduced tolerances.\n # The tol dict maps degree to expected tolerance for the coarse\n # meshes in the test.\n tol = {'direct': {1: 1E-11, 2: 1E-11, 3: 1E-11},\n 'Krylov': {1: 1E-14, 2: 1E-05, 3: 1E-03}}\n u_D = Expression('1 + x[0]*x[0] + 2*x[1]*x[1]')\n kappa = Expression('x[0] + x[1]')\n f = Expression('-8*x[0] - 10*x[1]')\n for Nx, Ny in [(3,3), (3,5), (5,3)]:\n for degree in 1, 2, 3:\n for linear_solver in 'direct', 'Krylov':\n for solver_func in solver, solver_objects:\n print('solving on 2(%dx%dx) mesh with P%d elements'\n % (Nx, Ny, degree)),\n print(' %s solver, %s function' %\n (linear_solver, solver_func.__name__))\n # Important: Krylov solver error must be smaller\n # than tol!\n u = solver_func(\n kappa, f, u_D, Nx, Ny, degree,\n linear_solver=linear_solver,\n abs_tol=0.1*tol[linear_solver][degree],\n rel_tol=0.1*tol[linear_solver][degree])\n # Make a finite element function of the exact u_D\n V = u.function_space()\n u_D_Function = interpolate(u_D, V) # exact solution\n # Check that dof arrays are equal\n u_D_array = u_D_Function.vector().array() # dof values\n max_error = (u_D_array - u.vector().array()).max()\n msg = 'max error: %g for 2(%dx%d) mesh, degree=%d,'\\\n ' %s solver, %s' % \\\n (max_error, Nx, Ny, degree, linear_solver,\n solver_func.__name__)\n print(msg)\n assert max_error < tol[linear_solver][degree], msg","def v(resistances, r_i, applied_voltages, **kwargs):\n if r_i.word_line > 0 or r_i.bit_line > 0:\n g = fill.g(resistances, r_i)\n i = fill.i(applied_voltages, resistances, r_i)\n\n utils.message('Started solving for v.', **kwargs)\n v_matrix = linalg.spsolve(g.tocsc(), i)\n utils.message('Solved for v.', **kwargs)\n\n # if `num_examples == 1`, it can result in 1D array.\n if v_matrix.ndim == 1:\n v_matrix = v_matrix.reshape(v_matrix.shape[0], 1)\n\n # if one of the interconnect resistances is zero, only half of the\n # matrix_v had to be solved. The other half can be filled without\n # solving because the node voltages are known.\n if r_i.word_line == 0:\n new_v_matrix = np.zeros(\n (2*resistances.size, applied_voltages.shape[1]))\n new_v_matrix[:resistances.size, ] = np.repeat(\n applied_voltages, resistances.shape[1], axis=0)\n new_v_matrix[resistances.size:, ] = v_matrix\n v_matrix = new_v_matrix\n if r_i.bit_line == 0:\n new_v_matrix = np.zeros(\n (2*resistances.size, applied_voltages.shape[1]))\n new_v_matrix[:resistances.size, ] = v_matrix\n v_matrix = new_v_matrix\n else:\n # if both interconnect resistances are zero, all node voltages are\n # known.\n v_matrix = np.zeros(\n (2*resistances.size, applied_voltages.shape[1]))\n v_matrix[:resistances.size, ] = np.repeat(\n applied_voltages, resistances.shape[1], axis=0)\n\n return v_matrix","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 iter_vs_cnum(solver, n_range=None, cnum_range=None, verbose=0, \\\n construct_args=dict(), solve_args=dict() ):\n if n_range is None:\n n_range = range(50, 501, 50)\n if cnum_range is None:\n cnum_range = [10**i for i in range(1,10)]\n\n n_mats = len(n_range) * len(cnum_range)\n print('Evaluating %d matrices' % n_mats)\n\n results = dict()\n\n # Construct solver instance\n solver_ = solver(A=None, b=None, full_output=1, **construct_args)\n\n for n in n_range:\n results[n] = []\n plt.figure()\n plt.title('Size: %d by %d' % (n, n))\n for cond_num in cnum_range:\n if verbose: print('n: %d cnum: %d' % (n, cond_num))\n\n #A = util.psd_from_cond(cond_num=cond_num, n=n)\n A = psd_from_cond(cond_num=cond_num, n=n)\n x_true = 4 * np.random.randn(n)\n b = np.dot(A, x_true)\n\n if verbose: print('Initial resid error: %f' % la.norm(b))\n\n\n solver_.A, solver_.b = A, b\n xopt, n_iter, resids, x_difs = solver_.solve(x_true=x_true, max_iter = n*2, \\\n **solve_args)\n results[n].append(n_iter)\n\n if verbose:\n print('Final resid error: %f' % la.norm(b - np.dot(A, xopt)))\n print('Took %d iter' % n_iter)\n\n return results","def runpower_one(matrix, n):\n\t#get initial vector\n\tv = np.zeros(n)\n\tw = np.zeros(n)\n\tfor j in range(n):\n\t\tv[j] = np.random.uniform(0,1)\n\t#print 'matrix', matrix\n\t#print 'v', v\n\tT = 10000 #number of iterations\n\ttol = 1e-06\n\toldnormw = 0\n\tfor t in range(T):\n\t\tw = matrix.dot(v)\n\t\t#print 't', t, 'w',w\n\t\tnormw = (np.inner(w,w))**.5\n\t\tv = w/normw\n\t\t#print 't',t,'v',v\n\t\t#print 't',t,'normw',normw, 'old', oldnormw\n\t\tif np.abs(normw - oldnormw)/normw < tol:\n\t\t\t#print ' breaking'\n\t\t\tbreak\n\t\toldnormw = normw\n\treturn normw, v","def value_iteration(vision, n_tongs):\n q_value = np.zeros([11, 11, 4, 3], dtype=np.float32)\n for _ in range(1000):\n delta = 0\n for px in range(11):\n for py in range(11):\n item = recognize_item(px, py, vision)\n # Not update for locations collecting items, to avoid endless loops.\n if (item == 'diamond' and n_tongs > 0) or item == 'tongs' or item == 'jellybean':\n continue\n q_new = np.zeros([4, 3], dtype=np.float32)\n for d in range(4):\n for a in range(3):\n px_next, py_next, d_next, r = simulate_step(px, py, d, a, vision, n_tongs)\n q_new[d, a] = r\n if 0 <= px_next < 11 and 0 <= py_next < 11: # next position in vision\n q_new[d, a] += np.max(q_value[px_next, py_next, d_next])\n delta = max(delta, norm(q_new - q_value[px, py], ord=np.inf))\n q_value[px, py] = q_new\n if delta < 1e-3:\n break\n return q_value","def calibration(N,kb,T,Ekinv,V):\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\n \n if lamb < 0.9999:\n V = lamb*V\n elif lamb>1.0001:\n V = lamb*V\n \n return V","def _arnoldi_fact(matvec, args, v0, krylov_vectors, H, start, num_krylov_vecs,\n eps):\n Z = jax.numpy.linalg.norm(v0)\n v = v0 / Z\n krylov_vectors = jax.ops.index_update(krylov_vectors,\n jax.ops.index[start, :],\n jax.numpy.ravel(v))\n H = jax.lax.cond(\n start > 0, start,\n lambda x: jax.ops.index_update(H, jax.ops.index[x, x - 1], Z), None,\n lambda x: H)\n\n # body of the arnoldi iteration\n def body(vals):\n krylov_vectors, H, matvec, vector, _, threshold, i, maxiter = vals\n Av = matvec(vector, *args)\n initial_vals = [Av, krylov_vectors, i, H]\n Av, krylov_vectors, _, H = jax.lax.fori_loop(\n 0, i + 1, modified_gram_schmidt_step_arnoldi, initial_vals)\n norm = jax.numpy.linalg.norm(Av)\n Av /= norm\n H = jax.ops.index_update(H, jax.ops.index[i + 1, i], norm)\n krylov_vectors = jax.ops.index_update(krylov_vectors,\n jax.ops.index[i + 1, :],\n jax.numpy.ravel(Av))\n return [krylov_vectors, H, matvec, Av, norm, threshold, i + 1, maxiter]\n\n def cond_fun(vals):\n # Continue loop while iteration < num_krylov_vecs and norm > eps\n _, _, _, _, norm, _, iteration, _ = vals\n counter_done = (iteration >= num_krylov_vecs)\n norm_not_too_small = norm > eps\n continue_iteration = jax.lax.cond(counter_done,\n _, lambda x: False,\n _, lambda x: norm_not_too_small)\n\n return continue_iteration\n initial_norm = v.real.dtype.type(1.0+eps)\n initial_values = [krylov_vectors, H, matvec, v, initial_norm, eps, start,\n num_krylov_vecs]\n final_values = jax.lax.while_loop(cond_fun, body, initial_values)\n kvfinal, Hfinal, _, _, norm, _, it, _ = final_values\n return kvfinal, Hfinal, it, norm < eps","def gs(self, k=50):\n # a. initialize V1 to Vk as a matrix of zeros\n Vs = np.zeros((k, self.ATA.shape[0]), dtype=float)\n\n # initialize u_n as first eigen vector?\n # un = self.eigen_vectors[0]\n\n # looking for k largest eigenvalues and associated eigenvectors\n # of ATA\n # b. for i = 1 to k\n for i in tqdm(range(len(Vs))):\n print(\"Doing i\")\n\n # i. randomly generated vector of size m\n # (length of latitudes, in this case?)\n # scale entire vector by its magnitude, to make magnitude = 1\n u1 = scale_mag_1(np.random.rand(self.ATA.shape[0]))\n un = u1 # at first, u_n is u_1 and random\n\n diff = 1 # set initial diff too high to trip while loop\n while diff > 1e-3:\n\n print(\"Doing ii\")\n # ii. u_(n+1) = A^T*A*u_n\n u1more = np.dot(self.ATA, un)\n\n print(\"Doing iii\")\n # iii. u_(n+1) = u_(n+1) - Sigma_j^(i-1)(u_(n+1)^T * V_j) * V_j\n u1more = u1more - np.sum([\n np.dot(np.dot(u1more.T, Vs[j]), Vs[j]) for j in range(i)\n ])\n\n print(\"Doing iv\")\n # iv. u_(n+1) = u_(n+1) / || u_(n+1) ||\n # just norm mag\n u1more = scale_mag_1(u1more)\n\n diff = mag(u1more - un)\n print(\"Diff:\", diff)\n\n un = u1more\n\n Vs[i] = un","def run_exact(self):\n self.operator, var_form, opt = self.generate_VQE_args()\n\n exact_eigensolver = ExactEigensolver(self.operator, k=1)\n self.result = exact_eigensolver.run()\n\n solution = self.extract_solution(self.result, True)\n return solution","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 solve(n_vec, m_vec, p_vec, repeat, dns_level, seed, solver='gurobi'):\n\n print(\"Solving random problems with solver %s\\n\" % solver)\n\n # Define statistics to record\n std_solve_time = np.zeros(len(n_vec))\n avg_solve_time = np.zeros(len(n_vec))\n min_solve_time = np.zeros(len(n_vec))\n max_solve_time = np.zeros(len(n_vec))\n\n n_prob = len(n_vec)\n\n # Store also OSQP time\n if solver == 'miosqp':\n # Add OSQP solve times statistics\n avg_osqp_solve_time = np.zeros(len(n_vec))\n\n # reset random seed\n np.random.seed(seed)\n\n for i in range(n_prob):\n\n # Get dimensions\n n = n_vec[i]\n m = m_vec[i]\n p = p_vec[i]\n\n print(\"problem n = %i, m = %i, p = %i\" % (n, m, p))\n\n # Define vector of cpu times\n solve_time_temp = np.zeros(repeat)\n\n # Store also OSQP time\n if solver == 'miosqp':\n osqp_solve_time_temp = np.zeros(repeat)\n\n for j in tqdm(range(repeat)):\n # for j in range(repeat):\n\n # Generate random vector of indeces\n i_idx = np.random.choice(np.arange(0, n), p, replace=False)\n\n # Generate random Matrices\n Pt = spa.random(n, n, density=dns_level)\n P = spa.csc_matrix(np.dot(Pt, Pt.T))\n q = sp.randn(n)\n A = spa.random(m, n, density=dns_level)\n u = 2 + sp.rand(m)\n l = -2 + sp.rand(m)\n\n # Enforce [0, 1] bounds on variables\n i_l = np.zeros(p)\n i_u = np.ones(p)\n # A, l, u = miosqp.add_bounds(i_idx, 0., 1., A, l, u)\n\n if solver == 'gurobi':\n # Solve with gurobi\n prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\n res_gurobi = prob.solve(solver=mpbpy.GUROBI,\n verbose=False, Threads=1)\n if res_gurobi.status != 'optimal':\n import ipdb\n ipdb.set_trace()\n solve_time_temp[j] = 1e3 * res_gurobi.cputime\n\n elif solver == 'miosqp':\n # Define problem settings\n miosqp_settings = {\n # integer feasibility tolerance\n 'eps_int_feas': 1e-03,\n # maximum number of iterations\n 'max_iter_bb': 1000,\n # tree exploration rule\n # [0] depth first\n # [1] two-phase: depth first until first incumbent and then best bound\n 'tree_explor_rule': 1,\n # branching rule\n # [0] max fractional part\n 'branching_rule': 0,\n 'verbose': False,\n 'print_interval': 1}\n\n osqp_settings = {'eps_abs': 1e-03,\n 'eps_rel': 1e-03,\n 'eps_prim_inf': 1e-04,\n 'verbose': False}\n\n model = miosqp.MIOSQP()\n model.setup(P, q, A, l, u, i_idx, i_l, i_u,\n miosqp_settings,\n osqp_settings)\n res_miosqp = model.solve()\n\n # DEBUG (check if solutions match)\n # prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\n # res_gurobi = prob.solve(solver=mpbpy.GUROBI, verbose=False)\n # if (np.linalg.norm(res_gurobi.x - res_miosqp.x) /\n # np.linalg.norm(res_gurobi.x)) > 1e-02:\n # import ipdb; ipdb.set_trace()\n#\n # import ipdb; ipdb.set_trace()\n\n if res_miosqp.status != miosqp.MI_SOLVED:\n import ipdb\n ipdb.set_trace()\n \n # Solution time \n solve_time_temp[j] = 1e3 * res_miosqp.run_time\n\n # Store OSQP time in percentage\n if solver == 'miosqp':\n osqp_solve_time_temp[j] = \\\n 100 * (res_miosqp.osqp_solve_time / res_miosqp.run_time)\n\n # Get time statistics\n std_solve_time[i] = np.std(solve_time_temp)\n avg_solve_time[i] = np.mean(solve_time_temp)\n max_solve_time[i] = np.max(solve_time_temp)\n min_solve_time[i] = np.min(solve_time_temp)\n\n # Store also OSQP time\n if solver == 'miosqp':\n avg_osqp_solve_time[i] = np.mean(osqp_solve_time_temp)\n\n # Create pandas dataframe for the results\n df_dict = {'n': n_vec,\n 'm': m_vec,\n 'p': p_vec,\n 't_min': min_solve_time,\n 't_max': max_solve_time,\n 't_avg': avg_solve_time,\n 't_std': std_solve_time}\n\n # Store also OSQP time\n if solver == 'miosqp':\n df_dict.update({'t_osqp_avg': avg_osqp_solve_time})\n\n timings = pd.DataFrame(df_dict)\n\n return timings","def calculate_vn4(vn_data_array, outputFileName):\n vn_data_array = array(vn_data_array)\n nev = len(vn_data_array[:, 0])\n dN = real(vn_data_array[:, 0])\n Q1 = dN*vn_data_array[:, 1]\n Q2 = dN*vn_data_array[:, 2]\n Q3 = dN*vn_data_array[:, 3]\n Q4 = dN*vn_data_array[:, 4]\n Q5 = dN*vn_data_array[:, 5]\n Q6 = dN*vn_data_array[:, 6]\n\n # two-particle correlation\n N2_weight = dN*(dN - 1.)\n Q1_2 = abs(Q1)**2. - dN\n Q2_2 = abs(Q2)**2. - dN\n Q3_2 = abs(Q3)**2. - dN\n\n # four-particle correlation\n N4_weight = dN*(dN - 1.)*(dN - 2.)*(dN - 3.)\n Q1_4 = ((abs(Q1)**4.) - 2.*real(Q2*conj(Q1)*conj(Q1))\n - 4.*(dN - 2.)*(abs(Q1)**2.) + abs(Q2)**2.\n + 2*dN*(dN - 3.))\n Q2_4 = ((abs(Q2)**4.) - 2.*real(Q4*conj(Q2)*conj(Q2))\n - 4.*(dN - 2.)*(abs(Q2)**2.) + abs(Q4)**2.\n + 2*dN*(dN - 3.))\n Q3_4 = ((abs(Q3)**4.) - 2.*real(Q6*conj(Q3)*conj(Q3))\n - 4.*(dN - 2.)*(abs(Q3)**2.) + abs(Q6)**2.\n + 2*dN*(dN - 3.))\n\n # calcualte observables with Jackknife resampling method\n C1_4_array = zeros(nev)\n C2_4_array = zeros(nev)\n C3_4_array = zeros(nev)\n for iev in range(nev):\n array_idx = [True]*nev\n array_idx[iev] = False\n array_idx = array(array_idx)\n\n # C_1{4}\n C1_4_array[iev] = (mean(Q1_4[array_idx])/mean(N4_weight[array_idx])\n - 2.*((mean(Q1_2[array_idx])\n /mean(N2_weight[array_idx]))**2.))\n # C_2{4}\n C2_4_array[iev] = (mean(Q2_4[array_idx])/mean(N4_weight[array_idx])\n - 2.*((mean(Q2_2[array_idx])\n /mean(N2_weight[array_idx]))**2.))\n # C_3{4}\n C3_4_array[iev] = (mean(Q3_4[array_idx])/mean(N4_weight[array_idx])\n - 2.*((mean(Q3_2[array_idx])\n /mean(N2_weight[array_idx]))**2.))\n C1_4_mean = mean(C1_4_array)\n C1_4_err = sqrt((nev - 1.)/nev*sum((C1_4_array - C1_4_mean)**2.))\n C2_4_mean = mean(C2_4_array)\n C2_4_err = sqrt((nev - 1.)/nev*sum((C2_4_array - C2_4_mean)**2.))\n C3_4_mean = mean(C3_4_array)\n C3_4_err = sqrt((nev - 1.)/nev*sum((C3_4_array - C3_4_mean)**2.))\n\n v1_4 = 0.0\n v1_4_err = 0.0\n if C1_4_mean < 0:\n v1_4 = (-C1_4_mean)**0.25\n v1_4_err = 0.25*((-C1_4_mean)**(-0.75))*C1_4_err\n\n v2_4 = 0.0\n v2_4_err = 0.0\n if C2_4_mean < 0:\n v2_4 = (-C2_4_mean)**0.25\n v2_4_err = 0.25*((-C2_4_mean)**(-0.75))*C2_4_err\n\n v3_4 = 0.0\n v3_4_err = 0.0\n if C3_4_mean < 0:\n v3_4 = (-C3_4_mean)**0.25\n v3_4_err = 0.25*((-C3_4_mean)**(-0.75))*C3_4_err\n\n results = [v1_4, v1_4_err, C1_4_mean, C1_4_err,\n v2_4, v2_4_err, C2_4_mean, C2_4_err,\n v3_4, v3_4_err, C3_4_mean, C3_4_err,]\n f = open(outputFileName, 'w')\n f.write(\"# n vn{4} vn{4}_err Cn{4} Cn{4}_err\\n\")\n for i in range(1, 4):\n f.write(\"%d %.10e %.10e %.10e %.10e\\n\"\n % (i, results[4*i-4], results[4*i-3],\n results[4*i-2], results[4*i-1]))\n f.close()\n return","def iterate_value(self):\n self.V = np.zeros(self.stateCount)\n for i in range(self.maxIter):\n last_V = np.copy(self.V)\n for state_index in range(self.stateCount):\n current_state = self.env.statespace[state_index]\n for action in self.env.actionspace:\n next_state = self.env.next_state(current_state,action)\n reward = self.env.compute_reward(next_state)\n next_state_index = self.env.stateDict[next_state]\n self.Q[state_index][action] = reward + self.gamma*last_V[next_state_index]\n if self.mode == 'debug':\n print(\"Q(s={}):{}\".format(current_state,self.Q[state_index]))\n self.V[state_index] = max(self.Q[state_index])\n if np.sum(np.fabs(last_V - self.V)) <= self.th:\n print (\"Convergene Achieved in {}th iteration. \"\n \"Breaking V_Iteration loop!\".format(i))\n break","def power_iteration(X):\n #X, languages=prepare_data_matrix()\n M=X\n M=M-np.mean(M, axis=0)\n M=np.cov(M, rowvar=False) #the covariance matrix, size 100x100\n x=np.ones(len(M)) #a random starting vector composed of 100 ones, it only cant be of all zeros\n difference=np.ones(len(x))\n\n #print(np.linalg.norm(difference))\n while np.linalg.norm(difference) >= 10**-5: #we iterate until the difference between the previous and the new x is really small, lets say 10^-5\n #print(x.T.shape)\n oldx=x\n z=M.dot((x.T))\n x=z.T\n x=x/np.linalg.norm(x)\n difference=np.linalg.norm(oldx-x)\n #the x that we get at the end of this loop is our eigenvector\n\n #print(x.dot(M).shape)\n #print(x.shape)\n y=(x.dot(M)).dot(x.T) #y is the corresponding eigenvalue to the eigenvector x\n \n return x, y","def poweig(A, x0, maxiter = 100, ztol= 1.0e-5, mode= 0, teststeps=1):\n m = len(A)\n xi = x0[:] \n \n for n in range(maxiter):\n # matrix vector multiplication.\n xim1 = xi[:]\n for i in range(m):\n xi[i] = 0.0\n for j in range(m):\n xi[i] += A[i][j] * xim1[j]\n print n, xi\n if mode == 0:\n vlen = sqrt(sum([xi[k]**2 for k in range(m)]))\n xi = [xi[k] /vlen for k in range(m)]\n elif mode == 1:\n for k in range(m-1, -1, -1):\n c = abs(xi[k])\n if c > 1.0e-5:\n xi = [xi[k] /c for k in range(m)]\n break\n # early termination test.\n if n % teststeps == 0:\n S = sum([xi[k]-xim1[k] for k in range(m)])\n if abs(S) < ztol:\n break\n #print n, xi\n # Compute Rayleigh quotient.\n numer = sum([xi[k] * xim1[k] for k in range(m)])\n denom = sum([xim1[k]**2 for k in range(m)])\n xlambda = numer/denom\n return xlambda, xi","def invariant_mass_distributions_v_v_v(\n model: SingleRhNeutrinoModel,\n genv: Generation,\n nbins: int,\n):\n\n def msqrd(s, t):\n return msqrd_v_v_v(s, t, model, genv)\n\n tb = ThreeBody(model.mx, (0, 0, 0), msqrd=msqrd)\n return tb.invariant_mass_distributions(nbins=nbins)","def fv(X,Y,dx,dy,r2,i,append,L,N,U,dt,close_list,Nlist,vel_verlet_on,R,menu,submenu,n1,grid,G,wallcount,X2):\r\n\r\n \"\"\"JV: append is a boolean. If it's true, adds the energy to our list, if it isn't, it doesn't.\r\n We do that because in some cases we will call the algorithm more times than the actual step number (and\r\n we only want to sum the value T/dt times), this is needed in the velocity-Verlet algorithm, that we call the fv()\r\n function one more time than needed just to start the loop.\"\"\"\r\n\r\n# L = self.param[2]\r\n#\r\n# N = self.particles.size\r\n\r\n #For computing all the distances I use a trick with the meshgrid function,\r\n #see the documentation on how this works if you dont see it.\r\n\r\n \"\"\"JV: X is an array that contains each position, mx is an nxn array that each column is the position of one particle (so it's a matrix\r\n that has n X rows) and mxt is the same but tranposed (so it's a matrix of n X columns)\"\"\"\r\n\r\n \"\"\"\r\n UPDATE: This block of code is commented because now it's done in a loop inside solve_verlet() (due to Numba...).\r\n Looks a little bit messy but if Numba allowed me to call the np.meshgrid() function we would do this here. Sorry, but I like to keep the comment to remind me that.\r\n \"\"\"\r\n # MX, MXT = np.meshgrid(X,X,copy=False)\r\n # MY, MYT = np.meshgrid(Y,Y,copy=False)\r\n\r\n #JV: So dx is a nxn simetric array with 0 in the diagonal, and each position is the corresponding distance between the particles,\r\n # so the position [1,2] is the distance between partcle 1 and 2 (x1-x2), and so on\r\n # dx = MXT - MX\r\n # dx = dx\r\n\r\n # dy = MYT - MY\r\n # dy = dy\r\n\r\n # r2 = np.square(dx)+np.square(dy)\r\n\r\n # if(menu == \"Free!\"):\r\n # #JV: We do this to get the actual distance in the case of the \"Free!\" simulation, in which there is no elastic collision between the particles and the boundaries\r\n # dx_v2 = (np.abs(dx.copy())-1*L)\r\n # r2_v2 = dx_v2**2+dy**2\r\n # dx = np.where(r2 > r2_v2,dx_v2*np.sign(dx),dx)\r\n # r2 = np.where(r2 > r2_v2,r2_v2,r2)\r\n # dy_v2 = (np.abs(dy.copy())-1*L)\r\n # r2_v2 = dx**2+dy_v2**2\r\n # dy = np.where(r2 > r2_v2,dy_v2*np.sign(dy),dy)\r\n # r2 = np.where(r2 > r2_v2,r2_v2,r2)\r\n # r2_v2 = dx_v2**2+dy_v2**2\r\n # dx = np.where(r2 > r2_v2,dx_v2*np.sign(dx),dx)\r\n # dy = np.where(r2 > r2_v2,dy_v2*np.sign(dy),dy)\r\n # r2 = np.where(r2 > r2_v2,r2_v2,r2)\r\n\r\n dUx = 0.\r\n dUy = 0.\r\n utot = np.zeros((N))\r\n f = np.zeros((N,2))\r\n\r\n for j in range(0,N):\r\n dUx = 0.\r\n dUy = 0.\r\n u = 0.\r\n\r\n #JV: we now calculate the force with only the Nlist closest particles\r\n for k in range(0,Nlist):\r\n c = int(close_list[j][k])\r\n\r\n #In the force computation we include the LJ and the walls (JV: in the verlet case). I truncate the interaction at self.R units of lenght,\r\n #I also avoid distances close to 0 (which only should affect the diagonal in the matrix of distances)\r\n #All these conditions are included using the numpy.where function.\r\n #If you want to include more forces you only need to add terms to these lines.\r\n\r\n if(vel_verlet_on == True):\r\n if((r2[j,c] < 4*max(R[j],R[c])) and (r2[j,c] > 10**(-2))):\r\n dUx = dUx + dLJverlet(dx[j,c],r2[j,c],R[j],R[c])\r\n dUy = dUy + dLJverlet(dy[j,c],r2[j,c],R[j],R[c])\r\n # print(dUx,dUy,dx[j,c],r2[j,c],R[j],R[c])\r\n#JV: COMMENTED PART BECAUSE NUMBA HAS PROBLEMS WITH THIS BLOCK OF CODE THAT DOES THE CALCULATION IN THE VERLET ALGORITHM, NOW IT ONLY WORKS WITH THE VELOCITY VERLET, TO FIX\"\r\n# else:\r\n# if((r2[j,c] < 4*max(R[j],R[c])) and (r2[j,c] > 10**(-2))):\r\n# dUx = dUx + dLJverlet(dx[j,c],r2[j,c],R[j],R[c]) - dwalls([X[j],Y[j]],param)\r\n# dUy = dUy + dLJverlet(dy[j,c],r2[j,c],R[j],R[c]) - dwalls([X[j],Y[j]],param)\r\n\r\n #JV: We add the energy in the corresponding array in both cases, remember that the verlet algorithm will include the energy from the walls\r\n # and that will be visible in fluctuations on the energy\r\n if(vel_verlet_on == True):\r\n if((r2[j,c] < 2*max(R[j],R[c])) and (r2[j,c] > 10**(-2))):\r\n u = u + LJverlet(r2[j,c],R[c],R[j])\r\n# else:\r\n# u = u + walls([X[j],Y[j]])#JV: TO CHANGE; NOW ONLY WORKS WITH VEL_VERLET_ON\r\n# else:\r\n# if((r2[j,c] < 2*max(R[j],R[c])) and (r2[j,c] > 10**(-2))):\r\n# u = u + LJverlet(r2[j,c],R[c],R[j],param)\r\n#\r\n# if((X[j]**2+Y[j]**2) > (0.8*L)**2):\r\n# u = u + walls([X[j],Y[j]],param)\r\n #JV: COMMENTED FOR NOW\r\n\r\n #JV: If the argument it's True, we will append the energy to our corresponding array\r\n if(append == True):\r\n utot[j] = u\r\n\r\n f[j,:] = f[j,:]+np.array([dUx,dUy])\r\n\r\n if(append == True):\r\n U[int(i)] = np.sum(utot) #JV: Finally, we add the total energy so we have the global energy in a step of time\r\n\r\n return f","def solver(u,f,n=50,m=100,t0=0,t1=1000,dt=.1,nu=1):\n \n u_new=[[u[i][j] for j in range(m)]for i in range(n)]\n loopCounter=t0\n while(loopCounter<=t1):\n for i in xrange(1,n-1):\n for j in xrange(1,m-1):\n u_new[i][j]=u[i][j] + dt * (nu*u[i-1][j] + nu*u[i][j-1] - 4*nu*u[i][j] + nu*u[i][j+1] + nu*u[i+1][j] + f[i][j])\n loopCounter+=dt\n u=[[u_new[i][j] for j in range(m)]for i in range(n)]\n\n return u","def relax(self,n=1):\n # print(\"putin\", self.level.rhs.reshape(-1)[:])\n # print(\"getout\", self.solver(self.level.rhs.reshape(-1)))\n for i in range(n):\n self.level.mid[:] += (self.solver(self.level.rhs.reshape(-1)) -\n self.solver(self.stencil.eval_convolve(\n self.level.evaluable_view(self.stencil)).reshape(-1))).reshape(self.level.mid.shape)","def calculate_vn4_over_vn2(vn_data_array, outputFileName):\n vn_data_array = array(vn_data_array)\n nev = len(vn_data_array[:, 0])\n dN = real(vn_data_array[:, 0])\n Q1 = dN*vn_data_array[:, 1]\n Q2 = dN*vn_data_array[:, 2]\n Q3 = dN*vn_data_array[:, 3]\n Q4 = dN*vn_data_array[:, 4]\n Q5 = dN*vn_data_array[:, 5]\n Q6 = dN*vn_data_array[:, 6]\n\n # two-particle correlation\n N2_weight = dN*(dN - 1.)\n Q1_2 = abs(Q1)**2. - dN\n Q2_2 = abs(Q2)**2. - dN\n Q3_2 = abs(Q3)**2. - dN\n\n # four-particle correlation\n N4_weight = dN*(dN - 1.)*(dN - 2.)*(dN - 3.)\n Q1_4 = ((abs(Q1)**4.) - 2.*real(Q2*conj(Q1)*conj(Q1))\n - 4.*(dN - 2.)*(abs(Q1)**2.) + abs(Q2)**2.\n + 2*dN*(dN - 3.))\n Q2_4 = ((abs(Q2)**4.) - 2.*real(Q4*conj(Q2)*conj(Q2))\n - 4.*(dN - 2.)*(abs(Q2)**2.) + abs(Q4)**2.\n + 2*dN*(dN - 3.))\n Q3_4 = ((abs(Q3)**4.) - 2.*real(Q6*conj(Q3)*conj(Q3))\n - 4.*(dN - 2.)*(abs(Q3)**2.) + abs(Q6)**2.\n + 2*dN*(dN - 3.))\n\n # calcualte observables with Jackknife resampling method\n r1_array = zeros(nev)\n r2_array = zeros(nev)\n r3_array = zeros(nev)\n F1_array = zeros(nev)\n F2_array = zeros(nev)\n F3_array = zeros(nev)\n for iev in range(nev):\n array_idx = [True]*nev\n array_idx[iev] = False\n array_idx = array(array_idx)\n\n # C_n{4}\n C_1_4 = (mean(Q1_4[array_idx])/mean(N4_weight[array_idx])\n - 2.*((mean(Q1_2[array_idx])/mean(N2_weight[array_idx]))**2.))\n C_1_2 = mean(Q1_2[array_idx])/mean(N2_weight[array_idx])\n if C_1_4 < 0. and C_1_2 > 0.:\n v1_4 = (-C_1_4)**0.25\n v1_2 = sqrt(C_1_2)\n r1_array[iev] = v1_4/(v1_2 + 1e-15)\n F1_array[iev] = sqrt((v1_2**2. - v1_4**2.)\n /(v1_2**2. + v1_4**2. + 1e-15))\n\n C_2_4 = (mean(Q2_4[array_idx])/mean(N4_weight[array_idx])\n - 2.*((mean(Q2_2[array_idx])/mean(N2_weight[array_idx]))**2.))\n C_2_2 = mean(Q2_2[array_idx])/mean(N2_weight[array_idx])\n if C_2_4 < 0. and C_2_2 > 0.:\n v2_4 = (-C_2_4)**0.25\n v2_2 = sqrt(C_2_2)\n r2_array[iev] = v2_4/v2_2\n F2_array[iev] = sqrt((v2_2**2. - v2_4**2.)\n /(v2_2**2. + v2_4**2. + 1e-15))\n\n C_3_4 = (mean(Q3_4[array_idx])/mean(N4_weight[array_idx])\n - 2.*((mean(Q3_2[array_idx])/mean(N2_weight[array_idx]))**2.))\n C_3_2 = mean(Q3_2[array_idx])/mean(N2_weight[array_idx])\n if C_3_4 < 0. and C_3_2 > 0.:\n v3_4 = (-C_3_4)**0.25\n v3_2 = sqrt(C_3_2)\n r3_array[iev] = v3_4/v3_2\n F3_array[iev] = sqrt((v3_2**2. - v3_4**2.)\n /(v3_2**2. + v3_4**2. + 1e-15))\n\n r1_mean = mean(r1_array)\n r1_err = sqrt((nev - 1.)/nev*sum((r1_array - r1_mean)**2.))\n r2_mean = mean(r2_array)\n r2_err = sqrt((nev - 1.)/nev*sum((r2_array - r2_mean)**2.))\n r3_mean = mean(r3_array)\n r3_err = sqrt((nev - 1.)/nev*sum((r3_array - r3_mean)**2.))\n\n F1_mean = mean(F1_array)\n F1_err = sqrt((nev - 1.)/nev*sum((F1_array - F1_mean)**2.))\n F2_mean = mean(F2_array)\n F2_err = sqrt((nev - 1.)/nev*sum((F2_array - F2_mean)**2.))\n F3_mean = mean(F3_array)\n F3_err = sqrt((nev - 1.)/nev*sum((F3_array - F3_mean)**2.))\n\n results = [r1_mean, r1_err, F1_mean, F1_err,\n r2_mean, r2_err, F2_mean, F2_err,\n r3_mean, r3_err, F3_mean, F3_err]\n f = open(outputFileName, 'w')\n f.write(\"# n vn{4}/vn{2} (vn{4}/vn{2})_err Fn Fn_err\\n\")\n f.write(\"# Fn = sqrt((vn{2}^2 - vn{4}^2)/(vn{2}^2 + vn{4}^2))\\n\")\n for i in range(1, 4):\n f.write(\"%d %.10e %.10e %.10e %.10e\\n\"\n % (i, results[4*i - 4], results[4*i - 3],\n results[4*i - 2], results[4*i-1]))\n f.close()\n return","def relax(self, n=1):\n\n for i in range(n):\n rhs = self.lvl.rhs - self.st_minus.eval_convolve(self.evaluable_view, self.convolve_control)\n self.lvl.mid[:] = self.l_plus_solver(rhs.reshape(-1)).reshape(self.lvl.mid.shape)","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 SSA(self,N=1,q=12):\n\n X = self.data[self.IDs]\n X = np.flip(X.T[(np.arange(q))+np.arange(np.max(self.dimT-(q-1),0)).reshape(-1,1)].reshape(self.dimT-q+1,self.n*q).T,0)\n U,S,V = np.linalg.svd(X,full_matrices=False)\n\n EEOFs = np.zeros((self.dimX,self.dimY,self.dimT,N))\n X_rec = np.zeros((self.n,self.dimT,self.dimT-q+1))\n for k in range(self.dimT-q+1):\n Xk = S[k]*np.dot(np.atleast_2d(U[:,k]).T,np.atleast_2d(V.T[:,k]))\n offset1 = 0\n offset2 = 1\n for t in range(self.dimT):\n if t == 0:\n X_rec[:,t,k] = Xk[-self.n:,0]\n elif (t > 0) & (t < q-1):\n x_kj = np.zeros((self.n,t+1))\n start = self.n*q - (t+1)*self.n\n for l in range(t+1):\n x_kj[:,l] = Xk[start:start+self.n,l]\n start += self.n\n X_rec[:,t,k] = np.mean(x_kj,1)\n elif (t >= q-1) & (t <= self.dimT-q):\n x_kj = np.zeros((self.n,q))\n start = 0\n for l in range(offset1,q+offset1):\n x_kj[:,l-offset1] = Xk[start:start+self.n,l]\n start += self.n\n offset1 += 1\n X_rec[:,t,k] = np.mean(x_kj,1)\n elif (t > self.dimT-q) & (t < self.dimT-1):\n x_kj = np.zeros((self.n,q-offset2))\n start = 0\n for l in range(offset1,(q-offset2)+offset1):\n x_kj[:,l-offset1] = Xk[start:start+self.n,l]\n start += self.n\n offset1 += 1\n offset2 += 1\n X_rec[:,t,k] = np.mean(x_kj,1)\n elif t == self.dimT-1:\n X_rec[:,t,k] = Xk[:self.n,-1]\n\n EEOFs[self.IDs] = (np.flip(X_rec,0)/self.weights[self.IDs][:,np.newaxis,np.newaxis])[:,:,:N]\n \n return EEOFs","def IterateValues(self):\n agrid = self.agrid\n self.w = self.setwage(self.K, self.N)\n self.r = self.setrate(self.K, self.N)\n self.b = self.benefit(self.N)\n\n for l in range(self.Na): \n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\n self.v[-1][l] = self.util(self.c[-1][l],0)\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\n\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\n m0 = 0 \n for l in range(self.Na):\n # Find a bracket within which optimal a' lies\n m = max(0, m0-1)\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\n # Define objective function for optimal a'\n def objfn(a1):\n v = self.value(y, agrid[l], a1)\n return -v\n # Find optimal a' using Golden Section Search\n if a == b:\n self.a[y][l] = 0\n elif b == c:\n self.a[y][l] = agrid[-1]\n else:\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\n #‘Brent’,‘Bounded’,‘Golden’\n self.a[y][l] = result.x\n # Computing consumption and labor\n if y >= -self.R:\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\n else:\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')","def calculate_posvij_matrices(main_tetrad_ark):\n\n # Import all the possible solutions to the Vij matrices\n vij_possibilities = matrix_outerprod_calc.illuminator_of_elfes()\n vij_matrices = []\n\n print(\" \")\n print(\" Calculating Vij matrices\")\n print(\" \")\n # for i in range(0, len(main_tetrad_ark)):\n for i in range(0, len(vij_possibilities)):\n tet_i = [x[1] for x in main_tetrad_ark[i]]\n tri_tet = [np.transpose(i) for i in tet_i]\n print(\"# ********************************\")\n # print(\" \")\n print(\"MATRIX i: \", i)\n print(\" \")\n for j in range(0, len(main_tetrad_ark)):\n tet_j = [x[1] for x in main_tetrad_ark[j]]\n trj_tet = [np.transpose(j) for j in tet_j]\n vij_temp = []\n # print(\"# ********************************\")\n print(\" \")\n print(\"MATRIX j: \", j)\n temp_zero = np.zeros((4,4), dtype=int)\n for x in range(0,len(tet_i)):\n test_1half = np.dot(tri_tet[x],tet_j[x])\n test_2half = np.dot(trj_tet[x],tet_i[x])\n test_difs = np.subtract(test_1half, test_2half)\n # print(\" \")\n # print(test_difs)\n temp_mat = np.dot(tri_tet[x],tet_j[x]) - np.dot(trj_tet[x],tet_i[x])\n vij_temp.append(temp_mat)\n # print(\"\")\n temp_add1 = np.add(vij_temp[0], vij_temp[1])\n temp_add2 = np.add(temp_add1, vij_temp[2])\n tempf = np.add(temp_add2, vij_temp[3])\n # tempf = np.divide(temp_add3, 2)\n for ijx in vij_possibilities:\n if np.array_equal(temp_addf, ijx[0]):\n print(\"*************$$$$$$$$$$$$$$$$$$***************** \")\n print(\"l-solution found:\", ijx[1])\n print(temp_addf)\n print(\"\")\n print(ijx[0])\n if np.array_equal(temp_addf, temp_zero):\n pass\n else:\n vij_matrices.append(temp_addf)\n # print(\"\")\n print(temp_addf)\n # vij_matrices.append(temp_addf)\n vijmats_size = sys.getsizeof(vij_matrices)\n print(\"Size of Vij Matrices list: bytes / kilobytes:\", vijmats_size, vijmats_size/1024)\n print(\"Length of Vij Matrices\")\n print(len(vij_matrices))\n print(vij_matrices)\n pass","def f(t, x, n, v):\n total = 0\n for i in range(n+1):\n for j in range(n+1):\n for k in range(v):\n total = t[i][j] * x[i][j][k]","def test_large_sum(self):\n for n in [10, 20, 30, 40, 50]:\n A = np.arange(n*n)\n A = np.reshape(A, (n, n))\n x = Variable(n, n)\n p = Problem(Minimize(at.sum_entries(x)), [x >= A])\n result = p.solve()\n answer = n*n*(n*n+1)/2 - n*n\n print(result - answer)\n self.assertAlmostEqual(result, answer)","def eigenvalue_analysis(*, dates, obs_data, model_data, residuals,\n proxy_number=1):\n # Create a masked version of the residuals array so that we can perform the\n # PCA ignoring all nan values\n masked_residuals = np.ma.array(residuals, mask=np.isnan(residuals))\n\n # Calculate the covariance matrix of the masked residuals array\n covariance_matrix = np.ma.cov(masked_residuals, rowvar=False,\n allow_masked=True)\n # Calculate the eigenvalues and eigenvectors of the covariance matrix\n eig_values, eig_vectors = np.linalg.eigh(covariance_matrix)\n # Sort the eigenvalues in decreasing order\n idx = np.argsort(np.abs(eig_values))[::-1]\n eig_values = eig_values[idx]\n # Sort the eigenvectors according to the same index\n eig_vectors = eig_vectors[:, idx]\n\n # Project the residuals onto the eigenvectors\n projected_residuals = np.ma.dot(masked_residuals, eig_vectors)\n\n # Use the method of Cox et al (2018) to remove unmodelled external\n # signal in the SV residuals. The variable 'proxy' contains the sum\n # of the SV residuals projected into the number of dominant PCs\n # specified by proxy_number\n\n corrected_residuals = []\n\n if proxy_number == 1:\n noisy_direction = eig_vectors[:, 0]\n proxy = projected_residuals[:, 0]\n for idx in range(len(proxy)):\n corrected_residuals.append(\n masked_residuals.data[idx, :] - proxy[idx] * noisy_direction)\n # Apply the denoising algorithm to each of the PCs specified\n elif proxy_number > 1:\n noisy_direction = eig_vectors[:, 0:proxy_number]\n proxy = np.sum(projected_residuals[:, 0:proxy_number], axis=1)\n for idx in range(len(projected_residuals[:, 0])):\n corrected = masked_residuals.data[idx, :]\n for direction in range(proxy_number):\n corrected = corrected - projected_residuals[idx, direction] \\\n * noisy_direction[:, direction]\n corrected_residuals.append(corrected)\n\n corrected_residuals = pd.DataFrame(corrected_residuals,\n columns=obs_data.columns)\n # Re-form the SV from the denoised residuals\n denoised_sv = pd.DataFrame(\n corrected_residuals.values + model_data.values,\n columns=obs_data.columns)\n\n denoised_sv.insert(0, 'date', dates)\n\n return denoised_sv, proxy, np.abs(eig_values), eig_vectors,\\\n projected_residuals, corrected_residuals.astype('float'),\\\n covariance_matrix","def test_basic_newton_finder(self):\n forwards = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\n strikes = np.array([1.0, 2.0, 1.0, 0.5, 1.0, 1.0])\n expiries = np.array([1.0, 1.0, 1.0, 1.0, 0.5, 2.0])\n discounts = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\n init_vols = np.array([2.0, 0.5, 2.0, 0.5, 1.5, 1.5])\n option_signs = np.array([1.0, 1.0, -1.0, -1.0, 1.0, 1.0])\n volatilities = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\n prices = np.array([\n 0.38292492, 0.19061012, 0.38292492, 0.09530506, 0.27632639, 0.52049988\n ])\n results = implied_vol(\n forwards,\n strikes,\n expiries,\n discounts,\n prices,\n option_signs,\n initial_volatilities=init_vols,\n max_iterations=100)\n implied_vols, converged, failed = self.evaluate(results)\n num_volatilities = len(volatilities)\n self.assertAllEqual(np.ones(num_volatilities, dtype=np.bool), converged)\n self.assertAllEqual(np.zeros(num_volatilities, dtype=np.bool), failed)\n self.assertArrayNear(volatilities, implied_vols, 1e-7)","def _relax_matrix(self, n=1):\n\n for i in range(n):\n self.level.mid.reshape(-1)[:] = self.R_w.dot(self.level.mid.reshape(-1)) \\\n + self.omega * self.level.rhs / self.D","def main(n = 150000, quiet = False):\n t0 = time() #timing possibility\n\n if quiet:\n output_stream = StringIO()\n else:\n output_stream = sys.stdout\n\n\n print(t0,file=output_stream)\n \n\n sfr = .01\n # star mass function\n kroupa = np.vectorize(functions.kroupa)\n mf = dist.Distribution(kroupa, .1, 50.)\n\n #star formation history\n constant_sfr = np.vectorize(functions.constant_sfr)\n \n ages = np.logspace(5,7,7)\n sf = [dist.Distribution(constant_sfr, 1000., ages[i]) for i in range(len(ages))]\n #sfr = [150000*mf.mean()/(ages[i]-1000.) for i in range(len(ages))]\n\n t1 = time() # finished reading the distributions\n print(t1,file=output_stream)\n\n\n # setting up model data\n aperas = np.logspace(2, 5, 4)\n avs = np.linspace(10.0, 50.0, 5)\n l = 1\n mpold, tmpnew = 0., time()\n parameters = []\n for i in range(len(avs)):\n for j in range(len(aperas)):\n for k in range(len(ages)):\n tmpold, tmpnew = tmpnew, time()\n starformation.main(massfunction = mf, starformationhistory = sf[k], \\\n A_v = avs[i], sfr = n, apera = aperas[j], maxage = ages[k], \\\n appendix = \"%s_%03d_%06d_%09d\" % ('sim',avs[i],aperas[j],ages[k]), quiet=True, precise=False)\n print(avs[i],aperas[j],ages[k], l/len(avs)/len(aperas)/len(ages), (len(avs)*len(aperas)*len(ages)-l)*(tmpnew-tmpold),file=output_stream)\n l = l+1\n \n parameters.append([avs[i],aperas[j],ages[k]])\n\n t2 = time() # end of simulation\n print(t2, t1, t2-t1)\n \n print ('number of simulations run: %s' %l , file=output_stream) \n head = ['#','AV', 'Aperature_size', 'Age']\n f = open('out/__head', 'w')\n f.write( ','.join(head)+'\\n' )\n np.savetxt(f, parameters)\n f.close()\n\n t3 = time() # end of saving data\n\n analysis.main('out')\n print ('analysis complete' , file=output_stream) \n \n t4 = time() # end of analysing data\n\n\n\n print( 'starting script at %f' %(t0), file=output_stream)\n print( 'initializing %f' %(t1-t0), file=output_stream)\n print( \"running simulation %f\" %(t2-t1), file=output_stream)\n print( \"writing data %f\" %(t3-t2), file=output_stream)\n print( \"analysing data %f\" %(t4-t3), file=output_stream)\n print( \"________________________\", file=output_stream)\n print( \"total runtime %f\" %(t4-t0), file=output_stream)\n print( \"finishing script %f\" %t4, file=output_stream)","def test_convergence(self, nMax=500000, withPlots=True, overStep=100):\n\n def _mad(vin):\n med = np.median(vin)\n return np.median(np.abs(vin - med))\n\n self.convergenceSearchFlag = True\n self.needReset = False\n self._reset_limits()\n mStart = 10\n mStep = 1\n statStep = 5\n m = 0\n k = mStart\n converged = False\n postConv = 0\n pltout = []\n dIout = []\n Iold = 0\n sE = self.E_max * np.ones(1)\n sTheta_max = self.Theta_max * np.ones(1)\n sPsi_max = self.Psi_max * np.ones(1)\n\n statOut = []\n dIOut = []\n xm = []\n\n outQuad = 0\n outInt = 0\n if withPlots:\n from matplotlib import pyplot as plt\n fig = plt.figure(figsize=(8, 6))\n\n ax0 = fig.add_axes([0.1, 0.65, 0.8, 0.3])\n ax0.xaxis.set_visible(False)\n ax0.set_ylabel('Relative intensity $I$', color='C0')\n ampLine, = ax0.semilogy([], [], 'C0')\n\n ax1 = fig.add_axes([0.1, 0.1, 0.8, 0.55])\n ax1.set_xlabel('Number of nodes')\n ax1.set_ylabel('Median absolute deviation of $I$', color='C1')\n madLine, = ax1.semilogy([], [], 'C1')\n\n ax2 = ax1.twinx()\n ax2.set_ylabel('Median $dI/I$', color='C2')\n relmadLine, = ax2.semilogy([], [], 'C2')\n else:\n fig = None\n\n while True:\n m += 1\n if m % 1000 == 0:\n mStep *= 2\n if True: # raycing._VERBOSITY_ > 10:\n # print(\"INSUFFICIENT CONVERGENCE RANGE:\", k, \"NODES\")\n print(\"INCREASING CONVERGENCE STEP. NEW STEP\", mStep)\n\n k += mStep\n self.quadm = k\n self._build_integration_grid()\n xm.append(k*self.gIntervals)\n Inew = self.build_I_map(sE, sTheta_max, sPsi_max)[0]\n pltout.append(Inew)\n dIout.append(np.abs(Inew-Iold)/Inew)\n if m == 1:\n Iold = Inew\n continue\n Iold = Inew\n\n if withPlots:\n ampLine.set_xdata(xm)\n relInt = np.array(pltout)\n relInt /= relInt.max()\n ampLine.set_ydata(relInt)\n new_y_min = np.floor(np.log10(relInt.min()))\n ax0.set_xlim([0, xm[-1]+5])\n ax0.set_ylim([10**(new_y_min+0.1), 1.1])\n\n if converged:\n postConv += 1\n if m > statStep:\n mad = _mad(np.abs(np.array(pltout))[m-statStep:m])\n dIMAD = np.median(dIout[m-statStep:m])\n\n statOut.append(mad)\n dIOut.append(dIMAD)\n\n if ((dIMAD < self.gp) or (mad < self.gp)) and not converged:\n convPoint = k*self.gIntervals\n outQuad = k\n outInt = self.gIntervals\n if True: # raycing._VERBOSITY_ > 10:\n print(\"CONVERGENCE THRESHOLD REACHED AT \"\n \"{0} NODES, {1} INTERVALS.\".format(\n k, self.gIntervals))\n print(\"INTEGRATION GRID LENGTH IS {} POINTS\".format(\n convPoint))\n converged = True\n if withPlots:\n label = 'True convergence: {0} nodes, {1} interval{2}'\\\n .format(self.quadm, self.gIntervals,\n '' if self.gIntervals == 1 else 's')\n axvlineDict = dict(x=convPoint, color='r', label=label)\n ax0.axvline(**axvlineDict)\n ax1.axvline(**axvlineDict)\n if withPlots:\n new_y_max = np.ceil(np.log10(max(statOut)))\n new_y_min = np.floor(np.log10(min(statOut)))\n ax1.set_xlim([0, xm[-1]+5])\n ax1.set_ylim([10**new_y_min, 10**(new_y_max-0.1)])\n madLine.set_xdata(xm[statStep:])\n madLine.set_ydata(statOut)\n relmadLine.set_xdata(xm[statStep:])\n relmadLine.set_ydata(dIOut)\n new_y_max = np.ceil(np.log10(max(dIOut)))\n new_y_min = np.floor(np.log10(min(dIOut)))\n ax2.set_xlim([0, xm[-1]+5])\n ax2.set_ylim([10**new_y_min, 10**new_y_max])\n fig.canvas.draw()\n plt.pause(0.001)\n\n if xm[-1] > nMax:\n if not converged:\n print(\"PROBLEM WITH CONVERGENCE. INCREASE nMax.\")\n break\n\n if overStep is not None:\n if postConv > overStep:\n break\n\n convRes, stats = self._find_convergence_mixed()\n print(\"CONVERGENCE TEST COMPLETED.\")\n self.needReset = True\n if withPlots:\n label = 'Auto-finder: {0} nodes, {1} interval{2}'.format(\n self.quadm, self.gIntervals,\n '' if self.gIntervals == 1 else 's')\n axvlineDict = dict(x=self.quadm*self.gIntervals, color='m',\n linestyle='--', label=label)\n ax0.axvline(**axvlineDict)\n ax1.axvline(**axvlineDict)\n ax1.legend()\n fig.canvas.draw()\n plt.pause(0.1)\n return converged, outQuad, outInt, fig","def sqrtm_loop(Rarr, Tarr, n):\n\n # C code\n code = \"\"\"\n int j = 0, i = 0, k = 0;\n std::complex<double> s;\n for (j = 0; j < n; ++j) {\n Rarr(j,j) = sqrt(Tarr(j,j));\n for (i = j-1; i > -1; --i) {\n s = 0.0;\n for (k = i+1; k < j; ++k) {\n s += Rarr(i,k) * Rarr(k,j);\n }\n Rarr(i,j) = (Tarr(i,j) - s) / (Rarr(i,i) + Rarr(j,j));\n }\n }\n return_val = 0;\n \"\"\"\n return wv.inline(code,['Rarr','Tarr', 'n'],type_converters=wv.converters.blitz)","def alternative_iterative_method(x0, n, gamma, b):\n # Parameters:\n MAX_ITER = 1000\n n2 = n**2\n\n # Creating NxN versions of vector for easier indexing during iteration\n b = b.copy().reshape(n, n)\n b_transposed = b.copy().T\n x0 = x0.copy().reshape(n, n)\n x0_transposed = x0.copy().T\n x1 = x0.copy()\n x1_transposed = x0_transposed.copy()\n\n # No need for M, N, only a smaller tridiagonal system:\n H = scipy.sparse.diags((-1, 2, -1), (-1, 0, 1), shape=(n, n), format=\"csr\")\n gammaI = scipy.sparse.diags((gamma,), (0,), shape=(n, n), format=\"csr\")\n M1 = gammaI + H # Corresponds to both (gI + M) & (gI + N) in equations\n M2 = gammaI - H # Corresponds to both (gI - M) & (gI - N) in equations\n\n # Preallocating RHS of equations\n RHS7 = np.zeros((n, n), dtype=np.float64)\n RHS8 = np.zeros((n, n), dtype=np.float64)\n\n k = 0\n while k < MAX_ITER:\n for i in range(n): # Loading RHS values for Equation (7):\n RHS7[:, i] = scipy.sparse.csr_matrix.dot(M2, x0_transposed[i]) + b_transposed[i]\n for i in range(n): # Solving N independent tridig mat systems related to Eq(7):\n x1[i] = scipy.sparse.linalg.spsolve(M1, RHS7[i])\n RHS8[i] = scipy.sparse.csr_matrix.dot(M2, x1[i]) + b[i] # Loading RHS values for Equation (8):\n for i in range(n): # Solving N independent tridig mat systems related to Eq(8):\n x1_transposed[i] = scipy.sparse.linalg.spsolve(M1, RHS8[:, i])\n\n k += 1\n if np.allclose(x1_transposed, x0_transposed, rtol=1e-8):\n break\n x0_transposed = x1_transposed.copy()\n\n res = x1_transposed.T.reshape(n2)\n return res, k","def SOR_Solve_Opt(A,b,tol=1.0e-6,max_iterations=100,LOUD=False):\n [Nrow, Ncol] = A.shape\n assert Nrow == Ncol\n N = Nrow\n converged = False\n iteration = 1\n omega = 1\n l = 5\n p = 2\n x = np.random.rand(N) #random initial guess \n x_new = np.zeros(N)\n while not(converged):\n x = x_new.copy() #replace old value\n for row in range(N):\n x_new[row] = b[row]\n for column in range(N):\n if column != row:\n x_new[row] -= A[row,column]*x_new[column]\n x_new[row] /= A[row,row]\n x_new[row] = (1.0-omega) * x[row] + omega*x_new[row]\n relative_change = np.linalg.norm(x_new-x)/np.linalg.norm(x_new)\n #record change after iteration k\n if (l==iteration):\n dxl = np.linalg.norm(x_new-x)\n if (l + p == iteration):\n dxlp = np.linalg.norm(x_new-x)\n omega = 2.0/(1.0+np.sqrt(1-(dxlp/dxl)**(1.0/p)))\n if (LOUD):\n print(\"Iteration\",iteration,\": Relative Change =\",relative_change)\n if (relative_change < tol) or (iteration >= max_iterations):\n converged = True\n iteration += 1\n return x_new","def potentialSolver(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 # solve potential\n for it in np.arange(1,max_it+1):\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 #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 #check for convergence*/\n if it%25==0:\n sum = 0;\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 R = -self.phi[i][j][k]*(2*dx2+2*dy2+2*dz2) +\\\n 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])\n\n sum += R*R;\n\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 question27():\n global conv_residuals\n def catch(r):\n \"\"\"Helper function to retrieve residual + steps to convergence for\n GMRES operation in Scipy. Used as a callback function for\n scipy.sparse.linalg.gmres\n \"\"\"\n global conv_residuals\n conv_residuals.append(r)\n return\n\n def iterate(rk):\n \"\"\" Preconditioner Function for GMRES.\"\"\"\n y = scipy.sparse.linalg.spsolve(P1, rk)\n RHS = scipy.sparse.csr_matrix.dot(P4, y) + rk\n zk = scipy.sparse.linalg.spsolve(P3, RHS)\n return zk\n\n\n N_search = np.array([20, 40, 60, 80, 100, 120, 140, 160, 180])\n steps_till_conv_N = np.zeros(N_search.size)\n\n fig271 = plt.figure(figsize=(13, 8))\n\n for i, n in enumerate(N_search):\n n2 = n**2\n A = construct_matrix_A(n)\n b = np.random.randn(n2)\n M, N = construct_M_N(n)\n mu_max = scipy.sparse.linalg.eigs(M, k=1, which='LM', return_eigenvectors=False)[0].real\n mu_min = scipy.sparse.linalg.eigs(M, k=1, which='SM', return_eigenvectors=False)[0].real\n gamma = np.sqrt(mu_max*mu_min)\n gammaI = scipy.sparse.diags((gamma,), (0,), shape=(n2, n2), format=\"csr\")\n P1 = gammaI + M\n P2 = gammaI - N\n P3 = gammaI + N\n P4 = gammaI - M\n M = scipy.sparse.linalg.LinearOperator((n2, n2), matvec=iterate)\n conv_residuals = []\n x = scipy.sparse.linalg.gmres(A, b, M=M, callback=catch)\n steps_till_conv_N[i] += len(conv_residuals)\n n_steps = len(conv_residuals)\n plt.semilogy(range(n_steps), conv_residuals, label=f\"N = {n}\")\n\n plt.xlabel(\"Steps Required for Convergence\")\n plt.ylabel(\"Residuals\")\n plt.title(\"Figure 271 - GMRES + Preconditioner Residuals for Varying N\", fontsize=13)\n plt.legend()\n plt.grid()\n plt.savefig(f\"figures/figure271.png\")\n plt.show()\n\n\n fig270 = plt.figure(figsize=(13, 8))\n plt.plot(N_search, steps_till_conv_N)\n plt.xlabel(\"N\")\n plt.ylabel(\"Steps until convergence\")\n plt.title(\"Figure 270 - GMRES + Preconditioner Convergence Required for Varying N\", fontsize=13)\n plt.grid()\n plt.savefig(f\"figures/figure270.png\")\n plt.show()\n return","def get_mat_n(T_e, r_0, M, N, E, g_e, R_h, tmpN_t, tmpN_max):\n mat_n = np.zeros((M, len(T_e))) # matrix for the result\n for i in range(len(T_e)):\n R_e = get_R_e(E, M, g_e, T_e[-i-1]) # matrix with transition rates (env)\n #print get_R_e_test(E, M, g_e, T_e, R_e, 10e-15)\n R = get_R(R_e, R_h) # total transition rates\n data = (R, M, N) # arguments for fsolve \n #-----------solve the nonlinear system of equations-------------------- \n solution = fsolve(func, r_0,args=data, full_output=1)\n if solution[2] == 0: # if sol. didnt conv., repeat calcul.\n print i\n else:\n n1 = get_n1(solution[0],N) # occupation number of the ground state\n n = np.zeros(M) # vector of all occupation numbers\n n[0], n[1:] = n1 , solution[0] \n if np.any(n<0.): # if solution is unphysical \n print \"Needed to repeat calculation at Temperature T_e =\", T_e[-i-1] \n n = get_cor_n(i, T_e, r_0, M, N, E, g_e, R_h, tmpN_t, tmpN_max)\n if n == None:\n print \"Calculation failed! You may choose a larger tmpN_max.\"\n break\n else:\n r_0 = n[1:]\n else:\n r_0 = solution[0]\n mat_n[:,-i-1] = n\n return mat_n","def multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \"north\"):\n inds = self.mlat_finder(lat1, lat0, pole)[1]\n NeA = self.NeA[inds]\n NeB = self.NeB[inds]\n NeC = self.NeC[inds]\n\n secondsA = self.secondsA[inds]\n secondsB = self.secondsB[inds]\n secondsC = self.secondsC[inds]\n\n\n mlatA = self.mlatA[inds]\n mlatB = self.mlatB[inds]\n mlatC = self.mlatC[inds]\n\n mean_range = 5\n NeA = self.meanie(NeA, mean_range)\n NeB = self.meanie(NeB, mean_range)\n NeC = self.meanie(NeC, mean_range)\n \n \n N = int((len(NeA)/n*2) - 1) #nr of windows\n \n dx = (secondsB[1]-secondsB[0])*self.velB[0]\n \n nBAs = []\n nBCs = []\n nACs = []\n \n for i in range(N):\n startind = int(i/2*n)\n stopind = int((i/2+1)*n)\n temp_NeA = NeA[startind:stopind]\n temp_NeB = NeB[startind:stopind]\n temp_NeC = NeC[startind:stopind]\n \n temp_secondsA = secondsA[startind:stopind]\n temp_secondsB = secondsB[startind:stopind]\n temp_secondsC = secondsC[startind:stopind]\n \n \n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\n if np.sum(curr_timediff) > 2:\n continue\n \n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\n \n if np.max(gradA) < 0.9:\n continue\n \n stdA = np.std(gradA)\n stdB = np.std(gradB)\n stdC = np.std(gradC)\n \n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\n \n p0A = [1, meanA, stdA]\n p0B = [1, meanB, stdB]\n p0C = [1, meanB, stdB]\n \n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\n \n nBA = poptB[1] - poptA[1]\n nBC = poptB[1] - poptC[1]\n nAC = poptA[1] - poptC[1]\n \n nBAs.append(nBA)\n nBCs.append(nBC)\n nACs.append(nAC)\n \n \n sBA = self.BA_shift/2 #time delay BA\n sBC = self.BC_shift/2 #time delay BC\n sAC = (self.BC_shift - self.BA_shift)/2\n V = self.velA[0]\n for i in range(len(nBAs)):\n VBA = self.along_track_velo(V, sBA, nBAs[i])\n VBC = self.along_track_velo(V, sBC, nBCs[i])\n VAC = self.along_track_velo(V, sAC, nACs[i])\n \n print(VBA)\n print(VBC)\n print(VAC)\n print(\"________________________________________\")","def mr(A, n_iterations, stop=False):\n assert len(A.sizes) == 2\n assert A.sizes[0] == A.sizes[1]\n M = A.same_shape()\n n = A.sizes[0]\n @for_range(n)\n def _(i):\n e = sfix.Array(n)\n e.assign_all(0)\n e[i] = 1\n M[i] = solve_linear(A, e, n_iterations, stop=stop)\n return M.transpose()","def mbieLoop (self) :\n self.iterCnt = 0\n while self.iterCnt < 5000:\n s = self.mdp.s0\n for h in range(self.H) :\n self.QUpper = QBoundsSolver(self.mdp, self.PHat, self.QUpper, self.Ntotal, 0.1, True, self.stop)\n a = np.argmax(self.QUpper[s])\n s_, self.R[s,a] = self.mdp.step(s, a)\n self.updateVisitStatistics(s, a, s_)\n s = s_\n\n if self.iterCnt % 10 == 0: \n print(self.iterCnt)\n print(self.QUpper)\n\n self.iterCnt += 1","def dp_alex(v_space, num_frames_r, num_frames_q, bov_flag, prev_ref=5,\n next_ref=0):\n t1 = float(cv2.getTickCount())\n\n common.DebugPrint(\"Entered dp_alex(): Running dynamic programming...\")\n\n r, c, d = v_space.shape\n\n # We substitute all NaN's of v_space\n for i in range(d):\n v_temp = v_space[:, :, i]\n v_temp[np.isnan(v_temp)] = 0\n v_space[:, :, i] = v_temp\n\n vv = np.zeros((r, c))\n for j in range(d):\n vv += v_space[:, :, j]\n\n # Checking that vv has positive elements\n assert np.nonzero(vv < 0.0)[0].size == 0\n\n print_matrices = True\n\n if common.MY_DEBUG_STDOUT and print_matrices:\n print(\"dp_alex(): r = %d, c = %d\" % (r, c))\n print(\"dp_alex(): vv = \\n%s\" % str(vv))\n sys.stdout.flush()\n\n D = np.zeros((r, c))\n tback = np.zeros((r, c))\n\n for ref in range(r):\n D[ref, 0] = vv[ref, 0]\n tback[ref, 0] = -1\n\n for qry in range(1, c):\n for ref in range(r):\n # We enumerate a few reference frames to find the one with\n # highest votes\n lb = ref - prev_ref\n ub = ref + next_ref\n\n if lb < 0:\n lb = 0\n if lb >= r:\n lb = r - 1\n\n if ub < 0:\n ub = 1\n if ub >= r:\n ub = r - 1\n\n max_pos = lb\n for i in range(lb + 1, ub + 1):\n \"\"\"\n We use <= --> we break ties by going forward in the\n reference video (incrementing the reference frame for\n the next query frame).\n \"\"\"\n if D[max_pos, qry - 1] <= D[i, qry - 1]:\n max_pos = i\n # max_pos is the maximum vote reference frame for query frame qry\n\n D[ref, qry] += D[max_pos, qry - 1] + vv[ref, qry]\n tback[ref, qry] = max_pos\n\n if common.MY_DEBUG_STDOUT and print_matrices:\n print(\"D = \\n%s\" % str(D))\n print(\"tback = \\n%s\" % str(tback))\n\n crossref = np.zeros((num_frames_q, 2))\n\n # Find max-cost path (the critical path) for the last query frame:\n max_pos = 0\n for ref in range(1, r):\n \"\"\"\n We use <= --> we break ties by going forward in the\n reference video (incrementing the reference frame for\n the next query frame) - debatable if this is a good idea!!!!TODO.\n \"\"\"\n if D[max_pos, c - 1] <= D[ref, c - 1]:\n max_pos = ref\n print(\"max_pos = %d\" % max_pos)\n\n print(\"dp_alex(): cost critical path = %s\" % str(D[max_pos, c - 1]))\n\n pos_ref = max_pos\n for qry in range(c - 1, 0-1, -1):\n crossref[qry][0] = qry\n crossref[qry][1] = pos_ref\n\n common.DebugPrint(\"qry=%d, pos_ref=%d\" % (qry, pos_ref))\n pos_ref = tback[pos_ref, qry]\n\n # time took\n common.DebugPrint(\"dp_alex(): crossref = %s\" % str(crossref))\n compute_cost(crossref, vv, \"crossref_dp_Alex.txt\")\n # TODO: assert cost computed is = D[max_pos,...]\n\n t2 = float(cv2.getTickCount())\n my_time = (t2 - t1) / cv2.getTickFrequency()\n print(\"dp_alex() took %.6f [sec]\" % my_time)\n\n y = None\n x = None\n return y, x, D, tback, crossref","def runLinAdvec():\n # Courant number \n c = 0.4\n #just run and print, for two different Courant numbers\n main(50, 50, c, displayResults = True)\n main(400, 400, c, displayResults = True)\n print(\"\\n\")\n # run order of convergence tests\n runErrorTests(c, 50, 300, stepNx=50, display=True)\n # run timing tests\n runTimingTests(c, 50, 600, stepNx=50, displayResults=True)\n # check monotonicity\n checkMonotonicity(50, 50, c, displayResults = True)\n # check mass/variance conservation\n checkConservation(200, 200, c, display=True)","def compute(self): \n Ex=np.zeros((self.nx,self.ny+1))\n Ey=np.zeros((self.nx+1,self.ny))\n Hz=np.zeros((self.nx,self.ny))\n Hzx=np.zeros((self.nx,self.ny))\n Hzy=np.zeros((self.nx,self.ny))\n \n imx = []\n #eps, mu = self.makeenv()\n mu=np.ones((self.nx,self.ny))*const.mu_0\n eps = self.luneberg(int(self.nx/2), int(self.ny*2/3), self.R)\n eps[:20,:] *= self.q #adself.ds a space of higher permittivity \n eps[-20:,:] *= self.q #adself.ds a space of higher permittivity \n eps[:,:20] *= self.q #adself.ds a space of higher permittivity \n eps[:,-20:] *= self.q #adself.ds a space of higher permittivity \n\n c = self.dt/(eps*self.ds)\n d = self.dt/(mu* self.ds)\n \n sigma = self.pml(eps, mu, 20)\n cax = 1 - (sigma[0] * self.dt / eps)\n cay = 1 - (sigma[1] * self.dt / eps)\n dax = 1 - (sigma[2] * self.dt / mu) \n day = 1 - (sigma[3] * self.dt / mu)\n \n bar = progressbar.ProgressBar()\n for n in bar(range(self.nt+1)):\n Ex[:,1:-1] = (cay[:,1:]+cay[:,:-1])/2*Ex[:,1:-1] + (c[:,1:]+c[:,:-1])/2*(Hz[:,1:]-Hz[:,:-1])\n Ey[1:-1,:] = (cax[1:,:]+cax[:-1,:])/2*Ey[1:-1,:] - (c[1:,:]+c[:-1,:])/2*(Hz[1:,:]-Hz[:-1,:])\n \n Hzx = dax*Hzx - d*(Ey[1:,:] - Ey[:-1,:])\n Hzy = day*Hzy + d*(Ex[:,1:] - Ex[:,:-1]) \n Hz = Hzx + Hzy + self.actualsource(self.source, self.f, n, self.dt) \n \n if(n%self.interval == 0): imx.append(Ex[:self.nx,:self.ny]**2 + Ey[:self.nx, :self.ny]**2)\n\n return imx","def calculate_rn_ratios(vn_event_arrays):\n vn_event_arrays = array(vn_event_arrays)\n rn_arrays = []\n for iorder in range(3, 6):\n # compute r2, r3, r4\n rn_array = []\n for itrig in range(3, len(vn_event_arrays[0, :, 0])):\n pT_trig = real(vn_event_arrays[0, itrig, 0])\n dN_trig = real(vn_event_arrays[:, itrig, 1])\n Qn_trig_array = dN_trig*vn_event_arrays[:, itrig, iorder]\n nev = len(Qn_trig_array)\n\n denorm2_dN = dN_trig*(dN_trig - 1.)\n denorm2_array = abs(Qn_trig_array)**2. - dN_trig\n\n for iasso in range(0, itrig+1):\n pT_asso = real(vn_event_arrays[0, iasso, 0])\n dN_asso = real(vn_event_arrays[:, iasso, 1])\n Qn_asso_array = dN_asso*vn_event_arrays[:, iasso, iorder]\n\n num_dN = dN_trig*dN_asso\n num_array = real(Qn_asso_array*conj(Qn_trig_array))\n if iasso == itrig:\n num_dN -= dN_asso\n num_array = (real(Qn_asso_array*conj(Qn_trig_array))\n - dN_asso)\n\n denorm1_dN = dN_asso*(dN_asso - 1.)\n denorm1_array = abs(Qn_asso_array)**2. - dN_asso\n\n rn_jackknife = zeros(nev)\n for iev in range(nev):\n array_idx = [True]*nev\n array_idx[iev] = False\n array_idx = array(array_idx)\n\n num = mean(num_array[array_idx])/mean(num_dN[array_idx])\n denorm1 = (mean(denorm1_array[array_idx])\n /mean(denorm1_dN[array_idx]))\n denorm2 = (mean(denorm2_array[array_idx])\n /mean(denorm2_dN[array_idx]))\n\n if denorm1 > 0. and denorm2 > 0.:\n rn_jackknife[iev] = num/sqrt(denorm1*denorm2)\n\n rn_mean = mean(rn_jackknife)\n rn_err = sqrt((nev - 1.)/nev*sum((rn_jackknife - rn_mean)**2.))\n rn_array.append([pT_trig - pT_asso, rn_mean, rn_err])\n rn_arrays.append(rn_array)\n rn_arrays = array(rn_arrays)\n return(rn_arrays)","def iterative_improvement(opt_matrix, w_matrix, r_vector, c_min, c_max, max_iter=None, verbose=True,\n use_cuda=False):\n\n total_time = 0\n with Timer(\"Calculating initial solution...\", verbose) as t:\n opt_matrix = optimal_result(opt_matrix, w_matrix, r_vector)\n total_time += t.get_time_s()\n\n total_per_col = opt_matrix.sum(axis=0)\n n_rows = opt_matrix.shape[0]\n over_alloc, under_alloc = print_solution_diagnostic(total_per_col, c_min, c_max, verbose)\n\n cuda_interation = CudaIteration(opt_matrix.shape[0], opt_matrix.shape[1])\n\n solution_vals = []\n iteration_n = 0\n while (sum(over_alloc) > 1 or sum(under_alloc) > 1) and iteration_n != max_iter:\n solution_vals.append(np.sum(np.multiply(opt_matrix, w_matrix)))\n iteration_n += 1\n with Timer(f\"Iteration {iteration_n} :\\n\", verbose) as t:\n over_alloc_pct, under_alloc_pct, can_add, can_remove = \\\n get_iteration_parameters(total_per_col, c_min, c_max, n_rows)\n if use_cuda:\n opt_matrix = cuda_interation(opt_matrix, over_alloc_pct, under_alloc_pct, can_add, can_remove)\n else:\n opt_matrix = iteration_improve(opt_matrix, over_alloc_pct, under_alloc_pct, can_add, can_remove)\n total_per_col = opt_matrix.sum(axis=0)\n over_alloc, under_alloc = print_solution_diagnostic(total_per_col, c_min, c_max, verbose)\n total_time += t.get_time_s()\n solution_vals.append(np.sum(np.multiply(opt_matrix, w_matrix)))\n\n cuda_compute_time = cuda_interation.computation_time\n\n return solution_vals, total_time, cuda_compute_time","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","def fAVM(RHOB,Dw,Ds,Df,Dc1,PHIc1,Ck,Dk,PHIk,RSK):\n#\n# 5.1.1 Initialise Outputs & Check for missing values in inputs:\n# --------------------------------------------------------------\n\tPHIt=MissingValue\n\tPHIe=MissingValue\n\tCBW=MissingValue\n\tBVW=MissingValue\n\tHCPV=MissingValue\n\tVf=MissingValue\n\tVs=MissingValue\n\tSwt=MissingValue\n\tSwe=MissingValue\n\tVc1=MissingValue\n\tVc2=MissingValue\n\tVc3=MissingValue\n\tVk=MissingValue\n\tToc=MissingValue\n\tQc=MissingValue\n\tGDen=MissingValue\n\tif MissingValue in (RHOB,Dw,Ds,Df,Dc1,PHIc1,Ck,Dk,PHIk,RSK):\n\t\treturn PHIt,PHIe,CBW,BVW,HCPV,Vf,Vs,Swt,Swe,Vc1,Vc2,Vc3,Vk,Toc,Qc,GDen\n#\n# 5.1.2 Initialise parameters:\n# ----------------------------\n\tNIter=0\n\tNIterMax=100\n\tErrIter=10000\n\tTolErrIter=0.0001\n\tIterEnd=0\n\tVk=0.000 # Initially assumme no kerogen\n\tDh=Df\n#\n#\t5.1.3 Start interative loop:\n#\t-----------------------------\n\twhile IterEnd==0:\n#\n# 5.5.3.1 Organic and Inorganic Component Density Values:\n# -------------------------------------------------------\n\t\tDBI=(1-PHIc1)*Dc1+(PHIc1*Dw) # Bulk Density of Inorganic Component\n\t\tDBO=(1-PHIk)*Dk+(PHIk*Dh)# Bulk Density of Organic Component\n#\n# 5.1.3.2 Compute Volume of Organic and Inorganic Component:\n# ----------------------------------------------------------\n\t\tVOR=(DBI-RHOB)/(DBI-DBO)\n\t\tVOR=ImposeLimits(VOR,0,1)\n\t\tVIN=(1-VOR)\n#\n# 5.1.3.3 Compute Volumetrics, Total & Effective Porosity and Total & Effective Water Saturation:\n# ---------------------------------------\t-------------------------------------------------------\n\t\tVc1=VIN*(1-PHIc1)\n\t\tVc2=0.000\n\t\tVc3=0.000\n\t\tVk=VOR*(1-PHIk)\n\t\tPHIt=VIN*PHIc1+VOR*PHIk\n\t\tPHIe=VOR*PHIk\n\t\tSwt=1-((VOR*PHIk)/PHIt)\n\t\tSwt=ImposeLimits(Swt,0,1)\n\t\tSwe=0.000\n\t\tSxot=Swt\n\t\tSxoe=Swe\n#\n# 5.1.3.4 Compute Bulk Volume of Water, Hydrocarbon Pore Volume and Pore Space Fluid Properties:\n# ---------------------------------------\t------------------------------------------------------\n\t\tBVW=PHIe*Swe\n\t\tHCPV=PHIe*(1-Swe)\n\t\tVs=RSK*Vk # Estimate volume of adsorbed (sorbed) hydrocarbon\n\t\tVs=ImposeLimits(Vs,0,HCPV)\n\t\tVf=(HCPV-Vs)\n\t\tVf=ImposeLimits(Vf,0,(HCPV-Vs))\n#\n# 5.1.3.5 Recompute hydrocarbon properties in the pore space:\n# -----------------------------------------------------------\n\t\tSum=Vs+Vf\n\t\tif(Sum<=0.000):\n\t\t\tDh=Df\n\t\telse:\n\t\t\tDh=(Ds*Vs+Df*Vf)/(Vs+Vf)\n#\n# 5.1.4 Test for interative computations:\n# ---------------------------------------\n\t\tNIter=NIter+1\n\t\tif(NIter>=NIterMax):\n\t\t\tIterEnd=1\n\t\telse:\t\t\t\n\t\t\tif(NIter<=2):\n\t\t\t\tResultOld=[1,1,1,1,1,1,1,1,1] # Initial Setting\n\t\t\t\tResultNew=[Vc1,Vc2,Vc3,Vk,Vs,Vf,PHIe,Swt,Swe] # Current Results\n\t\t\t\tErrIter=ComputeMatrixDifference(ResultOld,ResultNew)\n\t\t\t\tResultOld=ResultNew\n\t\t\telse:\n\t\t\t\tResultNew=[Vc1,Vc2,Vc3,Vk,Vs,Vf,PHIe,Swt,Swe] # Current Results\n\t\t\t\tErrIter=ComputeMatrixDifference(ResultOld,ResultNew)\n\t\t\t\tResultOld=ResultNew\n\t\t\t\tif(ErrIter<=TolErrIter):\n\t\t\t\t\tIterEnd=1\n#\n# 5.1.6 Preoutput computations:\n# ------------------------------\n\tQc=MissingValue\n\tDc2=0.00\n\tDc3=0.00\n\tCBW=PHIt-PHIe # The assumption is that all microporosity can be considered to be clay bound water.\n\tToc=fToc_Wtf(Vc1,Vc2,Vc3,Vk,0,Ck,Dc1,Dc2,Dc3,Dk,Dw) # TOC-wt fraction. Note: Vrw=0 in fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw)\n\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,0,Dc1,Dc2,Dc3,Dk,Dw) # Grain Density. Note: Vrw=0 in fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\n#\n# 5.5.7 Output Results:\n# \t-------------------\n\treturn PHIt,PHIe,CBW,BVW,HCPV,Vf,Vs,Swt,Swe,Vc1,Vc2,Vc3,Vk,Toc,Qc,GDen","def test_eigen_multiple_neighborhoods(self):\n # vectorized version\n t0 = time.time()\n extract_vect = EigenValueVectorizeFeatureExtractor()\n eigvals_vect = extract_vect.extract(self.point_cloud, self.neigh, None, None, None)\n print('Timing Vectorize : {}'.format((time.time() - t0)))\n eigvals_vect = np.vstack(eigvals_vect[:3]).T\n\n # serial version\n eigvals = []\n t0 = time.time()\n for n in self.neigh:\n extract = EigenValueSerial()\n eigvals.append(extract.extract(self.point_cloud, n, None, None, None))\n print('Timing Serial : {}'.format((time.time() - t0)))\n eigvals = np.array(eigvals)\n\n np.testing.assert_allclose(eigvals_vect, eigvals)","def test_solve_nicv(self):\n\n traces = np.array([[1, 2, 3], [4, 5, 6], [7, 0.4, 9], [2, 3, 12]])\n plain = np.array([[1], [2], [1], [2]])\n keys = plain\n resulting_nicvs = np.array([0.23045267, 0.24016342, 0.49382716])\n calculated_nicvs = NICV.calculate_nicv_array(plain, traces, 0, keys)\n self.assertTrue(np.allclose(calculated_nicvs, resulting_nicvs))","def refugia_adj_5_full_2_iter5 (params, ns):\n #33 parameters \n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\n nu_T0 = [nu1x, nuA]\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\n fs.integrate(nu_T0, T0, m=mig0)\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\n nu_T1 = [nu1a, nu2a, nu3a]\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \n fs.integrate(nu_T1, T1, m=mig1)\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\n nu_T2 = [nu1b, nu2b, nu3b]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\n nu_T3 = [nu1c, nu2c, nu3c]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3)\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\n nu_T4 = [nu1d, nu2d, nu3d]\n fs.integrate(nu_T4, T4) \n return fs","def solve_prep(self):\n\n par = self.par\n sol = self.sol\n\n # a. retirement\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\n\n # b. working\n if par.solmethod == 'G2EGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n \n elif par.solmethod == 'NEGM':\n\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\n sol.inv_vn = np.zeros((0,0,0))\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\n\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\n sol.wb = np.zeros((0,0,0))\n \n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))","def MATSOL(N,A):\r\n\r\n X = np.zeros((N+1),dtype=float) # X.shape = N+1\r\n NROW = np.arange(0,N+1,dtype=int) # NROW.shape = N+1\r\n\r\n for i in np.arange(N): # loop through rows\r\n AMAX = np.max(np.abs(A[NROW[i:],i])) # max value for column, all later rows\r\n ip = np.argmax(np.abs(A[NROW[i:],i]))+i # index of above\r\n \r\n if(abs(AMAX) <= 1E-08):\r\n print('Singular matrix --> No unique solution exists')\r\n return X\r\n \r\n if(NROW[i] != NROW[ip]): # swap rows\r\n NC = NROW[i].copy()\r\n NROW[i] = NROW[ip].copy()\r\n NROW[ip] = NC.copy()\r\n \r\n \r\n COEF = A[NROW[i+1:],i]/A[NROW[i],i] # normalize column values by maximum magnitude value (AMAX > 0)\r\n A[NROW[i+1:],i+1:] = A[NROW[i+1:],i+1:] - np.dot(COEF[:,None],A[NROW[i],i+1:][None,:]) # normalize/reduce matrix\r\n \r\n \r\n if(abs(A[NROW[N],N]) <= 1E-08):\r\n print('Singular matrix --> No unique solution exists')\r\n return X\r\n \r\n X[N] = A[NROW[N],N+1]/A[NROW[N],N] # downstream edge\r\n i = N-1\r\n while (i >= 0):\r\n# SUMM = 0.0\r\n# j = i+1\r\n \r\n SUMM = np.sum(A[NROW[i],i+1:N+1]*X[i+1:N+1]) # do not include final column\r\n \r\n# while (j <= N-1):\r\n# SUMM = A[NROW[i],j]*X[j] + SUMM\r\n# j = j+1\r\n # print(SUMM,SUMM2)\r\n \r\n X[i] = (A[NROW[i],N+1] - SUMM)/A[NROW[i],i]\r\n i = i-1\r\n return X","def calculate_vn6_over_vn4(vn_data_array, outputFileName):\n vn_data_array = array(vn_data_array)\n nev = len(vn_data_array[:, 0])\n dN = real(vn_data_array[:, 0])\n Q1 = dN*vn_data_array[:, 1]\n Q2 = dN*vn_data_array[:, 2]\n Q3 = dN*vn_data_array[:, 3]\n Q4 = dN*vn_data_array[:, 4]\n Q5 = dN*vn_data_array[:, 5]\n Q6 = dN*vn_data_array[:, 6]\n\n # two-particle correlation\n N2_weight = dN*(dN - 1.)\n Q2_2 = abs(Q2)**2. - dN\n\n # four-particle correlation\n N4_weight = dN*(dN - 1.)*(dN - 2.)*(dN - 3.)\n Q2_4 = ((abs(Q2)**4.) - 2.*real(Q4*conj(Q2)*conj(Q2))\n - 4.*(dN - 2.)*(abs(Q2)**2.) + abs(Q4)**2.\n + 2*dN*(dN - 3.))\n\n # six-particle correlation\n N6_weight = dN*(dN - 1.)*(dN - 2.)*(dN - 3.)*(dN - 4.)*(dN - 5.)\n Q2_6 = (abs(Q2)**6. + 9*(abs(Q4)**2.)*(abs(Q2)**2.)\n - 6.*real(Q4*Q2*conj(Q2)*conj(Q2)*conj(Q2))\n + 4.*real(Q6*conj(Q2)*conj(Q2)*conj(Q2))\n - 12.*real(Q6*conj(Q4)*conj(Q2))\n + 18.*(dN - 4.)*real(Q4*conj(Q2)*conj(Q2))\n + 4.*(abs(Q6)**2.)\n - 9.*(dN - 4.)*((abs(Q2)**4.) + (abs(Q4)**2.))\n + 18.*(dN - 5.)*(dN - 2.)*(abs(Q2)**2.)\n - 6.*dN*(dN - 4.)*(dN - 5.))\n\n # calcualte observables with Jackknife resampling method\n r2_array = zeros(nev)\n gamma1_array = zeros(nev)\n for iev in range(nev):\n array_idx = [True]*nev\n array_idx[iev] = False\n array_idx = array(array_idx)\n\n # C_n{4}\n C_2_2 = mean(Q2_2[array_idx])/mean(N2_weight[array_idx])\n C_2_4 = (mean(Q2_4[array_idx])/mean(N4_weight[array_idx])\n - 2.*(C_2_2**2.))\n C_2_6 = (mean(Q2_6[array_idx])/mean(N6_weight[array_idx])\n - 9.*C_2_2*mean(Q2_4[array_idx])/mean(N4_weight[array_idx])\n + 12.*(C_2_2**3.))\n if C_2_6 > 0. and C_2_4 < 0. and C_2_2 > 0.:\n v2_2 = sqrt(C_2_2)\n v2_6 = (C_2_6/4.)**(1./6.)\n v2_4 = (-C_2_4)**(1./4.)\n r2_array[iev] = v2_6/v2_4\n gamma1_array[iev] = (-6.*sqrt(2)*(v2_4**2.)*(v2_4 - v2_6)\n /(v2_2**2. - v2_4**2.)**(1.5))\n\n r2_mean = mean(r2_array)\n r2_err = sqrt((nev - 1.)/nev*sum((r2_array - r2_mean)**2.))\n gamma1_mean = mean(gamma1_array)\n gamma1_err = sqrt((nev - 1.)/nev*sum((gamma1_array - gamma1_mean)**2.))\n\n f = open(outputFileName, 'w')\n f.write(\n \"# n vn{6}/vn{4} (vn{6}/vn{4})_err gamma_1 gamma_1_err\\n\")\n f.write(\"%d %.10e %.10e %.10e %.10e\\n\"\n % (2, r2_mean, r2_err, gamma1_mean, gamma1_err))\n f.close()\n return","def test_error1(version='scalar'):\n Lx = 10\n Ly = 10\n c = 1.0\n\n def exact(x, y, t):\n kx = pi/Lx; ky = pi/Ly; omega = sqrt(kx*kx + ky*ky)\n return cos(omega*t)*sin(kx*x)*sin(ky*y)\n\n def I1(x, y):\n return exact(x, y, 0)\n\n def bc(x, y, t):\n return exact(x, y, t)\n\n def f(x, y, t):\n if isinstance(x, ndarray) and isinstance(y, ndarray):\n return zeros((x.shape[0], y.shape[1]))\n else:\n return 0.0\n \n error = []\n def action(u, xv, yv, t):\n e = exact(xv, yv, t) - u\n error.append((t, sqrt(innerproduct(e.flat,e.flat))))\n\n t0 = time.clock()\n implementation = {'ic': version, 'inner': version, 'bc': version}\n nx = 10; ny = 4; tstop = 20\n solver(I1, f, c, bc, Lx, Ly, nx, ny, 0, tstop,\n user_action=action, implementation=implementation)\n for t, e in error:\n print 't=%10.2E error=%10.2E' % (t, e)","def run_qae_optimization(training_states, n_repetitions, exact=no_noise, noisy=gate_error):\n result_list = []\n def proxy(params, training_states, n_repetitions, exact=no_noise, noisy=gate_error):\n \"\"\"Embedded function version\n \"\"\"\n input_list = fix_list(params, all_param_array=all_param, var_param_array=var_param, fixed_vals_array=fixed_vals)\n fidelities = []\n for training_state in training_states:\n fid = cusp_stage2.compute_stage2_cost_function(*input_list, alpha=training_state, n_repetitions=n_repetitions,\n exact=exact, noisy=noisy)\n fidelities.append(fid)\n avg_fid = np.mean(fidelities)\n result_list.append(1-avg_fid)\n print(1-avg_fid)\n return 1. - avg_fid\n\n \n # Initialize parameters\n half_turn_min = 0\n half_turn_max = 2\n init_params = np.random.uniform(low=half_turn_min, high=half_turn_max,\n size=num_param)\n\n # Optimization using Nelder-Mead.\n h2_qae_wrap = lambda params: proxy(params, training_states=training_states,\n n_repetitions=n_repetitions, exact=exact, noisy=noisy)\n \n if noisy:\n maxiter = 60\n else:\n maxiter = None\n \n res = minimize(h2_qae_wrap, init_params, args=(),\n method='Nelder-Mead', tol=None, \n options={'disp': False, 'maxiter': maxiter, 'xatol': 0.001,\n 'return_all': False, 'fatol': 0.001})\n np.savetxt('stage2_data.csv',result_list, delimiter=',')\n return res.x","def find_min_norm_element(vecs):\n # Solution lying at the combination of two points\n\n\n vecs_clone = []\n for i in range(len(vecs)):\n # assert len(vecs[i]) == 1\n vecs_task = []\n for k in range(len(vecs[i])):\n vecs_task.append(vecs[i][k].view(-1))\n vecs_clone.append(torch.cat(vecs_task).unsqueeze(0))\n vecs_clone = torch.cat(vecs_clone)\n\n grad_mat = torch.matmul(vecs_clone, vecs_clone.t())\n\n # dps = {}\n init_sol = MinNormSolver._min_norm_2d(grad_mat)\n \n n = len(vecs)\n sol_vec = torch.zeros([n,]).cuda()\n sol_vec[init_sol[0][0]] = init_sol[1]\n sol_vec[init_sol[0][1]] = 1 - init_sol[1]\n# sol_vec = sol_vec.unsqueeze(0)\n\n if n < 3:\n # This is optimal for n=2, so return the solution\n return sol_vec , init_sol[2]\n \n iter_count = 0\n\n # grad_mat = np.zeros((n,n))\n # for i in range(n):\n # for j in range(n):\n # grad_mat[i,j] = dps[(i, j)]\n \n\n while iter_count < MinNormSolver.MAX_ITER:\n grad_dir = -1.0 * torch.matmul(grad_mat, sol_vec)\n# sol_vec = sol_vec.squeeze()\n new_point = MinNormSolver._next_point(sol_vec, grad_dir, n)\n\n v1v1 = torch.sum(sol_vec.unsqueeze(1).repeat(1, n)*sol_vec.unsqueeze(0).repeat(n, 1)*grad_mat)\n v1v2 = torch.sum(sol_vec.unsqueeze(1).repeat(1, n)*new_point.unsqueeze(0).repeat(n, 1)*grad_mat)\n v2v2 = torch.sum(new_point.unsqueeze(1).repeat(1, n)*new_point.unsqueeze(0).repeat(n, 1)*grad_mat)\n\n nc, nd = MinNormSolver._min_norm_element_from2(v1v1, v1v2, v2v2)\n new_sol_vec = nc*sol_vec + (1-nc)*new_point\n change = new_sol_vec - sol_vec\n if torch.sum(torch.abs(change)) < MinNormSolver.STOP_CRIT:\n return sol_vec, nd\n sol_vec = new_sol_vec","def iterative_function_vect(points, numLines, numIter, e_tilde, gamma_tilde, beta_tilde):\n \n numPoints = len(points)\n \n # Randomly sample pairs and get the corresponding rho and theta parameters for a line fitted to the pair: \n # Returns a list of tuples - Each tuple has the rho and theta parameters for the line: \n lines ,idxs = info_rand_sample_fit_lines(points, numLines)\n \n \n # Compute normal distance of each point from each line: Store in a 2-D numpy array: \n # Points along 1st axis - Rows - axis= 0\n # Lines along 2nd axis - Columns - axis=1\n \n # Initialize the 2-D array: \n normDist = np.zeros((numPoints, numLines))\n \n \n # Indices for the 2-D array: \n j,k = 0,0\n \n # Loop through points:\n for point in points: \n \n k = 0\n \n # Loop through the lines: \n for line in lines:\n \n normDist[j,k] = get_normal_dist(line,point)\n \n # Increment the column (line) index:\n k+=1\n \n \n #Increment the row (point) index\n j += 1\n \n # Transform the Normal Distance matrix to the Probability of Membership matrix: \n Pr_C = log_dec(normDist,e_tilde)\n \n \n ## Iteratively refine estimates of Prob of Validity - Points and Lines: \n iterCount = 0\n \n # Initialize Probability of Validity of points and lines: \n initProb =1\n Pr_A = initProb*np.ones((numPoints,1))\n Pr_V = np.zeros((numLines,1))\n \n \n # Initialize gamma and beta: Fractions of valid points and lines respectively: \n gamma = np.zeros_like(Pr_V)\n beta = np.zeros_like(Pr_A)\n \n \n while iterCount < numIter: \n \n # For each line: Compute Gamma:\n \n # Compute expected fraction of valid points: \n gamma = np.dot(Pr_A.T, Pr_C)/np.sum(Pr_A) # Hope the broadcasting works here:\n \n \n # Compute Probability of Validity: \n Pr_V = log_inc(gamma, gamma_tilde) \n \n \n # For each point: Compute beta:\n \n # Compute expected fraction of valid lines in which it is a member: \n beta = np.dot(Pr_C, Pr_V.T)/np.sum(Pr_V)\n \n \n # Compute Probability of Validity: \n Pr_A = log_inc(beta, beta_tilde)\n \n \n iterCount +=1\n \n # Sort the lines according to Probability of Validity:\n idx_sort = np.argsort(Pr_V, axis=1)\n \n print (\" The equations of candidate lines and their probability of validity are: \") \n\n \n for idx in idx_sort: \n print (lines[int(idx)] , end = '-- >')\n print (Pr_V[idx])\n \n return lines, Pr_A, Pr_V","def solve(self, regparam):\n self.regparam = regparam\n \n #Some counters for bookkeeping\n self.stepcounter = 0\n self.flipcounter = 0\n self.nochangecounter = 0\n \n #Cached results\n self.evals = np.multiply(self.svals, self.svals)\n self.newevals = 1. / (self.evals + self.regparam)\n newevalslamtilde = np.multiply(self.evals, self.newevals)\n self.D = np.sqrt(newevalslamtilde)\n #self.D = -newevalslamtilde\n \n self.VTY = self.svecs.T * self.Y\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\n \n #Using lists in order to avoid unnecessary matrix slicings\n self.DVTY_list = []\n self.YTVDDVTY_list = []\n self.classFitnessList = []\n for i in range(self.labelcount):\n DVTY_i = DVTY[:,i]\n self.DVTY_list.append(DVTY_i)\n YTVDDVTY_i = DVTY_i.T * DVTY_i\n self.YTVDDVTY_list.append(YTVDDVTY_i)\n fitness_i = self.size - DVTY_i.T * DVTY_i\n self.classFitnessList.append(fitness_i)\n \n self.Dsvecs_list = []\n self.svecsDDsvecs_list = []\n for i in range(self.size):\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\n self.Dsvecs_list.append(Dsvec)\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\n \n self.updateA()\n \n \n converged = False\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n while True:\n \n converged = self.roundRobin()\n print(self.classcounts.T)\n if self.callbackfun is not None:\n self.callbackfun.callback(self)\n if converged: break\n \n if self.oneclass:\n self.Y = self.Y[:, 0]\n self.A = self.A[:, 0]\n self.results['predicted_clusters_for_training_data'] = self.Y\n self.predictor = self.svdad.createModel(self)","def value_iteration(r,terminal_states_mask, not_slipping_prob=1,\n initial_policy=None,\n eps=0.1):\n V = np.copy(r).astype(np.float)\n for _ in range(200):\n Vdet_u = np.copy(V)\n Vdet_r = np.copy(V)\n Vdet_l = np.copy(V)\n Vdet_d = np.copy(V)\n\n Vdet_u[1:, :] = V[:-1, :]\n Vdet_r[:, :-1] = V[:, 1:]\n Vdet_l[:, 1:] = V[:, :-1]\n Vdet_d[:-1, :] = V[1:, :]\n\n nsp = not_slipping_prob\n Vnext = np.zeros((4, )+r.shape, dtype=float)\n Vnext[UP, :, :] = nsp * Vdet_u + 0.5 * (1-nsp) * Vdet_l + 0.5 * (\n 1-nsp) * Vdet_r\n Vnext[DOWN, :, :] = nsp * Vdet_d + 0.5 * (1-nsp) * Vdet_l + 0.5 * (\n 1-nsp) * Vdet_r\n Vnext[LEFT, :, :] = nsp * Vdet_l + 0.5 * (1-nsp) * Vdet_u + 0.5 * (\n 1-nsp) * Vdet_d\n Vnext[RIGHT, :, :] = nsp * Vdet_r + 0.5 * (1-nsp) * Vdet_u + 0.5 * (\n 1-nsp) * Vdet_d\n if initial_policy is None:\n policy = np.argmax(r[None, :, :] + Vnext, axis=0)\n else:\n policy = np.copy(initial_policy)\n\n Vnew = np.copy(V)\n for a in [UP, DOWN, LEFT, RIGHT]:\n ind = np.logical_and(policy == a, ~ terminal_states_mask)\n Vnew[ind] = r[ind] + Vnext[a][ind]\n if np.linalg.norm(V - Vnew, ord=np.inf) < eps:\n break\n V[:, :] = Vnew\n return policy, V","def analytical_eig(A):\n n = len(A)\n h = 1/float(n)\n d = 2/float(h)**2\n a = -1/float(h)**2\n eigenval = np.empty(n)\n for j in range(1,n+1):\n eigenval[j-1] = d + 2*a*np.cos((j*np.pi)/(float(n)+1)) # Analytic solution\n \n return eigenval","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 svd_factorization_projections(A, m, n, orth_tol, max_refin, tol):\n # SVD Factorization\n U, s, Vt = scipy.linalg.svd(A, full_matrices=False)\n\n # Remove dimensions related with very small singular values\n U = U[:, s > tol]\n Vt = Vt[s > tol, :]\n s = s[s > tol]\n\n # z = x - A.T inv(A A.T) A x\n def null_space(x):\n # v = U 1/s V.T x = inv(A A.T) A x\n aux1 = Vt.dot(x)\n aux2 = 1/s*aux1\n v = U.dot(aux2)\n z = x - A.T.dot(v)\n\n # Iterative refinement to improve roundoff\n # errors described in [2]_, algorithm 5.1.\n k = 0\n while orthogonality(A, z) > orth_tol:\n if k >= max_refin:\n break\n # v = U 1/s V.T x = inv(A A.T) A x\n aux1 = Vt.dot(z)\n aux2 = 1/s*aux1\n v = U.dot(aux2)\n # z_next = z - A.T v\n z = z - A.T.dot(v)\n k += 1\n\n return z\n\n # z = inv(A A.T) A x\n def least_squares(x):\n # z = U 1/s V.T x = inv(A A.T) A x\n aux1 = Vt.dot(x)\n aux2 = 1/s*aux1\n z = U.dot(aux2)\n return z\n\n # z = A.T inv(A A.T) x\n def row_space(x):\n # z = V 1/s U.T x\n aux1 = U.T.dot(x)\n aux2 = 1/s*aux1\n z = Vt.T.dot(aux2)\n return z\n\n return null_space, least_squares, row_space","def run_vqe(\n self,\n backend=Aer.get_backend(\"statevector_simulator\"),\n var_form=None,\n optimizer=None,\n reps=None,\n mode=\"min_val\",\n ):\n # N=int(np.ceil(np.log2(len(self.mat))))\n # hk = np.zeros((2**N,2**N),dtype='complex')\n # hk[:self.mat.shape[0], :self.mat.shape[1]] = self.mat\n N = self.n_qubits()\n if mode == \"max_val\":\n Hamil_mat = aqua.operators.MatrixOperator(-1 * self.mat)\n # Hamil_mat = MatrixOperator(-1 * self.mat)\n else:\n Hamil_mat = aqua.operators.MatrixOperator(self.mat)\n # Hamil_mat = MatrixOperator(self.mat)\n Hamil_qop = aqua.operators.op_converter.to_weighted_pauli_operator(\n Hamil_mat\n )\n if var_form is None:\n if reps is None:\n reps = 2\n # reps=5\n from qiskit.circuit.library import EfficientSU2\n\n var_form = EfficientSU2(N, reps=reps)\n if optimizer is None:\n vqe = aqua.algorithms.VQE(Hamil_qop, var_form)\n # vqe = VQE(Hamil_qop, var_form)\n else:\n vqe = aqua.algorithms.VQE(Hamil_qop, var_form, optimizer)\n # vqe = VQE(Hamil_qop, var_form, optimizer)\n vqe_result = vqe.run(backend)\n en = np.real(vqe_result[\"eigenvalue\"])\n # params=vqe.optimal_params\n # circuit=vqe.construct_circuit(params)\n if mode == \"max_val\":\n en = -1 * en\n # states = np.sort(\n # np.real(\n # vqe.expectation.convert(\n # StateFn(vqe.operator, is_measurement=True)\n # ).to_matrix()\n # )\n # )\n return en, vqe_result, vqe","def refugia_adj_5_simsplit_4epochs_iter5 (params, ns):\n #28 parameters \n nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T1, T2, T3, T4 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2]) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\n nu_T1 = [nu1a, nu2a, nu3a]\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \n fs.integrate(nu_T1, T1, m=mig1)\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\n nu_T2 = [nu1b, nu2b, nu3b]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\n nu_T3 = [nu1c, nu2c, nu3c]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3)\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\n nu_T4 = [nu1d, nu2d, nu3d]\n fs.integrate(nu_T4, T4) \n return fs","def test_too_low_max_iterations(self):\n\n # Set up the problem of finding the square roots of three numbers.\n constants = np.array([4.0, 9.0, 16.0])\n initial_values = np.ones(len(constants))\n\n def objective_and_gradient(values):\n objective = values**2 - constants\n gradient = 2.0 * values\n return objective, gradient\n\n # Obtain and evaluate a tensor containing the roots.\n roots = newton_root_finder(\n objective_and_gradient, initial_values, max_iterations=1)\n _, converged, failed = self.evaluate(roots)\n\n # Reference values - we should neither have converged nor failed.\n converged_bench = np.array([False, False, False])\n failed_bench = np.array([False, False, False])\n\n # Assert that the values we obtained are close to the true values.\n np.testing.assert_array_equal(converged, converged_bench)\n np.testing.assert_array_equal(failed, failed_bench)","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 value_iteration(P, nS, nA, V, gamma=0.9, tol=1e-8):\n \n V_new = V.copy()\n ############################\n # YOUR IMPLEMENTATION HERE #\n while True:\n deltaV=0;\n for state in range(nS):\n # new_value=0;\n action_policy = np.zeros(nA) \n for action in range(nA):\n for p,nextS,r,boolean_v in P[state][action]:\n action_policy[action] += p*( r + gamma* V[nextS])\n V_new[state]=max(action_policy)\n deltaV= max(deltaV, abs(V_new[state]-V[state]))\n V[state] = V_new[state]\n #print(value_function)\n if(deltaV < tol):\n break\n policy_new = policy_improvement(P, nS, nA, V_new, gamma)\n ############################\n return policy_new, V_new","def mt(P_1,V0_1,meanF_1,rho): \n psi = np.arctan2(V0_1[2],-V0_1[0])\n \n # Find swept ares\n idx_zmax = np.argmax(P_1[:,-1,2])\n idx_ymax = np.argmax(P_1[:,-1,1])\n idx_zmin = np.argmin(P_1[:,-1,2])\n \n Ad = np.linalg.norm(P_1[idx_zmax,-1,2]-P_1[idx_zmin,-1,2])*P_1[idx_ymax,-1,1]\n print P_1[idx_zmax,-1,2]\n V0 = np.linalg.norm(V0_1)\n \n Vi_1new = np.zeros_like(V0_1,dtype=float)\n\n while True:\n Vi_1 = Vi_1new\n \n Vi_1new[0] = meanF_1[0] / (2 * rho * Ad * np.sqrt( (V0*np.cos(psi)+Vi_1[0])**2 + (-V0*np.sin(psi)+Vi_1[2])**2 )) \n Vi_1new[2] = meanF_1[2] / (2 * rho * Ad * np.sqrt( (V0*np.cos(psi)+Vi_1[0])**2 + (-V0*np.sin(psi)+Vi_1[2])**2 )) \n \n if np.linalg.norm(Vi_1-Vi_1new) < 0.001:\n break\n\n return -Vi_1","def _generate_jitted_eigsh_lanczos(jax: types.ModuleType) -> Callable:\n\n @functools.partial(jax.jit, static_argnums=(3, 4, 5, 6))\n def jax_lanczos(matvec, arguments, init, ncv, neig, landelta, reortho):\n \"\"\"\n Jitted lanczos routine.\n Args:\n matvec: A callable implementing the matrix-vector product of a\n linear operator.\n arguments: Arguments to `matvec` additional to an input vector.\n `matvec` will be called as `matvec(init, *args)`.\n init: An initial input state to `matvec`.\n ncv: Number of krylov iterations (i.e. dimension of the Krylov space).\n neig: Number of eigenvalue-eigenvector pairs to be computed.\n landelta: Convergence parameter: if the norm of the current Lanczos vector\n falls below `landelta`, iteration is stopped.\n reortho: If `True`, reorthogonalize all krylov vectors at each step.\n This should be used if `neig>1`.\n Returns:\n jax.numpy.ndarray: Eigenvalues\n list: Eigenvectors\n \"\"\"\n\n def body_modified_gram_schmidt(i, vals):\n vector, krylov_vectors = vals\n v = krylov_vectors[i, :]\n vector -= jax.numpy.vdot(v, vector) * jax.numpy.reshape(v, vector.shape)\n return [vector, krylov_vectors]\n\n def body_lanczos(vals):\n current_vector, krylov_vectors, vector_norms = vals[0:3]\n diagonal_elements, matvec, args, _ = vals[3:7]\n threshold, i, maxiteration = vals[7:]\n norm = jax.numpy.linalg.norm(current_vector)\n normalized_vector = current_vector / norm\n normalized_vector, krylov_vectors = jax.lax.cond(\n reortho, True,\n lambda x: jax.lax.fori_loop(0, i, body_modified_gram_schmidt,\n [normalized_vector, krylov_vectors]),\n False, lambda x: [normalized_vector, krylov_vectors])\n Av = matvec(normalized_vector, *args)\n\n diag_element = jax.numpy.vdot(normalized_vector, Av)\n\n res = jax.numpy.reshape(\n jax.numpy.ravel(Av) -\n jax.numpy.ravel(normalized_vector) * diag_element -\n krylov_vectors[i - 1] * norm, Av.shape)\n krylov_vectors = jax.ops.index_update(krylov_vectors, jax.ops.index[i, :],\n jax.numpy.ravel(normalized_vector))\n\n vector_norms = jax.ops.index_update(vector_norms, jax.ops.index[i - 1],\n norm)\n diagonal_elements = jax.ops.index_update(diagonal_elements,\n jax.ops.index[i - 1],\n diag_element)\n\n return [\n res, krylov_vectors, vector_norms, diagonal_elements, matvec, args,\n norm, threshold, i + 1, maxiteration\n ]\n\n def cond_fun(vals):\n _, _, _, _, _, _, norm, threshold, iteration, maxiteration = vals\n\n def check_thresh(check_vals):\n val, thresh = check_vals\n return jax.lax.cond(val < thresh, False, lambda x: x, True, lambda x: x)\n\n return jax.lax.cond(iteration <= maxiteration, [norm, threshold],\n check_thresh, False, lambda x: x)\n\n numel = jax.numpy.prod(init.shape)\n krylov_vecs = jax.numpy.zeros((ncv + 1, numel), dtype=init.dtype)\n norms = jax.numpy.zeros(ncv, dtype=init.dtype)\n diag_elems = jax.numpy.zeros(ncv, dtype=init.dtype)\n\n norms = jax.ops.index_update(norms, jax.ops.index[0], 1.0)\n\n norms_dtype = jax.numpy.real(jax.numpy.empty((0, 0),\n dtype=init.dtype)).dtype\n initvals = [\n init, krylov_vecs, norms, diag_elems, matvec, arguments,\n norms_dtype.type(1.0), landelta, 1, ncv\n ]\n output = jax.lax.while_loop(cond_fun, body_lanczos, initvals)\n final_state, krylov_vecs, norms, diags, _, _, _, _, it, _ = output\n krylov_vecs = jax.ops.index_update(krylov_vecs, jax.ops.index[it, :],\n jax.numpy.ravel(final_state))\n\n A_tridiag = jax.numpy.diag(diags) + jax.numpy.diag(\n norms[1:], 1) + jax.numpy.diag(jax.numpy.conj(norms[1:]), -1)\n eigvals, U = jax.numpy.linalg.eigh(A_tridiag)\n eigvals = eigvals.astype(A_tridiag.dtype)\n\n def body_vector(i, vals):\n krv, unitary, states = vals\n dim = unitary.shape[1]\n n, m = jax.numpy.divmod(i, dim)\n states = jax.ops.index_add(states, jax.ops.index[n, :],\n krv[m + 1, :] * unitary[m, n])\n return [krv, unitary, states]\n\n state_vectors = jax.numpy.zeros([neig, numel], dtype=init.dtype)\n _, _, vectors = jax.lax.fori_loop(0, neig * (krylov_vecs.shape[0] - 1),\n body_vector,\n [krylov_vecs, U, state_vectors])\n\n return jax.numpy.array(eigvals[0:neig]), [\n jax.numpy.reshape(vectors[n, :], init.shape) /\n jax.numpy.linalg.norm(vectors[n, :]) for n in range(neig)\n ]\n\n return jax_lanczos","def boxcar(self, box_dm: float = 0.5, n: int = 4, el_included=None, m_uplim: float=np.inf, is_info: bool = False):\n clone = self.clone()\n abund = clone.abund()\n # abun = np.zeros((clone.nzon, len(clone.Elements)))\n if el_included is None:\n el_included = clone.Elements\n if m_uplim is None:\n m_uplim = np.inf\n m = clone.m / phys.M_sun\n dmass = np.diff(m)\n dmass = np.insert(dmass, -1, dmass[-1])\n\n # todo Check left boundary condition fo Fe, Si\n for l in range(n): # the iteration number\n logger.debug(f'Attempt # {l}')\n for k in range(clone.nzon):\n if m[k] > m_uplim:\n logger.warn(f'Exit from zone cycle m[k] > m_uplim: k= {k} m= {m[k]:.4f} m_uplim= {m_uplim:.4f}')\n break # stop because mass is over the limit\n kk = k + 1\n dm = dmass[k]\n while dm < box_dm and kk <= clone.nzon:\n kk += 1\n dm = np.sum(dmass[k:kk])\n\n logger.debug(f'{k}: kk= {kk} dm= {dm:.4f} m= {m[k]:.4f}')\n if dm > 1e-6:\n for i, ename in enumerate(clone.Elements):\n if ename in el_included:\n dm_e = np.dot(abund[k:kk, i], dmass[k:kk])\n abund[k, i] = dm_e / dm\n # abun[k,i] = x[k]\n for i, ename in enumerate(clone.Elements):\n clone.set_chem(ename, abund[:, i]) \n logger.debug(f\"{ename}: {clone.el(ename)}\")\n\n return clone","def evaltr(x_solution): \n \n large = 10.0**30\n pred = np.zeros(cfg.ntrain)\n e0 = 0.0 # mean of observed values\n y=0.0\n for i in range(cfg.ntrain): # Computation of correct piece\n e0 += cfg.a_unscaled[i][-1]\n pind = 0\n ipbest = 0\n pbest = -large # for max\n \n for j1 in range(cfg.nomax):\n ipmin=pind\n pmin=large # for min\n for _ in range(cfg.jk[j1]):\n piece=x_solution[(pind+1)*cfg.nfea-1] \n for j3 in range(cfg.nfea-1): #\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\n if piece < pmin:\n ipmin = pind\n pmin = piece\n pind += 1 \n \n if pmin > pbest:\n ipbest = ipmin\n pbest = pmin\n \n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\n for j1 in range(cfg.nfea-1):\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\n y += pred[i]\n \n y = y/cfg.ntrain \n e0 = e0/cfg.ntrain\n \n # Computation of indices\n rmse = 0.0\n mae = 0.0\n e1 = 0.0\n for i in range(cfg.ntrain):\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \n e1 += (cfg.a_unscaled[i][-1] - e0)**2\n ce = 1.0 - rmse/e1 \n rmse = np.sqrt(rmse/cfg.ntrain)\n mae = mae/cfg.ntrain \n\n if cfg.ntrain > 1:\n sx=0.0\n sy=0.0\n rcor=0.0\n for i in range(cfg.ntrain):\n sx += (pred[i]-y)**2\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \n\n r = rcor/np.sqrt(sx*sy)\n \n return rmse,mae,ce,r","def solveNonlinear1(A, u_n, F_b, lam=1.5, tol=10e-10, maxiter=100):\n du = np.copy(u_n)\n error = 100\n iter = 0\n F = A @ u_n - lam / u_n ** 2 - F_b\n\n while iter < maxiter and error > tol:\n #Standard newthons method\n\n jacobian = A + np.diag(lam / u_n)\n\n du = splin.lgmres(jacobian, -F, du)[0]\n\n u_n += du\n\n F = A @ u_n - lam / u_n **2 - F_b\n\n\n error = np.nanmax(np.abs(F))\n iter += 1\n\n return u_n, error, iter","def calcEVals(self):\n self.eVals,self.eVecs = np.linalg.eigh(self.rhoOp)","def __init__( self ):\n self.NQ = 16\n self.Nbranches = 3\n self.NatomsUC = 1\n self.dim = 3\n self.QVectors = np.zeros( ( self.NQ , 3 ) )\n self.MakeQVectors()\n self.EigenVectors = np.zeros( [ self.NQ , \n self.Nbranches ,\n self.NatomsUC , \n self.dim ] )\n self.MakeEigenVectors()","def one_step(self):\r\n assert (self.uv_vol is not None)\r\n assert (self.guv_vol is not None)\r\n assert (self.uv_bound is not None)\r\n assert (self.vf_vect_bound is not None)\r\n assert (self.vF_vect_vol is not None)\r\n # Shape checks\r\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\r\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\r\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\r\n assert (self.uv_vol.shape == self.guv_vol.shape)\r\n assert (self.uv_vol.shape == self.uv_bound.shape)\r\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\r\n \r\n if self.step == 0:\r\n self.check_k_matrix_stability()\r\n # print(\"Epsilon is :\"+str(self.Epsilon))\r\n # print(\"Beta is :\"+str(self.Beta))\r\n\r\n # Form \"Stiffness\" matrix:\r\n K = self.make_k_matrix()\r\n # Form \"Force\" vector: \r\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\r\n\r\n # print(\"FORCE VECTOR:\")\r\n # print(f)\r\n # print(\"STIFFNESS MATRIX\")\r\n # print(K)\r\n # print(\"UV_VOL\")\r\n # print(self.uv_vol)\r\n # print(\"EPSILON * GUV_VOL\")\r\n # print(self.Epsilon * self.guv_vol)\r\n # print(\"UV_BOUND * COEFF\")\r\n # print((self.Epsilon / self.Beta) * self.uv_bound)\r\n sol = scipy_sparse_linsolve(K, f)\r\n # print(\"SOLUTION\")\r\n # print(sol)\r\n return sol"],"string":"[\n \"def initiateVMatrixes():\\n global v, vNew, vExact\\n # Initialize the grid to 0\\n v = np.zeros((n+1, n+1)) # matrix of v, index are i: row, j:column\\n # Set the boundary conditions\\n for i in range(1,n):\\n v[0,i] = 10\\n v[n,i] = 10\\n v[i,0] = 10\\n v[i,n] = 10\\n # Exact solution\\n vExact = np.copy(v)\\n for i in range(1,n):\\n for j in range(1,n):\\n vExact[i,j] = 10\\n # Initial guess\\n for i in range(1,n):\\n for j in range(1,n):\\n v[i,j] = 0.9*vExact[i,j]\\n vNew = np.copy(v)\",\n \"def solve_VFI(self):\\r\\n dimC = self.dimA ; dimA = self.dimA ; dimW = self.dimW \\r\\n C = self.c_grid ; A = self.a_grid ; W = self.W_grid\\r\\n tol = self.tol ; Niter = self.Niter ; R = self.R\\r\\n beta = self.beta ; Pi = self.Pi\\r\\n \\r\\n V0 = np.zeros((dimA,dimC,dimW))\\r\\n V1 = np.zeros((dimA,dimC,dimW))\\r\\n Pol = np.zeros((dimA,dimC,dimW))\\r\\n U = np.zeros((dimA,dimC,dimW))\\r\\n \\r\\n t0 = time()\\r\\n diff = 1 ; niter = 0\\r\\n \\r\\n while diff > tol:\\r\\n niter += 1\\r\\n # Value update step\\r\\n for ia in range(dimA):\\r\\n for ic in range(dimC):\\r\\n for iw in range(dimW):\\r\\n c = W[iw] + R*A[ia] - A\\r\\n x = C[ic]\\r\\n \\r\\n c[c < 0] = np.nan \\r\\n if x < 0:\\r\\n x = np.nan\\r\\n \\r\\n u = self.u(c,x) \\r\\n U[:,ic,iw] = u \\r\\n \\r\\n Objective = U + beta * V0 @ Pi.T\\r\\n V1[ia,:,:] = np.nanmax(Objective, axis = 0)\\r\\n Pol[ia,:,:] = np.nanargmax(Objective, axis = 0)\\r\\n \\r\\n # Evaluate distance between the value functions\\r\\n diff = np.max(np.max(np.abs(V1 - V0))) \\r\\n V0[:] = V1\\r\\n \\r\\n # Break the while loop if too many iterations\\r\\n #print(\\\"The current error is \\\"+str(diff))\\r\\n if niter > Niter:\\r\\n print('Ops, no convergence')\\r\\n break\\r\\n \\r\\n t1 = time()\\r\\n #print('VFI algorithm took {0:0d} iterations and {1:.2f} seconds.'.format(niter, t1 - t0))\\r\\n \\r\\n self.V1 = V1 ; self.Pol = Pol\",\n \"def relax_checker():\\n checker = 2\\n global v, vNew, n\\n for check in range(0,2):\\n for x in range(1,n):\\n for y in range(1,n):\\n if (x*(n+1) + y) % 2 == check:\\n v[x,y] = (v[x-1][y] + v[x+1][y] + v[x][y-1] + v[x][y+1])*0.25\",\n \"def VFI(method) :\\n iteration=0 # Iteration Counter\\n converged = 0 # Convergence Flag|\\n \\n#----- Initial Settings \\n v_update = zeros(n_grid)\\n v_func = empty(n_grid)\\n k_next_vec = empty(n_grid)\\n run_time = empty(2)\\n \\n def obj(k_next) :\\n \\\"\\\"\\\"\\n This function is used in value function iteration.\\n It represents the objective function to be maximized for one node (state) of current capitals.\\n Resulting value is maximized one corresponding to next period's capital as a maximizer. \\n Next period's value is computed by interpolation.\\n \\n Input : k_next (next period's capital)\\n \\n Output : value_vec (maximized value resulting from choosing optimal capital in the next period)\\n \\\"\\\"\\\" \\n \\n if method==1 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*linear_interp(k_grid,v_update,k_next))\\n elif method==2 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*quad_interp(k_grid,v_update,k_next))\\n elif method==3 :\\n value_vec = -1 * (log(A*k_current**(alpha) - k_next) + beta*cubic_interp(k_grid,v_update,k_next))\\n \\n return value_vec\\n\\n#----- Value function iteration\\n start = time.time() # start time\\n while converged==0 :\\n index = 0\\n for k_current in k_grid :\\n k_next = fminbound(obj,k_grid[0],k_grid[-1])\\n v_func[index] = (-1) * obj(k_next)\\n k_next_vec[index] = k_next\\n index = index + 1\\n dist = abs(max(v_func - v_update))\\n if dist<tol :\\n converged = 1\\n v_k, g_k = v_func, k_next_vec\\n v_update = v_func\\n print \\\"Iteration : \\\",iteration,\\\"\\\",\\\"Distance : \\\",dist # convergence process\\n iteration = iteration + 1\\n v_func = empty(n_grid) \\n k_next_vec = empty(n_grid)\\n \\n end = time.time() # end time\\n run_time[0],run_time[1] = runtime_cal(start,end) # total running time\\n \\n return v_k, g_k, run_time, iteration\",\n \"def 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 voltage_update(n):\\n global t\\n t = dt*(n-0.5)\\n\\n cv = dt / (C * dx)\\n\\n # recursively update the line voltage at all interior nodes\\n for k in range(0, nx - 1):\\n V[k] = V[k] - cv * (I[k] - I[k - 1])\",\n \"def eigenalgo(self, accuracy: float = 0, cap: int = 50000, version: str = \\\"Givens\\\", not_skip: bool = True):\\n j, temps, verify_accuracy = 0, 0, np.ones((self.N, self.N), dtype=bool) ^ np.eye(self.N, dtype=bool)\\n if version == \\\"Gram-Schmidt\\\":\\n temps = time()\\n while np.any(abs(self.vap[verify_accuracy]) > accuracy) and j < cap:\\n j += 1\\n q, r = self.gram_schmidt_qr()\\n self.vap, self.vep = r @ q, self.vep @ q\\n\\n elif version == \\\"Givens\\\":\\n verify_accuracy = np.ones((self.N, self.N), dtype=bool) ^ np.eye(self.N, dtype=bool)\\n temps = time()\\n while np.any(abs(self.vap[verify_accuracy]) > accuracy) and j < cap:\\n j += 1\\n q, r = self.givens_qr()\\n self.vap, self.vep = r @ q, self.vep @ q\\n\\n elif version == \\\"Rayleigh\\\":\\n not_sing, diff, cond, j = True, accuracy + 1, True, 0\\n temps = time()\\n while cond: # Stop condition, all eigenvalues must be different\\n while diff > accuracy and j < cap and not_sing:\\n j += 1\\n self.rvap, self.vep, diff, not_sing = self.rayleigh_iteration(self.rvap, self.vep)\\n\\n cond = False\\n if j < cap:\\n self.calc, first, not_sing = np.zeros(self.N, dtype=bool), True, True\\n for i in range(self.N):\\n if np.sum(np.less(np.abs(self.rvap - self.rvap[i]), 10 ** -6)) != 1:\\n self.rvap[i + 1:] += self.memorize[i]\\n if first:\\n self.memorize[i] += 0.5\\n self.vep[i + 1:, i + 1:] = np.eye(self.N - i - 1)\\n first, cond, diff = False, True, accuracy + 1\\n self.calc[i + 1:] = 1\\n temps = time() - temps\\n return self.rvap, self.vep, diff, j, temps\\n\\n else:\\n print(\\\"Please select an appropriate value for the version parameter\\\")\\n\\n temps = time() - temps\\n diff = np.max(abs(self.vap[verify_accuracy]))\\n return np.diag(self.vap), self.vep, diff, j, temps\",\n \"def FigA7(case):\\n \\n #set the parameter, arrays\\n \\n n_array=np.array([1,2,3])\\n\\n #set the result arrays\\n if case==0:\\n class_number=5\\n elif case==1:\\n class_number=6\\n fate=np.zeros([class_number])#number of evolutionary fate\\n fate_matrix=np.zeros([np.size(n_array),np.size(fate)])\\n \\n time=np.linspace(0,100000, 1000000)\\n loop=10**6\\n \\\"\\\"\\\"\\n 0 Co and/or Ch cannot survive in mono-culture\\n 1 Co cannot invade\\n 2 Only equilibrium of exclusion is stable\\n 3 Only equilibrium of coexistence is stable\\n 4 Two equilibria are UNstable\\n 5 two Equilibrium are stable (which may occur only when sCO vs rCh)\\n \\\"\\\"\\\"\\n for tri in range(np.size(n_array)):\\n counter=0\\n n=n_array[tri]\\n print(str(\\\"Hill coefficient is %d\\\" %(n)))\\n fate=np.zeros([class_number])#number of evolutionary fate should be reset\\n if case==0 or case==1:\\n fname=str('parameter-sweep-MC-n%d-case%d' %(n, case))\\n else:\\n print(\\\"Error in case\\\")\\n return 1\\n \\n for i in range(loop):\\n if(i+1)%10000==0:\\n print(i+1)\\n Ks,cd,T0, alpha,=np.random.uniform(0,1,4)\\n Kr,cr=np.random.uniform([Ks,0],[1,1],2)#Kr>Ks and cr.cd\\n #check whether r is positive or not\\n if case==0:\\n r1=rmax*(1-cr-cd)#rCO\\n r2=rmax#sCH\\n W0Co=r1-dmax*T0**n/(T0**n+Kr**n)-alpha#initial growth of Cooperator\\n W0Ch=r2-dmax*T0**n/(T0**n+Ks**n)-alpha#initial growth of Cheater\\n elif case==1:\\n r1=rmax*(1-cd)#sCo\\n r2=rmax*(1-cr)#rCh\\n W0Co=r1-dmax*T0**n/(T0**n+Ks**n)-alpha\\n W0Ch=r2-dmax*T0**n/(T0**n+Kr**n)-alpha\\n stab_e=0#initialize the falgs of stability\\n stab_c=0\\n if W0Co<0 or W0Ch<0:\\n fate[0]+=1\\n res=0\\n else:\\n #succeed in mono-culture \\n init=np.array([T0,10**(-6)])\\n if case==0: \\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Kr, alpha, n))\\n Ts=solCo[-1,0]\\n #x1s=solCo[-1,1]\\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Ks, alpha, n))\\n x2s=solCh[-1,1]\\n else:\\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Ks, alpha, n))\\n Ts=solCo[-1,0]\\n #x1s=solCo[-1,1]\\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Kr, alpha, n))\\n x2s=solCh[-1,1]\\n \\n #Evolutionary dynamics \\n if case==0:\\n K=Kr\\n else:\\n K=Ks\\n if r1*(1-x2s)-dmax*T0**n/(T0**n+K**n)<alpha:\\n #Co cannot invade\\n fate[1]+=1\\n res=1\\n else:\\n #Co can invade\\n #calculate Tdagger Td and check whether coexist or exclude\\n if case==0:\\n #rCo vs sCh\\n #in this case, at most one equilbrium is stable\\n tau=Quad(case,alpha,cr+cd,0,Kr, Ks, n)\\n Td=tau**(1/n)\\n if Td<Ts:\\n #Co exclude Ch\\n fate[2]+=1\\n res=2\\n else:\\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\\n #check the stability condition\\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\\n if stab==0:\\n #stable coexistence\\n fate[3]+=1\\n res=3\\n else:\\n #unstable coexistence nor exclusion\\n fate[4]+=1\\n res=4\\n print(Td, x1d, x2d)\\n else:\\n #sCo vs rCh\\n # in this case two equilibria can be stable at the same time\\n [tau_p,tau_m]=Quad(case,alpha,cd,cr,Ks, Kr, n)\\n if tau_m>Ts**n or tau_p<Ts**n:\\n # cexclusion is stable\\n stab_e=1\\n # stability in coexistence \\n if tau_p<0:\\n stab_c=0\\n else:\\n Td=tau_p**(1/n)\\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\\n #check the stability condition\\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\\n if stab==0:\\n #stable coexistence\\n stab_c=1\\n #classify\\n if stab_e==1 and stab_c==1:\\n # two stable equilbria\\n fate[5]+=1\\n res=5\\n elif stab_e==1 and stab_c==0:\\n #only stable cexclusion\\n fate[2]+=1\\n res=2\\n elif stab_e==0 and stab_c==1:\\n #stable coexistence\\n fate[3]+=1\\n res=3\\n else:\\n #both unstable\\n fate[4]+=1\\n res=4\\n \\n #save the results\\n if counter==0:\\n result=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\\n #save the result with parameter values\\n \\n else:\\n #add array of results\\n R=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\\n result=np.concatenate((result, R), axis=0)\\n counter+=1\\n \\n #save csv file and graph\\n np.savetxt(fname+'.csv',result, delimiter=',', header='Ks, Kr, cr, cd, alpha, T0, class', fmt='%.6f') \\n print(fate)\\n fate_matrix[tri,:]=fate \\n if case==0: \\n np.savetxt('parameter_sweep_MC_total_case0.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4', fmt='%d')\\n else:\\n np.savetxt('parameter_sweep_MC_total_case1.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4,cl5', fmt='%d')\\n Plot(case)\",\n \"def mmb_secuencial(n, tol):\\n if n <= 1:\\n return \\\"El parametro n debe ser mayor a 1\\\"\\n\\n # Se crea la matriz tridiagonal y la matriz de resultados\\n matriz_a = crear_matriz_a(n)\\n matriz_b = crear_matriz_b(n)\\n\\n # Se crea el vector inicial\\n vec_x = matrix(ones((n, 1), dtype='object'))\\n\\n # Se crean las variables simbolicas\\n simbolos = [MatrixSymbol('A', n, n),\\n MatrixSymbol('b', n, 1),\\n MatrixSymbol('x', n, 1)]\\n\\n simb_a = simbolos[0] # Variable simbolica de la matriz A\\n simb_b = simbolos[1] # Variable simbolica de la matriz b\\n simb_x = simbolos[2] # Variable simbolica de la matriz x\\n\\n # Se crea la funcion que debe ser evaluada\\n f = 1/2 * simb_x.T * simb_a * simb_x - simb_b.T * simb_x\\n funcion = lambdify(simbolos, f) # f(A, b, x)\\n\\n z = Symbol('z')\\n\\n vec_x_simbolico = []\\n # Se crean todas las variables simbolicas del vector\\n for i in range(0, n):\\n vec_x_simbolico.append([Symbol('x' + str(i))])\\n\\n # Se construye una np.matrix a partir del vector obtenido\\n vec_x_simbolico = matrix(vec_x_simbolico)\\n\\n gradiente = calcular_gradiente(funcion, matriz_a, matriz_b, vec_x_simbolico)\\n\\n # Se crean los vectores para las iteraciones\\n vec_x1_aux = matrix(zeros((n, 1), dtype='object'))\\n vec_error = matrix(zeros((n, 1), dtype='object'))\\n\\n # Se crean las listas para graficar el error\\n lista_iter = []\\n lista_error = []\\n\\n itr = 1 # Contador de iteraciones\\n\\n while 1:\\n # Se calcula el vector k+1 utilizando la regla de Jacobi\\n for j in range(0, n):\\n copia_vec_x = vec_x.copy()\\n copia_vec_x[j] = z\\n\\n # Se evalua la funcion con el vec_x con la variable simbolica\\n ecuacion = funcion(matriz_a, matriz_b, copia_vec_x)\\n\\n # Se crea la funcion a minimizar\\n fun_minimizar = lambdify(z, ecuacion.item(0))\\n\\n # Se minimiza la funcion\\n resultado = optimize.minimize_scalar(fun_minimizar).x\\n\\n # Se actualiza el vector de la iteracion actual\\n vec_x1_aux[j] = resultado\\n\\n # Se calcula el valor para el vector de error\\n copia_vec_x[j] = resultado\\n vec_error[j] = funcion(matriz_a, matriz_b, copia_vec_x)\\n\\n # Se obtiene la posicion del menor elemento en el vector de error\\n i = vec_error.argmin()\\n\\n # Se actualiza el valor en la posicion minima\\n vec_x[i] = vec_x1_aux[i]\\n\\n # Se calcula el vector para verificar la condicion de parada\\n vec_parada = evaluar_gradiente(gradiente, vec_x_simbolico, vec_x)\\n vec_parada = matrix(vec_parada, dtype='float')\\n\\n norma_2 = linalg.norm(vec_parada, 2)\\n\\n lista_iter.append(itr)\\n lista_error.append(norma_2)\\n\\n # Se verifica la condicion de parada\\n if norma_2 < tol:\\n break\\n\\n itr += 1\\n\\n graficar_error(lista_iter, lista_error)\\n\\n return vec_x\",\n \"def runpower(matrix, n, tolerance, max_num=None, return_vector=True):\\n\\tcalculate_next = True\\n\\teigenvalue_list = []\\n\\teigenvector_list = []\\n\\tleading_eigenvalue = np.nan\\n\\twhile(calculate_next):\\t\\n\\t\\tnew_eigenvalue, v = runpower_one(matrix, n)\\n\\t\\tif np.isnan(leading_eigenvalue):\\n\\t\\t\\tleading_eigenvalue = new_eigenvalue\\n\\t\\teigenvalue_list.append(new_eigenvalue)\\n\\t\\teigenvector_list.append(v)\\n\\t\\tif max_num is not None and len(eigenvalue_list) == max_num:\\n\\t\\t\\tbreak\\n\\t\\tif abs(1.0 * new_eigenvalue / leading_eigenvalue) < tolerance:\\n\\t\\t\\tcalculate_next = False\\n\\t\\telse:\\n\\t\\t\\tmatrix = matrix - new_eigenvalue * np.outer(v,v)\\n\\tif return_vector:\\n\\t\\treturn eigenvalue_list, np.asarray(eigenvector_list).T\\n\\telse:\\n\\t\\treturn eigenvalue_list\",\n \"def main():\\n print 'Running the power method...'\\n dim = input('Give the dimension : ')\\n nbit = input('How many iterations ? ')\\n j = complex(0, 1)\\n rnd = np.random.normal(0, 1, (dim, dim)) \\\\\\n + np.random.normal(0, 1, (dim, dim))*j\\n nbs = np.random.normal(0, 1, (dim, 1)) \\\\\\n + np.random.normal(0, 1, (dim, 1))*j\\n rndmat = np.matrix(rnd)\\n rndvec = np.matrix(nbs)\\n eigmax = power_method(rndmat, rndvec, nbit)\\n check(rndmat, eigmax)\",\n \"def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\\n mask, max_iter=100, init=None,\\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\\n\\n # shape of image box\\n \\n alpha = 1\\n\\n flat_mask = mask.ravel()\\n volume_shape = mask.shape\\n H_size = len(Hurst_init)\\n\\n if lipschitz_constant == 0:\\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\\n\\n #init[\\\"z\\\"] = Hurst_init.copy()\\n #init[\\\"t\\\"] = 1\\n #ini[\\\"stepsize\\\"] = 1 / lipschitz_constant\\n\\n def total_energy(x):\\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\\n\\n def unmaskvec(w):\\n return _unmask(w, mask)\\n\\n def maskvec(w):\\n return w[flat_mask]\\n\\n def f1_grad(x):\\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\\n\\n def f2_prox(w, stepsize, dgap_tol, init):\\n out, info = _prox_tvl1(unmaskvec(w),\\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\\n dgap_tol=dgap_tol, init=unmaskvec(init),\\n max_iter=prox_max_iter, fista = False,\\n verbose=verbose)\\n #pdb.set_trace()\\n return maskvec(out.ravel()), info\\n\\n w, obj, init = mfista(\\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\\n max_iter=max_iter, callback=None)\\n \\n return w, obj, init\",\n \"def test_solver1(N, version='scalar'):\\n def I(x): return sin(2*x*pi/L)\\n def f(x,t): return 0\\n solutions = []\\n # Need time_level_counter as global variable since\\n # it is assigned in the action function (that makes\\n # a variable local to that block otherwise).\\n # The manager class below provides a cleaner solution.\\n global time_level_counter\\n time_level_counter = 0\\n\\n def action(u, t, x):\\n global time_level_counter\\n if time_level_counter % N == 0:\\n solutions.append(u.copy())\\n time_level_counter += 1\\n\\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(solutions[-1])\",\n \"def simulating_verlet(n,N,D,t,Rv,sigma,epsilon,dt,m,T,dim,kb,V,steps_r):\\n Ekinv = np.zeros((n,1))\\n Epotv = np.zeros((n,1))\\n Ev = np.zeros((n,1))\\n Gpc = np.zeros((steps_r,n))\\n for k in range(len(t)):\\n F = particle_forceV(Rv[-1], N, sigma, epsilon, D)\\n Rv.append(particle_positionV(copy.deepcopy(Rv[-1]), V, dt, F, D)) \\n V = particle_velocityV(V, F, dt, Rv, sigma, epsilon, D, N)\\n Ekinv[k] = np.sum(1/(2*m)*(V**2))\\n \\n #Calibration\\n if (int(k%(10)) == int(0) & int(k)<int(len(t)/2)):\\n V = calibration(N, kb,T,Ekinv[k],V)\\n Ekinv[k] = np.sum(1/(2*m)*(V**2))\\n if int(k)> int(len(t)-50):\\n Gpc[:,k], dist, dr = pair_correlation(N,Rv[-1],D,steps_r)\\n Uv = particle_LJV(Rv[-1], N, D) \\n Epotv[k] = abs(Uv)/2 \\n Ev[k] = Ekinv[k]+Epotv[k]\\n return Rv, Ekinv, Epotv, Ev, Gpc\",\n \"def test_euler():\\n for nsteps in [1, 5]:\\n solver = EulerSolver(nsteps)\\n integration_testing(solver)\",\n \"def calculate_vn_eta(eta_array, dN_array, vn_array, eta_min, eta_max):\\n nev, neta = dN_array.shape\\n dN_array = dN_array.reshape((nev, 1, neta))\\n idx = (eta_array > eta_min) & (eta_array < eta_max)\\n vn_ref = (sum(dN_array[:, :, idx]*vn_array[:, :, idx], axis=2)\\n /(sum(dN_array[:, :, idx], axis=2) + 1e-15))\\n vnshape = vn_ref.shape\\n nvn = vnshape[1]\\n vn_ref = vn_ref.reshape((vnshape[0], vnshape[1], 1))\\n vn_SP_ev = real(vn_array*conj(vn_ref))\\n vn_SP_array = zeros([nev, nvn, neta])\\n for iev in range(nev):\\n array_idx = [True]*nev\\n array_idx[iev] = False\\n array_idx = array(array_idx)\\n vn_den = mean((absolute(vn_ref[array_idx, :, :]))**2., axis=0)\\n vn_SP = (mean(vn_SP_ev[array_idx, :, :], axis=0)\\n /(sqrt(vn_den) + 1e-16))\\n vn_SP_array[iev, :, :] = vn_SP\\n vn_SP_mean = mean(vn_SP_array, axis=0)\\n vn_SP_err = sqrt((nev - 1.)/nev*sum((vn_SP_array - vn_SP_mean)**2., axis=0))\\n return([vn_SP_mean, vn_SP_err])\",\n \"def run_test(d):\\n\\n ######### Problem Specification\\n\\n # Data generation parameters\\n prior_mu_z = np.zeros(d, dtype=np.float32) # Prior mean\\n prior_sigma_z = np.eye(d, dtype=np.float32) # Prior covariance matrix\\n\\n # True model parameters\\n num_range = np.arange(-(d-1)/2, (d+1)/2, dtype=np.float32)\\n\\n t_delta = num_range / 5 \\n\\n if d == 1:\\n t_sigma = np.ones(1)\\n else: \\n # Allow sigma to range from 0.1 to 1\\n t_sigma = 36/(10*(d-1)**2) * num_range**2 + 0.1 \\n\\n ######### Variable Initialization\\n\\n # Initial model parameters - same across all methods\\n init_delta = prior_mu_z.copy()\\n init_log_sigma = 3 * np.ones(d)\\n\\n # Initial HVAE variational parameters\\n init_T = 5.\\n init_eps = 0.005 * np.ones(d)\\n max_eps = params['max_eps'] * np.ones(d)\\n init_logit_eps = np.log(init_eps/(max_eps - init_eps))\\n init_log_T_0 = np.log(init_T - 1)\\n\\n # Initial NF variational parameters\\n init_u_pre_reparam = scipy.stats.truncnorm.rvs(-2, 2, scale=0.1, size=d)\\n init_w = scipy.stats.truncnorm.rvs(-2, 2, scale=0.1, size=d)\\n init_b = 0.1\\n\\n # Initial VAE parameters\\n init_mu_z = prior_mu_z.copy()\\n init_log_sigma_z = np.ones(d)\\n\\n ######### Set up models\\n\\n HVAE_model_1 = HVAE(\\n ['delta', 'log_sigma', 'logit_eps', 'log_T_0'],\\n [init_delta, init_log_sigma, init_logit_eps, init_log_T_0], \\n 'HVAE_1', d, params['HVAE_K_1'])\\n HVAE_model_2 = HVAE(\\n ['delta', 'log_sigma', 'logit_eps', 'log_T_0'],\\n [init_delta, init_log_sigma, init_logit_eps, init_log_T_0], \\n 'HVAE_2', d, params['HVAE_K_2'])\\n\\n HVAE_model_notemp_1 = HVAE(\\n ['delta', 'log_sigma', 'logit_eps'],\\n [init_delta, init_log_sigma, init_logit_eps], \\n 'HVAE_notemp_1', d, params['HVAE_K_1'])\\n HVAE_model_notemp_2 = HVAE(\\n ['delta', 'log_sigma', 'logit_eps'], \\n [init_delta, init_log_sigma, init_logit_eps],\\n 'HVAE_notemp_2', d, params['HVAE_K_2'])\\n\\n NF_model_1 = NF(\\n ['delta', 'log_sigma', 'u_pre_reparam', 'w', 'b'],\\n [init_delta, init_log_sigma, init_u_pre_reparam, init_w, init_b],\\n 'NF_1', d, params['NF_K_1'])\\n NF_model_2 = NF(\\n ['delta', 'log_sigma', 'u_pre_reparam', 'w', 'b'],\\n [init_delta, init_log_sigma, init_u_pre_reparam, init_w, init_b],\\n 'NF_2', d, params['NF_K_2'])\\n\\n VB_model = VB(['delta', 'log_sigma', 'mu_z', 'log_sigma_z'], \\n [init_delta, init_log_sigma, init_mu_z, init_log_sigma_z], 'VB', d)\\n\\n model_list = [HVAE_model_1, HVAE_model_2, HVAE_model_notemp_1, \\n HVAE_model_notemp_2, NF_model_1, NF_model_2, VB_model]\\n \\n ######### Generate Training Data & Save - One for each test\\n\\n train_data_list = []\\n\\n for i in range(params['n_tests']):\\n z = np.random.multivariate_normal(prior_mu_z, prior_sigma_z)\\n x = np.random.multivariate_normal(z + t_delta, np.diag(t_sigma**2), \\n size=params['n_data'])\\n train_data_list.append(x)\\n\\n # Folder should have already been created in the initializations\\n data_path = os.path.join('save', str(d), 'train_data.p')\\n pickle.dump(train_data_list, open(data_path, 'wb')) \\n\\n ######### Train models\\n\\n sess = tf.Session()\\n sess.run(tf.global_variables_initializer())\\n\\n # Store the final parameter values for all test runs in this dictionary\\n final_params = {}\\n\\n for m in model_list:\\n\\n final_values = []\\n\\n for i in range(params['n_tests']):\\n (delta, sigma) = m.train(sess, train_data_list[i], i)\\n final_values.append((delta, sigma))\\n\\n final_params[m.model_name] = final_values.copy()\\n\\n ######### Test models using difference between parameters\\n\\n param_diffs = {}\\n\\n for m in model_list:\\n\\n diffs = []\\n\\n for i in range(params['n_tests']):\\n delta = final_params[m.model_name][i][0]\\n sigma = final_params[m.model_name][i][1]\\n\\n delta_diff = np.sum((delta - t_delta)**2)\\n sigma_diff = np.sum((sigma - t_sigma)**2)\\n\\n diffs.append((delta_diff, sigma_diff))\\n\\n param_diffs[m.model_name] = diffs.copy()\\n\\n # Save parameter differences in a pickle file\\n diff_path = os.path.join('save', str(d), 'all_diffs.p')\\n pickle.dump(param_diffs, open(diff_path, 'wb'))\",\n \"def davidson_solver(ax_function, preconditioner, guess, e_conv=1.0E-8, r_conv=None, no_eigs=1, max_vecs_per_root=10, maxiter=100):\\n\\n if r_conv == None:\\n r_conv = e_conv * 100\\n d_tol = 1.0E-8\\n\\n # using the shape of the guess vectors to set the dimension of the matrix\\n N = guess.shape[0]\\n\\n #sanity check, guess subspace must be at least equal to number of eigenvalues\\n nli = guess.shape[1]\\n if nli < no_eigs:\\n raise ValueError(\\\"Not enough guess vectors provided!\\\")\\n\\n nl = nli\\n converged=False\\n count = 0\\n sub_count = nli\\n A_w_old = np.ones(nli)\\n max_ss_size = nli * max_vecs_per_root\\n B = np.zeros((N,N))\\n B[:,:nli] = guess\\n\\n ### begin loop\\n while count < maxiter:\\n active_mask = [True for x in range(nl)]\\n # Apply QR decomposition on B to orthogonalize the new vectors wrto all other subspace vectors\\n ## orthogonalize preconditioned residuals against all other vectors in the search subspace\\n B, r = np.linalg.qr(B)\\n\\n # compute sigma vectors corresponding to the new vectors sigma_i = A B_i\\n sigma = np.zeros((N,nl))\\n for i in range(nl):\\n bvec = B[:,i]\\n sigma[:,i] = ax_function(B[:,i])\\n\\n # compute subspace matrix A_b = Btranspose sigma\\n A_b = np.dot(B[:,:nl].T, sigma)\\n\\n # solve eigenvalue problem for subspace matrix; choose n lowest eigenvalue eigpairs\\n A_w, A_v = np.linalg.eig(A_b)\\n\\n # sorting eigenvalues and corresponding eigenvectors\\n A_v = A_v[:, A_w.argsort()]\\n A_w = A_w[A_w.argsort()]\\n\\n # here, check if no residuals > max no residuals, if so, collapse subspace\\n sub_count = A_v.shape[0]\\n if sub_count >= max_ss_size:\\n print(\\\"Subspace too big. Collapsing.\\\\n\\\")\\n Bnew = np.zeros((N,N))\\n Bnew[:,:nli] = np.dot(B[:,:nl], A_v[:,:nli])\\n B = Bnew\\n nl = nli\\n continue\\n # else, build residual matrix\\n ## residual_i = sigma * eigvec - eigval * B * eigvec\\n norm = np.zeros(nli)\\n for i in range(0, nli):\\n mat = A - A_w[i] * np.identity(N) \\n residual = np.dot(mat, np.dot(B[:,:sub_count], A_v[:,i]))\\n\\n ## check for convergence by norm of residuals\\n norm[i] = np.linalg.norm(residual)\\n ##apply the preconditioner (A_ii - A_v_i)^-1\\n precon_resid = preconditioner(residual, i, A, A_w)\\n\\n ## normalize and add to search subspace if they're larger than a threshold\\n if np.linalg.norm(precon_resid) > d_tol:\\n B[:,nl+1] = precon_resid\\n nl += 1\\n\\n # check for convergence by diff of eigvals and residual norms\\n check = norm < r_conv\\n eig_norm = np.linalg.norm(A_w[:no_eigs] - A_w_old[:no_eigs])\\n A_w_old = A_w\\n if(check.all() == True and eig_norm < e_conv):\\n converged = True\\n break\\n count += 1 \\n\\n if converged:\\n print(\\\"Davidson converged at iteration number {}. \\\\n Eigenvalues: {} \\\\n Eigenvectors: {}\\\".format(count, A_w[:no_eigs], A_v[:,:no_eigs]))\\n else:\\n print(\\\"Davidson did not converge. Max iterations exceeded.\\\")\",\n \"def run(self):\\n self.errList = []\\n self.initialize()\\n\\n for i in range(self.maxiter):\\n # update U\\n for k in range(self.K):\\n [p, sigma, q] = np.linalg.svd(self.H.dot(self.S[:, :, k]).dot(self.V.T).dot(self.X[k].T),\\n full_matrices=False)\\n self.U[k] = q.T.dot(p.T)\\n self.U[k] = self.U[k].real\\n\\n # calculate temporal variable y\\n y = np.zeros([self.rank, self.L, self.K])\\n for k in range(self.K):\\n y[:, :, k] = self.U[k].T.dot(self.X[k])\\n\\n # get H, V, and temps by running a single iteration of CP_ALS\\n if i == 0:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1, printitn=0)\\n else:\\n [cp, rec] = pyten.method.cp_als(pyten.tenclass.Tensor(y),\\n self.rank, tol=self.tol, maxiter=1,\\n init=[self.H, self.V, temps], printitn=0)\\n self.H = cp.Us[0]\\n self.V = cp.Us[1]\\n temps = cp.Us[2].dot(np.diag(cp.lmbda))\\n\\n # update S\\n for k in range(self.K):\\n self.S[:, :, k] = np.diag(temps[k, :])\\n\\n # checking the stop criteria\\n # error = 0\\n for k in range(self.K):\\n temp = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\\n self.sigma_new += np.linalg.norm(temp - self.X[k]) ** 2\\n\\n error = abs(self.sigma_new - self.sigma_old) #/ self.sigma_old\\n self.errList.append(error)\\n if (i + 1) % self.printitn == 0:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n elif error < self.tol:\\n print 'PARAFAC2: iterations={0}, difference={1}, fit_difference={2}'.format(i + 1, self.errList[-1],\\n self.sigma_new)\\n\\n if error < self.tol:\\n break\\n else:\\n self.sigma_old = self.sigma_new\\n self.sigma_new = 0\\n\\n for k in range(self.K):\\n self.fit[k] = self.U[k].dot(self.H).dot(self.S[:, :, k]).dot(self.V.T)\",\n \"def iterations(self):\\n i = 0\\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\\n n = len(self.model.stateVector)\\n self.answer = None\\n \\n while ((i < self.maxiter) \\n and (stateVectorConv > self.stateVectorConvThreshold)\\n ):\\n \\n F, K = self.model()\\n \\n if np.any(np.isnan(F)) or np.any(np.isnan(K)):\\n m = \\\"Iteration {0} failure of model.\\\"\\n raise OptimalEstimationException(m.format(i))\\n \\n if self.model.verbose > 0:\\n self.model.plot(i+1, stateVectorConv)\\n \\n try:\\n self.DecomposeJacobian(K)\\n except np.linalg.LinAlgError:\\n m = \\\"Iteration {0} failure in decomposition.\\\"\\n raise OptimalEstimationException(m.format(i))\\n \\n statevectorOffset = (self.V.T * self.priorSinvh * \\n np.matrix(np.array(self.model.stateVector) - np.array(self.model.prior) ).T)\\n measurementOffset = (self.U.T * self.errSinvh * \\n np.matrix(self.model.observation - F).T)\\n \\n newState = np.matrix((self.w * \\n (measurementOffset.A1 + \\n self.w * statevectorOffset.A1))/(self.w**2+1.0)).T\\n newState = self.priorSh * self.V * newState\\n newState = newState.A1 + self.model.prior\\n \\n stateVectorConv = ((np.matrix(newState - self.model.stateVector) * \\n self.Sinv * np.matrix(newState - self.model.stateVector).T)/n)[0,0]\\n self.model.stateVector = newState\\n\\n if i == 0:\\n \\n stateVectorConv = self.stateVectorConvThreshold * 1.0e6\\n \\n print('cost Function for iteration {}:'.format(i), self.costFunction)\\n\\n i += 1\\n \\n F, K = self.model()\\n if self.model.verbose > 0:\\n self.model.plot(i+1, stateVectorConv)\\n \\n try:\\n self.DecomposeJacobian(K)\\n except np.linalg.LinAlgError:\\n raise OptimalEstimationException(\\\"Failure in decomposition.\\\")\\n \\n Wplus2 = np.matrix(np.diag(1.0/(self.w**2+1.0)))\\n self.model.covariance = (self.priorSh * self.V * Wplus2 * \\n self.V.T * self.priorSh)\\n \\n\\n \\n return i, stateVectorConv\",\n \"def calculate_nonlinear_reponse(vn_array, outputFileName):\\n chi_422, chi_422_err = calculate_chi_422(vn_array)\\n v4_Psi2, v4_Psi2_err = calculate_v4_Psi2(chi_422, chi_422_err, vn_array)\\n rho_422, rho_422_err = calculate_rho_422(v4_Psi2, v4_Psi2_err, vn_array)\\n v4_L, v4_L_err = calculate_v4_L(v4_Psi2, v4_Psi2_err, vn_array)\\n\\n chi_523, chi_523_err = calculate_chi_523(vn_array)\\n v5_Psi23, v5_Psi23_err = calculate_v5_Psi23(chi_523, chi_523_err, vn_array)\\n rho_523, rho_523_err = calculate_rho_523(v5_Psi23, v5_Psi23_err, vn_array)\\n v5_L, v5_L_err = calculate_v5_L(v5_Psi23, v5_Psi23_err, vn_array)\\n\\n chi_6222, chi_6222_err = calculate_chi_6222(vn_array)\\n v6_Psi2, v6_Psi2_err = calculate_v6_Psi2(chi_6222, chi_6222_err, vn_array)\\n rho_6222, rho_6222_err = calculate_rho_6222(v6_Psi2, v6_Psi2_err, vn_array)\\n\\n chi_633, chi_633_err = calculate_chi_633(vn_array)\\n v6_Psi3, v6_Psi3_err = calculate_v6_Psi3(chi_633, chi_633_err, vn_array)\\n rho_633, rho_633_err = calculate_rho_633(v6_Psi3, v6_Psi3_err, vn_array)\\n v6_L, v6_L_err = calculate_v6_L(chi_6222, chi_6222_err,\\n chi_633, chi_633_err, vn_array)\\n\\n results = [v4_L, v4_L_err, v4_Psi2, v4_Psi2_err, rho_422, rho_422_err,\\n chi_422, chi_422_err,\\n v5_L, v5_L_err, v5_Psi23, v5_Psi23_err, rho_523, rho_523_err,\\n chi_523, chi_523_err,\\n v6_L, v6_L_err, v6_Psi2, v6_Psi2_err, v6_Psi3, v6_Psi3_err,\\n rho_6222, rho_6222_err, rho_633, rho_633_err,\\n chi_6222, chi_6222_err, chi_633, chi_633_err]\\n f = open(outputFileName, 'w')\\n f.write(\\\"# type value stat. err\\\\n\\\")\\n for i in range(len(nonlinear_reponse_correlator_name_list)):\\n f.write(\\\"%s %.10e %.10e\\\\n\\\"\\n % (nonlinear_reponse_correlator_name_list[i],\\n results[2*i], results[2*i+1]))\\n f.close()\\n return\",\n \"def calculate_rn_eta(eta_array, dN_array, vn_array, outputFileName):\\n nev, neta = dN_array.shape\\n dN_array = dN_array.reshape((nev, 1, neta))\\n Qn_array = vn_array\\n Qnshape = Qn_array.shape\\n nQn = Qnshape[1]\\n\\n # calculate the reference flow vector for every event\\n eta_b_min = 2.5\\n eta_b_max = 4.0\\n eta_ref1_tmp = linspace(eta_b_min, eta_b_max, 16)\\n eta_ref2_tmp = linspace(-eta_b_max, -eta_b_min, 16)\\n Qn_ref1 = [] \\n Qn_ref2 = [] \\n for iev in range(nev):\\n dN1_interp = interp(eta_ref1_tmp, eta_array, dN_array[iev, 0, :])\\n dN2_interp = interp(eta_ref2_tmp, eta_array, dN_array[iev, 0, :])\\n Qn_ref1_vec = []\\n Qn_ref2_vec = []\\n for iorder in range(nQn):\\n Qn1_interp = interp(eta_ref1_tmp, eta_array,\\n Qn_array[iev, iorder, :])\\n Qn2_interp = interp(eta_ref2_tmp, eta_array,\\n Qn_array[iev, iorder, :])\\n Qn_ref1_vec.append(sum(dN1_interp*Qn1_interp)\\n /(sum(dN1_interp) + 1e-15))\\n Qn_ref2_vec.append(sum(dN2_interp*Qn2_interp)\\n /(sum(dN2_interp) + 1e-15))\\n Qn_ref1.append(Qn_ref1_vec)\\n Qn_ref2.append(Qn_ref2_vec)\\n Qn_ref1 = array(Qn_ref1).reshape((nev, nQn, 1))\\n Qn_ref2 = array(Qn_ref2).reshape((nev, nQn, 1))\\n\\n rn_num = real(Qn_array[:, :, ::-1]*conj(Qn_ref1))\\n rn_den = real(Qn_array*conj(Qn_ref1))\\n rnn_num = real((Qn_ref2*conj(Qn_array))\\n *(Qn_array[:, :, ::-1]*conj(Qn_ref1)))\\n rnn_den = real((Qn_ref2*conj(Qn_array[:, :, ::-1]))\\n *(Qn_array*conj(Qn_ref1)))\\n\\n # compute the error using jack-knife\\n rn_array = zeros([nev, nQn, neta])\\n rnn_array = zeros([nev, nQn, neta])\\n for iev in range(nev):\\n array_idx = [True]*nev\\n array_idx[iev] = False\\n array_idx = array(array_idx)\\n rn_ev = (mean(rn_num[array_idx], axis=0)\\n /(mean(rn_den[array_idx], axis=0) + 1e-15))\\n rnn_ev = (mean(rnn_num[array_idx], axis=0)\\n /(mean(rnn_den[array_idx], axis=0) + 1e-15))\\n rn_array[iev, :, :] = rn_ev\\n rnn_array[iev, :, :] = rnn_ev\\n rn_mean = mean(rn_array, axis=0)\\n rn_err = sqrt((nev - 1.)/nev*sum((rn_array - rn_mean)**2., axis=0))\\n rnn_mean = mean(rnn_array, axis=0)\\n rnn_err = sqrt((nev - 1.)/nev*sum((rnn_array - rnn_mean)**2., axis=0))\\n\\n f = open(outputFileName, 'w')\\n f.write(\\\"#eta rn(eta) rn_err(eta) rnn(eta) rnn_err(eta)\\\\n\\\")\\n for ieta in range(len(eta_array)-1):\\n f.write(\\\"%.10e \\\" % eta_array[ieta])\\n for iorder in range(0, n_order-1):\\n f.write(\\\"%.10e %.10e %.10e %.10e \\\"\\n % (rn_mean[iorder, ieta], rn_err[iorder, ieta],\\n rnn_mean[iorder, ieta], rnn_err[iorder, ieta]))\\n f.write(\\\"\\\\n\\\")\\n f.close()\\n return\",\n \"def test_solvers():\\n # With P1 elements we have an error E-15 with Krylov solver\\n # tolerances of 1E-12, but with P2 elements the error is E-6.\\n # P3 elements drive the tolerance down to E-3.\\n # For higher mesh resolution we also need reduced tolerances.\\n # The tol dict maps degree to expected tolerance for the coarse\\n # meshes in the test.\\n tol = {'direct': {1: 1E-11, 2: 1E-11, 3: 1E-11},\\n 'Krylov': {1: 1E-14, 2: 1E-05, 3: 1E-03}}\\n u_D = Expression('1 + x[0]*x[0] + 2*x[1]*x[1]')\\n kappa = Expression('x[0] + x[1]')\\n f = Expression('-8*x[0] - 10*x[1]')\\n for Nx, Ny in [(3,3), (3,5), (5,3)]:\\n for degree in 1, 2, 3:\\n for linear_solver in 'direct', 'Krylov':\\n for solver_func in solver, solver_objects:\\n print('solving on 2(%dx%dx) mesh with P%d elements'\\n % (Nx, Ny, degree)),\\n print(' %s solver, %s function' %\\n (linear_solver, solver_func.__name__))\\n # Important: Krylov solver error must be smaller\\n # than tol!\\n u = solver_func(\\n kappa, f, u_D, Nx, Ny, degree,\\n linear_solver=linear_solver,\\n abs_tol=0.1*tol[linear_solver][degree],\\n rel_tol=0.1*tol[linear_solver][degree])\\n # Make a finite element function of the exact u_D\\n V = u.function_space()\\n u_D_Function = interpolate(u_D, V) # exact solution\\n # Check that dof arrays are equal\\n u_D_array = u_D_Function.vector().array() # dof values\\n max_error = (u_D_array - u.vector().array()).max()\\n msg = 'max error: %g for 2(%dx%d) mesh, degree=%d,'\\\\\\n ' %s solver, %s' % \\\\\\n (max_error, Nx, Ny, degree, linear_solver,\\n solver_func.__name__)\\n print(msg)\\n assert max_error < tol[linear_solver][degree], msg\",\n \"def v(resistances, r_i, applied_voltages, **kwargs):\\n if r_i.word_line > 0 or r_i.bit_line > 0:\\n g = fill.g(resistances, r_i)\\n i = fill.i(applied_voltages, resistances, r_i)\\n\\n utils.message('Started solving for v.', **kwargs)\\n v_matrix = linalg.spsolve(g.tocsc(), i)\\n utils.message('Solved for v.', **kwargs)\\n\\n # if `num_examples == 1`, it can result in 1D array.\\n if v_matrix.ndim == 1:\\n v_matrix = v_matrix.reshape(v_matrix.shape[0], 1)\\n\\n # if one of the interconnect resistances is zero, only half of the\\n # matrix_v had to be solved. The other half can be filled without\\n # solving because the node voltages are known.\\n if r_i.word_line == 0:\\n new_v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n new_v_matrix[:resistances.size, ] = np.repeat(\\n applied_voltages, resistances.shape[1], axis=0)\\n new_v_matrix[resistances.size:, ] = v_matrix\\n v_matrix = new_v_matrix\\n if r_i.bit_line == 0:\\n new_v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n new_v_matrix[:resistances.size, ] = v_matrix\\n v_matrix = new_v_matrix\\n else:\\n # if both interconnect resistances are zero, all node voltages are\\n # known.\\n v_matrix = np.zeros(\\n (2*resistances.size, applied_voltages.shape[1]))\\n v_matrix[:resistances.size, ] = np.repeat(\\n applied_voltages, resistances.shape[1], axis=0)\\n\\n return v_matrix\",\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 iter_vs_cnum(solver, n_range=None, cnum_range=None, verbose=0, \\\\\\n construct_args=dict(), solve_args=dict() ):\\n if n_range is None:\\n n_range = range(50, 501, 50)\\n if cnum_range is None:\\n cnum_range = [10**i for i in range(1,10)]\\n\\n n_mats = len(n_range) * len(cnum_range)\\n print('Evaluating %d matrices' % n_mats)\\n\\n results = dict()\\n\\n # Construct solver instance\\n solver_ = solver(A=None, b=None, full_output=1, **construct_args)\\n\\n for n in n_range:\\n results[n] = []\\n plt.figure()\\n plt.title('Size: %d by %d' % (n, n))\\n for cond_num in cnum_range:\\n if verbose: print('n: %d cnum: %d' % (n, cond_num))\\n\\n #A = util.psd_from_cond(cond_num=cond_num, n=n)\\n A = psd_from_cond(cond_num=cond_num, n=n)\\n x_true = 4 * np.random.randn(n)\\n b = np.dot(A, x_true)\\n\\n if verbose: print('Initial resid error: %f' % la.norm(b))\\n\\n\\n solver_.A, solver_.b = A, b\\n xopt, n_iter, resids, x_difs = solver_.solve(x_true=x_true, max_iter = n*2, \\\\\\n **solve_args)\\n results[n].append(n_iter)\\n\\n if verbose:\\n print('Final resid error: %f' % la.norm(b - np.dot(A, xopt)))\\n print('Took %d iter' % n_iter)\\n\\n return results\",\n \"def runpower_one(matrix, n):\\n\\t#get initial vector\\n\\tv = np.zeros(n)\\n\\tw = np.zeros(n)\\n\\tfor j in range(n):\\n\\t\\tv[j] = np.random.uniform(0,1)\\n\\t#print 'matrix', matrix\\n\\t#print 'v', v\\n\\tT = 10000 #number of iterations\\n\\ttol = 1e-06\\n\\toldnormw = 0\\n\\tfor t in range(T):\\n\\t\\tw = matrix.dot(v)\\n\\t\\t#print 't', t, 'w',w\\n\\t\\tnormw = (np.inner(w,w))**.5\\n\\t\\tv = w/normw\\n\\t\\t#print 't',t,'v',v\\n\\t\\t#print 't',t,'normw',normw, 'old', oldnormw\\n\\t\\tif np.abs(normw - oldnormw)/normw < tol:\\n\\t\\t\\t#print ' breaking'\\n\\t\\t\\tbreak\\n\\t\\toldnormw = normw\\n\\treturn normw, v\",\n \"def value_iteration(vision, n_tongs):\\n q_value = np.zeros([11, 11, 4, 3], dtype=np.float32)\\n for _ in range(1000):\\n delta = 0\\n for px in range(11):\\n for py in range(11):\\n item = recognize_item(px, py, vision)\\n # Not update for locations collecting items, to avoid endless loops.\\n if (item == 'diamond' and n_tongs > 0) or item == 'tongs' or item == 'jellybean':\\n continue\\n q_new = np.zeros([4, 3], dtype=np.float32)\\n for d in range(4):\\n for a in range(3):\\n px_next, py_next, d_next, r = simulate_step(px, py, d, a, vision, n_tongs)\\n q_new[d, a] = r\\n if 0 <= px_next < 11 and 0 <= py_next < 11: # next position in vision\\n q_new[d, a] += np.max(q_value[px_next, py_next, d_next])\\n delta = max(delta, norm(q_new - q_value[px, py], ord=np.inf))\\n q_value[px, py] = q_new\\n if delta < 1e-3:\\n break\\n return q_value\",\n \"def calibration(N,kb,T,Ekinv,V):\\n lamb = np.sqrt((N-1)*3*kb*T/(Ekinv*2))\\n \\n if lamb < 0.9999:\\n V = lamb*V\\n elif lamb>1.0001:\\n V = lamb*V\\n \\n return V\",\n \"def _arnoldi_fact(matvec, args, v0, krylov_vectors, H, start, num_krylov_vecs,\\n eps):\\n Z = jax.numpy.linalg.norm(v0)\\n v = v0 / Z\\n krylov_vectors = jax.ops.index_update(krylov_vectors,\\n jax.ops.index[start, :],\\n jax.numpy.ravel(v))\\n H = jax.lax.cond(\\n start > 0, start,\\n lambda x: jax.ops.index_update(H, jax.ops.index[x, x - 1], Z), None,\\n lambda x: H)\\n\\n # body of the arnoldi iteration\\n def body(vals):\\n krylov_vectors, H, matvec, vector, _, threshold, i, maxiter = vals\\n Av = matvec(vector, *args)\\n initial_vals = [Av, krylov_vectors, i, H]\\n Av, krylov_vectors, _, H = jax.lax.fori_loop(\\n 0, i + 1, modified_gram_schmidt_step_arnoldi, initial_vals)\\n norm = jax.numpy.linalg.norm(Av)\\n Av /= norm\\n H = jax.ops.index_update(H, jax.ops.index[i + 1, i], norm)\\n krylov_vectors = jax.ops.index_update(krylov_vectors,\\n jax.ops.index[i + 1, :],\\n jax.numpy.ravel(Av))\\n return [krylov_vectors, H, matvec, Av, norm, threshold, i + 1, maxiter]\\n\\n def cond_fun(vals):\\n # Continue loop while iteration < num_krylov_vecs and norm > eps\\n _, _, _, _, norm, _, iteration, _ = vals\\n counter_done = (iteration >= num_krylov_vecs)\\n norm_not_too_small = norm > eps\\n continue_iteration = jax.lax.cond(counter_done,\\n _, lambda x: False,\\n _, lambda x: norm_not_too_small)\\n\\n return continue_iteration\\n initial_norm = v.real.dtype.type(1.0+eps)\\n initial_values = [krylov_vectors, H, matvec, v, initial_norm, eps, start,\\n num_krylov_vecs]\\n final_values = jax.lax.while_loop(cond_fun, body, initial_values)\\n kvfinal, Hfinal, _, _, norm, _, it, _ = final_values\\n return kvfinal, Hfinal, it, norm < eps\",\n \"def gs(self, k=50):\\n # a. initialize V1 to Vk as a matrix of zeros\\n Vs = np.zeros((k, self.ATA.shape[0]), dtype=float)\\n\\n # initialize u_n as first eigen vector?\\n # un = self.eigen_vectors[0]\\n\\n # looking for k largest eigenvalues and associated eigenvectors\\n # of ATA\\n # b. for i = 1 to k\\n for i in tqdm(range(len(Vs))):\\n print(\\\"Doing i\\\")\\n\\n # i. randomly generated vector of size m\\n # (length of latitudes, in this case?)\\n # scale entire vector by its magnitude, to make magnitude = 1\\n u1 = scale_mag_1(np.random.rand(self.ATA.shape[0]))\\n un = u1 # at first, u_n is u_1 and random\\n\\n diff = 1 # set initial diff too high to trip while loop\\n while diff > 1e-3:\\n\\n print(\\\"Doing ii\\\")\\n # ii. u_(n+1) = A^T*A*u_n\\n u1more = np.dot(self.ATA, un)\\n\\n print(\\\"Doing iii\\\")\\n # iii. u_(n+1) = u_(n+1) - Sigma_j^(i-1)(u_(n+1)^T * V_j) * V_j\\n u1more = u1more - np.sum([\\n np.dot(np.dot(u1more.T, Vs[j]), Vs[j]) for j in range(i)\\n ])\\n\\n print(\\\"Doing iv\\\")\\n # iv. u_(n+1) = u_(n+1) / || u_(n+1) ||\\n # just norm mag\\n u1more = scale_mag_1(u1more)\\n\\n diff = mag(u1more - un)\\n print(\\\"Diff:\\\", diff)\\n\\n un = u1more\\n\\n Vs[i] = un\",\n \"def run_exact(self):\\n self.operator, var_form, opt = self.generate_VQE_args()\\n\\n exact_eigensolver = ExactEigensolver(self.operator, k=1)\\n self.result = exact_eigensolver.run()\\n\\n solution = self.extract_solution(self.result, True)\\n return solution\",\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 solve(n_vec, m_vec, p_vec, repeat, dns_level, seed, solver='gurobi'):\\n\\n print(\\\"Solving random problems with solver %s\\\\n\\\" % solver)\\n\\n # Define statistics to record\\n std_solve_time = np.zeros(len(n_vec))\\n avg_solve_time = np.zeros(len(n_vec))\\n min_solve_time = np.zeros(len(n_vec))\\n max_solve_time = np.zeros(len(n_vec))\\n\\n n_prob = len(n_vec)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n # Add OSQP solve times statistics\\n avg_osqp_solve_time = np.zeros(len(n_vec))\\n\\n # reset random seed\\n np.random.seed(seed)\\n\\n for i in range(n_prob):\\n\\n # Get dimensions\\n n = n_vec[i]\\n m = m_vec[i]\\n p = p_vec[i]\\n\\n print(\\\"problem n = %i, m = %i, p = %i\\\" % (n, m, p))\\n\\n # Define vector of cpu times\\n solve_time_temp = np.zeros(repeat)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n osqp_solve_time_temp = np.zeros(repeat)\\n\\n for j in tqdm(range(repeat)):\\n # for j in range(repeat):\\n\\n # Generate random vector of indeces\\n i_idx = np.random.choice(np.arange(0, n), p, replace=False)\\n\\n # Generate random Matrices\\n Pt = spa.random(n, n, density=dns_level)\\n P = spa.csc_matrix(np.dot(Pt, Pt.T))\\n q = sp.randn(n)\\n A = spa.random(m, n, density=dns_level)\\n u = 2 + sp.rand(m)\\n l = -2 + sp.rand(m)\\n\\n # Enforce [0, 1] bounds on variables\\n i_l = np.zeros(p)\\n i_u = np.ones(p)\\n # A, l, u = miosqp.add_bounds(i_idx, 0., 1., A, l, u)\\n\\n if solver == 'gurobi':\\n # Solve with gurobi\\n prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\\n res_gurobi = prob.solve(solver=mpbpy.GUROBI,\\n verbose=False, Threads=1)\\n if res_gurobi.status != 'optimal':\\n import ipdb\\n ipdb.set_trace()\\n solve_time_temp[j] = 1e3 * res_gurobi.cputime\\n\\n elif solver == 'miosqp':\\n # Define problem settings\\n miosqp_settings = {\\n # integer feasibility tolerance\\n 'eps_int_feas': 1e-03,\\n # maximum number of iterations\\n 'max_iter_bb': 1000,\\n # tree exploration rule\\n # [0] depth first\\n # [1] two-phase: depth first until first incumbent and then best bound\\n 'tree_explor_rule': 1,\\n # branching rule\\n # [0] max fractional part\\n 'branching_rule': 0,\\n 'verbose': False,\\n 'print_interval': 1}\\n\\n osqp_settings = {'eps_abs': 1e-03,\\n 'eps_rel': 1e-03,\\n 'eps_prim_inf': 1e-04,\\n 'verbose': False}\\n\\n model = miosqp.MIOSQP()\\n model.setup(P, q, A, l, u, i_idx, i_l, i_u,\\n miosqp_settings,\\n osqp_settings)\\n res_miosqp = model.solve()\\n\\n # DEBUG (check if solutions match)\\n # prob = mpbpy.QuadprogProblem(P, q, A, l, u, i_idx, i_l, i_u)\\n # res_gurobi = prob.solve(solver=mpbpy.GUROBI, verbose=False)\\n # if (np.linalg.norm(res_gurobi.x - res_miosqp.x) /\\n # np.linalg.norm(res_gurobi.x)) > 1e-02:\\n # import ipdb; ipdb.set_trace()\\n#\\n # import ipdb; ipdb.set_trace()\\n\\n if res_miosqp.status != miosqp.MI_SOLVED:\\n import ipdb\\n ipdb.set_trace()\\n \\n # Solution time \\n solve_time_temp[j] = 1e3 * res_miosqp.run_time\\n\\n # Store OSQP time in percentage\\n if solver == 'miosqp':\\n osqp_solve_time_temp[j] = \\\\\\n 100 * (res_miosqp.osqp_solve_time / res_miosqp.run_time)\\n\\n # Get time statistics\\n std_solve_time[i] = np.std(solve_time_temp)\\n avg_solve_time[i] = np.mean(solve_time_temp)\\n max_solve_time[i] = np.max(solve_time_temp)\\n min_solve_time[i] = np.min(solve_time_temp)\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n avg_osqp_solve_time[i] = np.mean(osqp_solve_time_temp)\\n\\n # Create pandas dataframe for the results\\n df_dict = {'n': n_vec,\\n 'm': m_vec,\\n 'p': p_vec,\\n 't_min': min_solve_time,\\n 't_max': max_solve_time,\\n 't_avg': avg_solve_time,\\n 't_std': std_solve_time}\\n\\n # Store also OSQP time\\n if solver == 'miosqp':\\n df_dict.update({'t_osqp_avg': avg_osqp_solve_time})\\n\\n timings = pd.DataFrame(df_dict)\\n\\n return timings\",\n \"def calculate_vn4(vn_data_array, outputFileName):\\n vn_data_array = array(vn_data_array)\\n nev = len(vn_data_array[:, 0])\\n dN = real(vn_data_array[:, 0])\\n Q1 = dN*vn_data_array[:, 1]\\n Q2 = dN*vn_data_array[:, 2]\\n Q3 = dN*vn_data_array[:, 3]\\n Q4 = dN*vn_data_array[:, 4]\\n Q5 = dN*vn_data_array[:, 5]\\n Q6 = dN*vn_data_array[:, 6]\\n\\n # two-particle correlation\\n N2_weight = dN*(dN - 1.)\\n Q1_2 = abs(Q1)**2. - dN\\n Q2_2 = abs(Q2)**2. - dN\\n Q3_2 = abs(Q3)**2. - dN\\n\\n # four-particle correlation\\n N4_weight = dN*(dN - 1.)*(dN - 2.)*(dN - 3.)\\n Q1_4 = ((abs(Q1)**4.) - 2.*real(Q2*conj(Q1)*conj(Q1))\\n - 4.*(dN - 2.)*(abs(Q1)**2.) + abs(Q2)**2.\\n + 2*dN*(dN - 3.))\\n Q2_4 = ((abs(Q2)**4.) - 2.*real(Q4*conj(Q2)*conj(Q2))\\n - 4.*(dN - 2.)*(abs(Q2)**2.) + abs(Q4)**2.\\n + 2*dN*(dN - 3.))\\n Q3_4 = ((abs(Q3)**4.) - 2.*real(Q6*conj(Q3)*conj(Q3))\\n - 4.*(dN - 2.)*(abs(Q3)**2.) + abs(Q6)**2.\\n + 2*dN*(dN - 3.))\\n\\n # calcualte observables with Jackknife resampling method\\n C1_4_array = zeros(nev)\\n C2_4_array = zeros(nev)\\n C3_4_array = zeros(nev)\\n for iev in range(nev):\\n array_idx = [True]*nev\\n array_idx[iev] = False\\n array_idx = array(array_idx)\\n\\n # C_1{4}\\n C1_4_array[iev] = (mean(Q1_4[array_idx])/mean(N4_weight[array_idx])\\n - 2.*((mean(Q1_2[array_idx])\\n /mean(N2_weight[array_idx]))**2.))\\n # C_2{4}\\n C2_4_array[iev] = (mean(Q2_4[array_idx])/mean(N4_weight[array_idx])\\n - 2.*((mean(Q2_2[array_idx])\\n /mean(N2_weight[array_idx]))**2.))\\n # C_3{4}\\n C3_4_array[iev] = (mean(Q3_4[array_idx])/mean(N4_weight[array_idx])\\n - 2.*((mean(Q3_2[array_idx])\\n /mean(N2_weight[array_idx]))**2.))\\n C1_4_mean = mean(C1_4_array)\\n C1_4_err = sqrt((nev - 1.)/nev*sum((C1_4_array - C1_4_mean)**2.))\\n C2_4_mean = mean(C2_4_array)\\n C2_4_err = sqrt((nev - 1.)/nev*sum((C2_4_array - C2_4_mean)**2.))\\n C3_4_mean = mean(C3_4_array)\\n C3_4_err = sqrt((nev - 1.)/nev*sum((C3_4_array - C3_4_mean)**2.))\\n\\n v1_4 = 0.0\\n v1_4_err = 0.0\\n if C1_4_mean < 0:\\n v1_4 = (-C1_4_mean)**0.25\\n v1_4_err = 0.25*((-C1_4_mean)**(-0.75))*C1_4_err\\n\\n v2_4 = 0.0\\n v2_4_err = 0.0\\n if C2_4_mean < 0:\\n v2_4 = (-C2_4_mean)**0.25\\n v2_4_err = 0.25*((-C2_4_mean)**(-0.75))*C2_4_err\\n\\n v3_4 = 0.0\\n v3_4_err = 0.0\\n if C3_4_mean < 0:\\n v3_4 = (-C3_4_mean)**0.25\\n v3_4_err = 0.25*((-C3_4_mean)**(-0.75))*C3_4_err\\n\\n results = [v1_4, v1_4_err, C1_4_mean, C1_4_err,\\n v2_4, v2_4_err, C2_4_mean, C2_4_err,\\n v3_4, v3_4_err, C3_4_mean, C3_4_err,]\\n f = open(outputFileName, 'w')\\n f.write(\\\"# n vn{4} vn{4}_err Cn{4} Cn{4}_err\\\\n\\\")\\n for i in range(1, 4):\\n f.write(\\\"%d %.10e %.10e %.10e %.10e\\\\n\\\"\\n % (i, results[4*i-4], results[4*i-3],\\n results[4*i-2], results[4*i-1]))\\n f.close()\\n return\",\n \"def iterate_value(self):\\n self.V = np.zeros(self.stateCount)\\n for i in range(self.maxIter):\\n last_V = np.copy(self.V)\\n for state_index in range(self.stateCount):\\n current_state = self.env.statespace[state_index]\\n for action in self.env.actionspace:\\n next_state = self.env.next_state(current_state,action)\\n reward = self.env.compute_reward(next_state)\\n next_state_index = self.env.stateDict[next_state]\\n self.Q[state_index][action] = reward + self.gamma*last_V[next_state_index]\\n if self.mode == 'debug':\\n print(\\\"Q(s={}):{}\\\".format(current_state,self.Q[state_index]))\\n self.V[state_index] = max(self.Q[state_index])\\n if np.sum(np.fabs(last_V - self.V)) <= self.th:\\n print (\\\"Convergene Achieved in {}th iteration. \\\"\\n \\\"Breaking V_Iteration loop!\\\".format(i))\\n break\",\n \"def power_iteration(X):\\n #X, languages=prepare_data_matrix()\\n M=X\\n M=M-np.mean(M, axis=0)\\n M=np.cov(M, rowvar=False) #the covariance matrix, size 100x100\\n x=np.ones(len(M)) #a random starting vector composed of 100 ones, it only cant be of all zeros\\n difference=np.ones(len(x))\\n\\n #print(np.linalg.norm(difference))\\n while np.linalg.norm(difference) >= 10**-5: #we iterate until the difference between the previous and the new x is really small, lets say 10^-5\\n #print(x.T.shape)\\n oldx=x\\n z=M.dot((x.T))\\n x=z.T\\n x=x/np.linalg.norm(x)\\n difference=np.linalg.norm(oldx-x)\\n #the x that we get at the end of this loop is our eigenvector\\n\\n #print(x.dot(M).shape)\\n #print(x.shape)\\n y=(x.dot(M)).dot(x.T) #y is the corresponding eigenvalue to the eigenvector x\\n \\n return x, y\",\n \"def poweig(A, x0, maxiter = 100, ztol= 1.0e-5, mode= 0, teststeps=1):\\n m = len(A)\\n xi = x0[:] \\n \\n for n in range(maxiter):\\n # matrix vector multiplication.\\n xim1 = xi[:]\\n for i in range(m):\\n xi[i] = 0.0\\n for j in range(m):\\n xi[i] += A[i][j] * xim1[j]\\n print n, xi\\n if mode == 0:\\n vlen = sqrt(sum([xi[k]**2 for k in range(m)]))\\n xi = [xi[k] /vlen for k in range(m)]\\n elif mode == 1:\\n for k in range(m-1, -1, -1):\\n c = abs(xi[k])\\n if c > 1.0e-5:\\n xi = [xi[k] /c for k in range(m)]\\n break\\n # early termination test.\\n if n % teststeps == 0:\\n S = sum([xi[k]-xim1[k] for k in range(m)])\\n if abs(S) < ztol:\\n break\\n #print n, xi\\n # Compute Rayleigh quotient.\\n numer = sum([xi[k] * xim1[k] for k in range(m)])\\n denom = sum([xim1[k]**2 for k in range(m)])\\n xlambda = numer/denom\\n return xlambda, xi\",\n \"def invariant_mass_distributions_v_v_v(\\n model: SingleRhNeutrinoModel,\\n genv: Generation,\\n nbins: int,\\n):\\n\\n def msqrd(s, t):\\n return msqrd_v_v_v(s, t, model, genv)\\n\\n tb = ThreeBody(model.mx, (0, 0, 0), msqrd=msqrd)\\n return tb.invariant_mass_distributions(nbins=nbins)\",\n \"def fv(X,Y,dx,dy,r2,i,append,L,N,U,dt,close_list,Nlist,vel_verlet_on,R,menu,submenu,n1,grid,G,wallcount,X2):\\r\\n\\r\\n \\\"\\\"\\\"JV: append is a boolean. If it's true, adds the energy to our list, if it isn't, it doesn't.\\r\\n We do that because in some cases we will call the algorithm more times than the actual step number (and\\r\\n we only want to sum the value T/dt times), this is needed in the velocity-Verlet algorithm, that we call the fv()\\r\\n function one more time than needed just to start the loop.\\\"\\\"\\\"\\r\\n\\r\\n# L = self.param[2]\\r\\n#\\r\\n# N = self.particles.size\\r\\n\\r\\n #For computing all the distances I use a trick with the meshgrid function,\\r\\n #see the documentation on how this works if you dont see it.\\r\\n\\r\\n \\\"\\\"\\\"JV: X is an array that contains each position, mx is an nxn array that each column is the position of one particle (so it's a matrix\\r\\n that has n X rows) and mxt is the same but tranposed (so it's a matrix of n X columns)\\\"\\\"\\\"\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n UPDATE: This block of code is commented because now it's done in a loop inside solve_verlet() (due to Numba...).\\r\\n Looks a little bit messy but if Numba allowed me to call the np.meshgrid() function we would do this here. Sorry, but I like to keep the comment to remind me that.\\r\\n \\\"\\\"\\\"\\r\\n # MX, MXT = np.meshgrid(X,X,copy=False)\\r\\n # MY, MYT = np.meshgrid(Y,Y,copy=False)\\r\\n\\r\\n #JV: So dx is a nxn simetric array with 0 in the diagonal, and each position is the corresponding distance between the particles,\\r\\n # so the position [1,2] is the distance between partcle 1 and 2 (x1-x2), and so on\\r\\n # dx = MXT - MX\\r\\n # dx = dx\\r\\n\\r\\n # dy = MYT - MY\\r\\n # dy = dy\\r\\n\\r\\n # r2 = np.square(dx)+np.square(dy)\\r\\n\\r\\n # if(menu == \\\"Free!\\\"):\\r\\n # #JV: We do this to get the actual distance in the case of the \\\"Free!\\\" simulation, in which there is no elastic collision between the particles and the boundaries\\r\\n # dx_v2 = (np.abs(dx.copy())-1*L)\\r\\n # r2_v2 = dx_v2**2+dy**2\\r\\n # dx = np.where(r2 > r2_v2,dx_v2*np.sign(dx),dx)\\r\\n # r2 = np.where(r2 > r2_v2,r2_v2,r2)\\r\\n # dy_v2 = (np.abs(dy.copy())-1*L)\\r\\n # r2_v2 = dx**2+dy_v2**2\\r\\n # dy = np.where(r2 > r2_v2,dy_v2*np.sign(dy),dy)\\r\\n # r2 = np.where(r2 > r2_v2,r2_v2,r2)\\r\\n # r2_v2 = dx_v2**2+dy_v2**2\\r\\n # dx = np.where(r2 > r2_v2,dx_v2*np.sign(dx),dx)\\r\\n # dy = np.where(r2 > r2_v2,dy_v2*np.sign(dy),dy)\\r\\n # r2 = np.where(r2 > r2_v2,r2_v2,r2)\\r\\n\\r\\n dUx = 0.\\r\\n dUy = 0.\\r\\n utot = np.zeros((N))\\r\\n f = np.zeros((N,2))\\r\\n\\r\\n for j in range(0,N):\\r\\n dUx = 0.\\r\\n dUy = 0.\\r\\n u = 0.\\r\\n\\r\\n #JV: we now calculate the force with only the Nlist closest particles\\r\\n for k in range(0,Nlist):\\r\\n c = int(close_list[j][k])\\r\\n\\r\\n #In the force computation we include the LJ and the walls (JV: in the verlet case). I truncate the interaction at self.R units of lenght,\\r\\n #I also avoid distances close to 0 (which only should affect the diagonal in the matrix of distances)\\r\\n #All these conditions are included using the numpy.where function.\\r\\n #If you want to include more forces you only need to add terms to these lines.\\r\\n\\r\\n if(vel_verlet_on == True):\\r\\n if((r2[j,c] < 4*max(R[j],R[c])) and (r2[j,c] > 10**(-2))):\\r\\n dUx = dUx + dLJverlet(dx[j,c],r2[j,c],R[j],R[c])\\r\\n dUy = dUy + dLJverlet(dy[j,c],r2[j,c],R[j],R[c])\\r\\n # print(dUx,dUy,dx[j,c],r2[j,c],R[j],R[c])\\r\\n#JV: COMMENTED PART BECAUSE NUMBA HAS PROBLEMS WITH THIS BLOCK OF CODE THAT DOES THE CALCULATION IN THE VERLET ALGORITHM, NOW IT ONLY WORKS WITH THE VELOCITY VERLET, TO FIX\\\"\\r\\n# else:\\r\\n# if((r2[j,c] < 4*max(R[j],R[c])) and (r2[j,c] > 10**(-2))):\\r\\n# dUx = dUx + dLJverlet(dx[j,c],r2[j,c],R[j],R[c]) - dwalls([X[j],Y[j]],param)\\r\\n# dUy = dUy + dLJverlet(dy[j,c],r2[j,c],R[j],R[c]) - dwalls([X[j],Y[j]],param)\\r\\n\\r\\n #JV: We add the energy in the corresponding array in both cases, remember that the verlet algorithm will include the energy from the walls\\r\\n # and that will be visible in fluctuations on the energy\\r\\n if(vel_verlet_on == True):\\r\\n if((r2[j,c] < 2*max(R[j],R[c])) and (r2[j,c] > 10**(-2))):\\r\\n u = u + LJverlet(r2[j,c],R[c],R[j])\\r\\n# else:\\r\\n# u = u + walls([X[j],Y[j]])#JV: TO CHANGE; NOW ONLY WORKS WITH VEL_VERLET_ON\\r\\n# else:\\r\\n# if((r2[j,c] < 2*max(R[j],R[c])) and (r2[j,c] > 10**(-2))):\\r\\n# u = u + LJverlet(r2[j,c],R[c],R[j],param)\\r\\n#\\r\\n# if((X[j]**2+Y[j]**2) > (0.8*L)**2):\\r\\n# u = u + walls([X[j],Y[j]],param)\\r\\n #JV: COMMENTED FOR NOW\\r\\n\\r\\n #JV: If the argument it's True, we will append the energy to our corresponding array\\r\\n if(append == True):\\r\\n utot[j] = u\\r\\n\\r\\n f[j,:] = f[j,:]+np.array([dUx,dUy])\\r\\n\\r\\n if(append == True):\\r\\n U[int(i)] = np.sum(utot) #JV: Finally, we add the total energy so we have the global energy in a step of time\\r\\n\\r\\n return f\",\n \"def solver(u,f,n=50,m=100,t0=0,t1=1000,dt=.1,nu=1):\\n \\n u_new=[[u[i][j] for j in range(m)]for i in range(n)]\\n loopCounter=t0\\n while(loopCounter<=t1):\\n for i in xrange(1,n-1):\\n for j in xrange(1,m-1):\\n u_new[i][j]=u[i][j] + dt * (nu*u[i-1][j] + nu*u[i][j-1] - 4*nu*u[i][j] + nu*u[i][j+1] + nu*u[i+1][j] + f[i][j])\\n loopCounter+=dt\\n u=[[u_new[i][j] for j in range(m)]for i in range(n)]\\n\\n return u\",\n \"def relax(self,n=1):\\n # print(\\\"putin\\\", self.level.rhs.reshape(-1)[:])\\n # print(\\\"getout\\\", self.solver(self.level.rhs.reshape(-1)))\\n for i in range(n):\\n self.level.mid[:] += (self.solver(self.level.rhs.reshape(-1)) -\\n self.solver(self.stencil.eval_convolve(\\n self.level.evaluable_view(self.stencil)).reshape(-1))).reshape(self.level.mid.shape)\",\n \"def calculate_vn4_over_vn2(vn_data_array, outputFileName):\\n vn_data_array = array(vn_data_array)\\n nev = len(vn_data_array[:, 0])\\n dN = real(vn_data_array[:, 0])\\n Q1 = dN*vn_data_array[:, 1]\\n Q2 = dN*vn_data_array[:, 2]\\n Q3 = dN*vn_data_array[:, 3]\\n Q4 = dN*vn_data_array[:, 4]\\n Q5 = dN*vn_data_array[:, 5]\\n Q6 = dN*vn_data_array[:, 6]\\n\\n # two-particle correlation\\n N2_weight = dN*(dN - 1.)\\n Q1_2 = abs(Q1)**2. - dN\\n Q2_2 = abs(Q2)**2. - dN\\n Q3_2 = abs(Q3)**2. - dN\\n\\n # four-particle correlation\\n N4_weight = dN*(dN - 1.)*(dN - 2.)*(dN - 3.)\\n Q1_4 = ((abs(Q1)**4.) - 2.*real(Q2*conj(Q1)*conj(Q1))\\n - 4.*(dN - 2.)*(abs(Q1)**2.) + abs(Q2)**2.\\n + 2*dN*(dN - 3.))\\n Q2_4 = ((abs(Q2)**4.) - 2.*real(Q4*conj(Q2)*conj(Q2))\\n - 4.*(dN - 2.)*(abs(Q2)**2.) + abs(Q4)**2.\\n + 2*dN*(dN - 3.))\\n Q3_4 = ((abs(Q3)**4.) - 2.*real(Q6*conj(Q3)*conj(Q3))\\n - 4.*(dN - 2.)*(abs(Q3)**2.) + abs(Q6)**2.\\n + 2*dN*(dN - 3.))\\n\\n # calcualte observables with Jackknife resampling method\\n r1_array = zeros(nev)\\n r2_array = zeros(nev)\\n r3_array = zeros(nev)\\n F1_array = zeros(nev)\\n F2_array = zeros(nev)\\n F3_array = zeros(nev)\\n for iev in range(nev):\\n array_idx = [True]*nev\\n array_idx[iev] = False\\n array_idx = array(array_idx)\\n\\n # C_n{4}\\n C_1_4 = (mean(Q1_4[array_idx])/mean(N4_weight[array_idx])\\n - 2.*((mean(Q1_2[array_idx])/mean(N2_weight[array_idx]))**2.))\\n C_1_2 = mean(Q1_2[array_idx])/mean(N2_weight[array_idx])\\n if C_1_4 < 0. and C_1_2 > 0.:\\n v1_4 = (-C_1_4)**0.25\\n v1_2 = sqrt(C_1_2)\\n r1_array[iev] = v1_4/(v1_2 + 1e-15)\\n F1_array[iev] = sqrt((v1_2**2. - v1_4**2.)\\n /(v1_2**2. + v1_4**2. + 1e-15))\\n\\n C_2_4 = (mean(Q2_4[array_idx])/mean(N4_weight[array_idx])\\n - 2.*((mean(Q2_2[array_idx])/mean(N2_weight[array_idx]))**2.))\\n C_2_2 = mean(Q2_2[array_idx])/mean(N2_weight[array_idx])\\n if C_2_4 < 0. and C_2_2 > 0.:\\n v2_4 = (-C_2_4)**0.25\\n v2_2 = sqrt(C_2_2)\\n r2_array[iev] = v2_4/v2_2\\n F2_array[iev] = sqrt((v2_2**2. - v2_4**2.)\\n /(v2_2**2. + v2_4**2. + 1e-15))\\n\\n C_3_4 = (mean(Q3_4[array_idx])/mean(N4_weight[array_idx])\\n - 2.*((mean(Q3_2[array_idx])/mean(N2_weight[array_idx]))**2.))\\n C_3_2 = mean(Q3_2[array_idx])/mean(N2_weight[array_idx])\\n if C_3_4 < 0. and C_3_2 > 0.:\\n v3_4 = (-C_3_4)**0.25\\n v3_2 = sqrt(C_3_2)\\n r3_array[iev] = v3_4/v3_2\\n F3_array[iev] = sqrt((v3_2**2. - v3_4**2.)\\n /(v3_2**2. + v3_4**2. + 1e-15))\\n\\n r1_mean = mean(r1_array)\\n r1_err = sqrt((nev - 1.)/nev*sum((r1_array - r1_mean)**2.))\\n r2_mean = mean(r2_array)\\n r2_err = sqrt((nev - 1.)/nev*sum((r2_array - r2_mean)**2.))\\n r3_mean = mean(r3_array)\\n r3_err = sqrt((nev - 1.)/nev*sum((r3_array - r3_mean)**2.))\\n\\n F1_mean = mean(F1_array)\\n F1_err = sqrt((nev - 1.)/nev*sum((F1_array - F1_mean)**2.))\\n F2_mean = mean(F2_array)\\n F2_err = sqrt((nev - 1.)/nev*sum((F2_array - F2_mean)**2.))\\n F3_mean = mean(F3_array)\\n F3_err = sqrt((nev - 1.)/nev*sum((F3_array - F3_mean)**2.))\\n\\n results = [r1_mean, r1_err, F1_mean, F1_err,\\n r2_mean, r2_err, F2_mean, F2_err,\\n r3_mean, r3_err, F3_mean, F3_err]\\n f = open(outputFileName, 'w')\\n f.write(\\\"# n vn{4}/vn{2} (vn{4}/vn{2})_err Fn Fn_err\\\\n\\\")\\n f.write(\\\"# Fn = sqrt((vn{2}^2 - vn{4}^2)/(vn{2}^2 + vn{4}^2))\\\\n\\\")\\n for i in range(1, 4):\\n f.write(\\\"%d %.10e %.10e %.10e %.10e\\\\n\\\"\\n % (i, results[4*i - 4], results[4*i - 3],\\n results[4*i - 2], results[4*i-1]))\\n f.close()\\n return\",\n \"def relax(self, n=1):\\n\\n for i in range(n):\\n rhs = self.lvl.rhs - self.st_minus.eval_convolve(self.evaluable_view, self.convolve_control)\\n self.lvl.mid[:] = self.l_plus_solver(rhs.reshape(-1)).reshape(self.lvl.mid.shape)\",\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 SSA(self,N=1,q=12):\\n\\n X = self.data[self.IDs]\\n X = np.flip(X.T[(np.arange(q))+np.arange(np.max(self.dimT-(q-1),0)).reshape(-1,1)].reshape(self.dimT-q+1,self.n*q).T,0)\\n U,S,V = np.linalg.svd(X,full_matrices=False)\\n\\n EEOFs = np.zeros((self.dimX,self.dimY,self.dimT,N))\\n X_rec = np.zeros((self.n,self.dimT,self.dimT-q+1))\\n for k in range(self.dimT-q+1):\\n Xk = S[k]*np.dot(np.atleast_2d(U[:,k]).T,np.atleast_2d(V.T[:,k]))\\n offset1 = 0\\n offset2 = 1\\n for t in range(self.dimT):\\n if t == 0:\\n X_rec[:,t,k] = Xk[-self.n:,0]\\n elif (t > 0) & (t < q-1):\\n x_kj = np.zeros((self.n,t+1))\\n start = self.n*q - (t+1)*self.n\\n for l in range(t+1):\\n x_kj[:,l] = Xk[start:start+self.n,l]\\n start += self.n\\n X_rec[:,t,k] = np.mean(x_kj,1)\\n elif (t >= q-1) & (t <= self.dimT-q):\\n x_kj = np.zeros((self.n,q))\\n start = 0\\n for l in range(offset1,q+offset1):\\n x_kj[:,l-offset1] = Xk[start:start+self.n,l]\\n start += self.n\\n offset1 += 1\\n X_rec[:,t,k] = np.mean(x_kj,1)\\n elif (t > self.dimT-q) & (t < self.dimT-1):\\n x_kj = np.zeros((self.n,q-offset2))\\n start = 0\\n for l in range(offset1,(q-offset2)+offset1):\\n x_kj[:,l-offset1] = Xk[start:start+self.n,l]\\n start += self.n\\n offset1 += 1\\n offset2 += 1\\n X_rec[:,t,k] = np.mean(x_kj,1)\\n elif t == self.dimT-1:\\n X_rec[:,t,k] = Xk[:self.n,-1]\\n\\n EEOFs[self.IDs] = (np.flip(X_rec,0)/self.weights[self.IDs][:,np.newaxis,np.newaxis])[:,:,:N]\\n \\n return EEOFs\",\n \"def IterateValues(self):\\n agrid = self.agrid\\n self.w = self.setwage(self.K, self.N)\\n self.r = self.setrate(self.K, self.N)\\n self.b = self.benefit(self.N)\\n\\n for l in range(self.Na): \\n self.c[-1][l] = agrid[l]*(1+self.r) + self.b\\n self.v[-1][l] = self.util(self.c[-1][l],0)\\n self.vtilde[-1] = interp1d(agrid,self.v[-1], kind='cubic')\\n\\n for y in range(-2,-(self.T+1),-1): # y = -2, -3,..., -60\\n m0 = 0 \\n for l in range(self.Na):\\n # Find a bracket within which optimal a' lies\\n m = max(0, m0-1)\\n m0, a, b, c = self.GetBracket(y, l, m, agrid)\\n # Define objective function for optimal a'\\n def objfn(a1):\\n v = self.value(y, agrid[l], a1)\\n return -v\\n # Find optimal a' using Golden Section Search\\n if a == b:\\n self.a[y][l] = 0\\n elif b == c:\\n self.a[y][l] = agrid[-1]\\n else:\\n result = minimize_scalar(objfn, bracket=(a,b,c), method='Golden')\\n #‘Brent’,‘Bounded’,‘Golden’\\n self.a[y][l] = result.x\\n # Computing consumption and labor\\n if y >= -self.R:\\n self.c[y][l], self.n[y][l] = (1+self.r)*agrid[l] + self.b - self.a[y][l], 0\\n else:\\n self.c[y][l], self.n[y][l] = self.solve(agrid[l], self.a[y][l])\\n self.v[y][l] = self.util(self.c[y][l],self.n[y][l]) + self.beta*self.vtilde[y+1](self.a[y][l])\\n self.vtilde[y] = interp1d(agrid, self.v[y], kind='cubic')\",\n \"def calculate_posvij_matrices(main_tetrad_ark):\\n\\n # Import all the possible solutions to the Vij matrices\\n vij_possibilities = matrix_outerprod_calc.illuminator_of_elfes()\\n vij_matrices = []\\n\\n print(\\\" \\\")\\n print(\\\" Calculating Vij matrices\\\")\\n print(\\\" \\\")\\n # for i in range(0, len(main_tetrad_ark)):\\n for i in range(0, len(vij_possibilities)):\\n tet_i = [x[1] for x in main_tetrad_ark[i]]\\n tri_tet = [np.transpose(i) for i in tet_i]\\n print(\\\"# ********************************\\\")\\n # print(\\\" \\\")\\n print(\\\"MATRIX i: \\\", i)\\n print(\\\" \\\")\\n for j in range(0, len(main_tetrad_ark)):\\n tet_j = [x[1] for x in main_tetrad_ark[j]]\\n trj_tet = [np.transpose(j) for j in tet_j]\\n vij_temp = []\\n # print(\\\"# ********************************\\\")\\n print(\\\" \\\")\\n print(\\\"MATRIX j: \\\", j)\\n temp_zero = np.zeros((4,4), dtype=int)\\n for x in range(0,len(tet_i)):\\n test_1half = np.dot(tri_tet[x],tet_j[x])\\n test_2half = np.dot(trj_tet[x],tet_i[x])\\n test_difs = np.subtract(test_1half, test_2half)\\n # print(\\\" \\\")\\n # print(test_difs)\\n temp_mat = np.dot(tri_tet[x],tet_j[x]) - np.dot(trj_tet[x],tet_i[x])\\n vij_temp.append(temp_mat)\\n # print(\\\"\\\")\\n temp_add1 = np.add(vij_temp[0], vij_temp[1])\\n temp_add2 = np.add(temp_add1, vij_temp[2])\\n tempf = np.add(temp_add2, vij_temp[3])\\n # tempf = np.divide(temp_add3, 2)\\n for ijx in vij_possibilities:\\n if np.array_equal(temp_addf, ijx[0]):\\n print(\\\"*************$$$$$$$$$$$$$$$$$$***************** \\\")\\n print(\\\"l-solution found:\\\", ijx[1])\\n print(temp_addf)\\n print(\\\"\\\")\\n print(ijx[0])\\n if np.array_equal(temp_addf, temp_zero):\\n pass\\n else:\\n vij_matrices.append(temp_addf)\\n # print(\\\"\\\")\\n print(temp_addf)\\n # vij_matrices.append(temp_addf)\\n vijmats_size = sys.getsizeof(vij_matrices)\\n print(\\\"Size of Vij Matrices list: bytes / kilobytes:\\\", vijmats_size, vijmats_size/1024)\\n print(\\\"Length of Vij Matrices\\\")\\n print(len(vij_matrices))\\n print(vij_matrices)\\n pass\",\n \"def f(t, x, n, v):\\n total = 0\\n for i in range(n+1):\\n for j in range(n+1):\\n for k in range(v):\\n total = t[i][j] * x[i][j][k]\",\n \"def test_large_sum(self):\\n for n in [10, 20, 30, 40, 50]:\\n A = np.arange(n*n)\\n A = np.reshape(A, (n, n))\\n x = Variable(n, n)\\n p = Problem(Minimize(at.sum_entries(x)), [x >= A])\\n result = p.solve()\\n answer = n*n*(n*n+1)/2 - n*n\\n print(result - answer)\\n self.assertAlmostEqual(result, answer)\",\n \"def eigenvalue_analysis(*, dates, obs_data, model_data, residuals,\\n proxy_number=1):\\n # Create a masked version of the residuals array so that we can perform the\\n # PCA ignoring all nan values\\n masked_residuals = np.ma.array(residuals, mask=np.isnan(residuals))\\n\\n # Calculate the covariance matrix of the masked residuals array\\n covariance_matrix = np.ma.cov(masked_residuals, rowvar=False,\\n allow_masked=True)\\n # Calculate the eigenvalues and eigenvectors of the covariance matrix\\n eig_values, eig_vectors = np.linalg.eigh(covariance_matrix)\\n # Sort the eigenvalues in decreasing order\\n idx = np.argsort(np.abs(eig_values))[::-1]\\n eig_values = eig_values[idx]\\n # Sort the eigenvectors according to the same index\\n eig_vectors = eig_vectors[:, idx]\\n\\n # Project the residuals onto the eigenvectors\\n projected_residuals = np.ma.dot(masked_residuals, eig_vectors)\\n\\n # Use the method of Cox et al (2018) to remove unmodelled external\\n # signal in the SV residuals. The variable 'proxy' contains the sum\\n # of the SV residuals projected into the number of dominant PCs\\n # specified by proxy_number\\n\\n corrected_residuals = []\\n\\n if proxy_number == 1:\\n noisy_direction = eig_vectors[:, 0]\\n proxy = projected_residuals[:, 0]\\n for idx in range(len(proxy)):\\n corrected_residuals.append(\\n masked_residuals.data[idx, :] - proxy[idx] * noisy_direction)\\n # Apply the denoising algorithm to each of the PCs specified\\n elif proxy_number > 1:\\n noisy_direction = eig_vectors[:, 0:proxy_number]\\n proxy = np.sum(projected_residuals[:, 0:proxy_number], axis=1)\\n for idx in range(len(projected_residuals[:, 0])):\\n corrected = masked_residuals.data[idx, :]\\n for direction in range(proxy_number):\\n corrected = corrected - projected_residuals[idx, direction] \\\\\\n * noisy_direction[:, direction]\\n corrected_residuals.append(corrected)\\n\\n corrected_residuals = pd.DataFrame(corrected_residuals,\\n columns=obs_data.columns)\\n # Re-form the SV from the denoised residuals\\n denoised_sv = pd.DataFrame(\\n corrected_residuals.values + model_data.values,\\n columns=obs_data.columns)\\n\\n denoised_sv.insert(0, 'date', dates)\\n\\n return denoised_sv, proxy, np.abs(eig_values), eig_vectors,\\\\\\n projected_residuals, corrected_residuals.astype('float'),\\\\\\n covariance_matrix\",\n \"def test_basic_newton_finder(self):\\n forwards = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n strikes = np.array([1.0, 2.0, 1.0, 0.5, 1.0, 1.0])\\n expiries = np.array([1.0, 1.0, 1.0, 1.0, 0.5, 2.0])\\n discounts = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n init_vols = np.array([2.0, 0.5, 2.0, 0.5, 1.5, 1.5])\\n option_signs = np.array([1.0, 1.0, -1.0, -1.0, 1.0, 1.0])\\n volatilities = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\\n prices = np.array([\\n 0.38292492, 0.19061012, 0.38292492, 0.09530506, 0.27632639, 0.52049988\\n ])\\n results = implied_vol(\\n forwards,\\n strikes,\\n expiries,\\n discounts,\\n prices,\\n option_signs,\\n initial_volatilities=init_vols,\\n max_iterations=100)\\n implied_vols, converged, failed = self.evaluate(results)\\n num_volatilities = len(volatilities)\\n self.assertAllEqual(np.ones(num_volatilities, dtype=np.bool), converged)\\n self.assertAllEqual(np.zeros(num_volatilities, dtype=np.bool), failed)\\n self.assertArrayNear(volatilities, implied_vols, 1e-7)\",\n \"def _relax_matrix(self, n=1):\\n\\n for i in range(n):\\n self.level.mid.reshape(-1)[:] = self.R_w.dot(self.level.mid.reshape(-1)) \\\\\\n + self.omega * self.level.rhs / self.D\",\n \"def main(n = 150000, quiet = False):\\n t0 = time() #timing possibility\\n\\n if quiet:\\n output_stream = StringIO()\\n else:\\n output_stream = sys.stdout\\n\\n\\n print(t0,file=output_stream)\\n \\n\\n sfr = .01\\n # star mass function\\n kroupa = np.vectorize(functions.kroupa)\\n mf = dist.Distribution(kroupa, .1, 50.)\\n\\n #star formation history\\n constant_sfr = np.vectorize(functions.constant_sfr)\\n \\n ages = np.logspace(5,7,7)\\n sf = [dist.Distribution(constant_sfr, 1000., ages[i]) for i in range(len(ages))]\\n #sfr = [150000*mf.mean()/(ages[i]-1000.) for i in range(len(ages))]\\n\\n t1 = time() # finished reading the distributions\\n print(t1,file=output_stream)\\n\\n\\n # setting up model data\\n aperas = np.logspace(2, 5, 4)\\n avs = np.linspace(10.0, 50.0, 5)\\n l = 1\\n mpold, tmpnew = 0., time()\\n parameters = []\\n for i in range(len(avs)):\\n for j in range(len(aperas)):\\n for k in range(len(ages)):\\n tmpold, tmpnew = tmpnew, time()\\n starformation.main(massfunction = mf, starformationhistory = sf[k], \\\\\\n A_v = avs[i], sfr = n, apera = aperas[j], maxage = ages[k], \\\\\\n appendix = \\\"%s_%03d_%06d_%09d\\\" % ('sim',avs[i],aperas[j],ages[k]), quiet=True, precise=False)\\n print(avs[i],aperas[j],ages[k], l/len(avs)/len(aperas)/len(ages), (len(avs)*len(aperas)*len(ages)-l)*(tmpnew-tmpold),file=output_stream)\\n l = l+1\\n \\n parameters.append([avs[i],aperas[j],ages[k]])\\n\\n t2 = time() # end of simulation\\n print(t2, t1, t2-t1)\\n \\n print ('number of simulations run: %s' %l , file=output_stream) \\n head = ['#','AV', 'Aperature_size', 'Age']\\n f = open('out/__head', 'w')\\n f.write( ','.join(head)+'\\\\n' )\\n np.savetxt(f, parameters)\\n f.close()\\n\\n t3 = time() # end of saving data\\n\\n analysis.main('out')\\n print ('analysis complete' , file=output_stream) \\n \\n t4 = time() # end of analysing data\\n\\n\\n\\n print( 'starting script at %f' %(t0), file=output_stream)\\n print( 'initializing %f' %(t1-t0), file=output_stream)\\n print( \\\"running simulation %f\\\" %(t2-t1), file=output_stream)\\n print( \\\"writing data %f\\\" %(t3-t2), file=output_stream)\\n print( \\\"analysing data %f\\\" %(t4-t3), file=output_stream)\\n print( \\\"________________________\\\", file=output_stream)\\n print( \\\"total runtime %f\\\" %(t4-t0), file=output_stream)\\n print( \\\"finishing script %f\\\" %t4, file=output_stream)\",\n \"def test_convergence(self, nMax=500000, withPlots=True, overStep=100):\\n\\n def _mad(vin):\\n med = np.median(vin)\\n return np.median(np.abs(vin - med))\\n\\n self.convergenceSearchFlag = True\\n self.needReset = False\\n self._reset_limits()\\n mStart = 10\\n mStep = 1\\n statStep = 5\\n m = 0\\n k = mStart\\n converged = False\\n postConv = 0\\n pltout = []\\n dIout = []\\n Iold = 0\\n sE = self.E_max * np.ones(1)\\n sTheta_max = self.Theta_max * np.ones(1)\\n sPsi_max = self.Psi_max * np.ones(1)\\n\\n statOut = []\\n dIOut = []\\n xm = []\\n\\n outQuad = 0\\n outInt = 0\\n if withPlots:\\n from matplotlib import pyplot as plt\\n fig = plt.figure(figsize=(8, 6))\\n\\n ax0 = fig.add_axes([0.1, 0.65, 0.8, 0.3])\\n ax0.xaxis.set_visible(False)\\n ax0.set_ylabel('Relative intensity $I$', color='C0')\\n ampLine, = ax0.semilogy([], [], 'C0')\\n\\n ax1 = fig.add_axes([0.1, 0.1, 0.8, 0.55])\\n ax1.set_xlabel('Number of nodes')\\n ax1.set_ylabel('Median absolute deviation of $I$', color='C1')\\n madLine, = ax1.semilogy([], [], 'C1')\\n\\n ax2 = ax1.twinx()\\n ax2.set_ylabel('Median $dI/I$', color='C2')\\n relmadLine, = ax2.semilogy([], [], 'C2')\\n else:\\n fig = None\\n\\n while True:\\n m += 1\\n if m % 1000 == 0:\\n mStep *= 2\\n if True: # raycing._VERBOSITY_ > 10:\\n # print(\\\"INSUFFICIENT CONVERGENCE RANGE:\\\", k, \\\"NODES\\\")\\n print(\\\"INCREASING CONVERGENCE STEP. NEW STEP\\\", mStep)\\n\\n k += mStep\\n self.quadm = k\\n self._build_integration_grid()\\n xm.append(k*self.gIntervals)\\n Inew = self.build_I_map(sE, sTheta_max, sPsi_max)[0]\\n pltout.append(Inew)\\n dIout.append(np.abs(Inew-Iold)/Inew)\\n if m == 1:\\n Iold = Inew\\n continue\\n Iold = Inew\\n\\n if withPlots:\\n ampLine.set_xdata(xm)\\n relInt = np.array(pltout)\\n relInt /= relInt.max()\\n ampLine.set_ydata(relInt)\\n new_y_min = np.floor(np.log10(relInt.min()))\\n ax0.set_xlim([0, xm[-1]+5])\\n ax0.set_ylim([10**(new_y_min+0.1), 1.1])\\n\\n if converged:\\n postConv += 1\\n if m > statStep:\\n mad = _mad(np.abs(np.array(pltout))[m-statStep:m])\\n dIMAD = np.median(dIout[m-statStep:m])\\n\\n statOut.append(mad)\\n dIOut.append(dIMAD)\\n\\n if ((dIMAD < self.gp) or (mad < self.gp)) and not converged:\\n convPoint = k*self.gIntervals\\n outQuad = k\\n outInt = self.gIntervals\\n if True: # raycing._VERBOSITY_ > 10:\\n print(\\\"CONVERGENCE THRESHOLD REACHED AT \\\"\\n \\\"{0} NODES, {1} INTERVALS.\\\".format(\\n k, self.gIntervals))\\n print(\\\"INTEGRATION GRID LENGTH IS {} POINTS\\\".format(\\n convPoint))\\n converged = True\\n if withPlots:\\n label = 'True convergence: {0} nodes, {1} interval{2}'\\\\\\n .format(self.quadm, self.gIntervals,\\n '' if self.gIntervals == 1 else 's')\\n axvlineDict = dict(x=convPoint, color='r', label=label)\\n ax0.axvline(**axvlineDict)\\n ax1.axvline(**axvlineDict)\\n if withPlots:\\n new_y_max = np.ceil(np.log10(max(statOut)))\\n new_y_min = np.floor(np.log10(min(statOut)))\\n ax1.set_xlim([0, xm[-1]+5])\\n ax1.set_ylim([10**new_y_min, 10**(new_y_max-0.1)])\\n madLine.set_xdata(xm[statStep:])\\n madLine.set_ydata(statOut)\\n relmadLine.set_xdata(xm[statStep:])\\n relmadLine.set_ydata(dIOut)\\n new_y_max = np.ceil(np.log10(max(dIOut)))\\n new_y_min = np.floor(np.log10(min(dIOut)))\\n ax2.set_xlim([0, xm[-1]+5])\\n ax2.set_ylim([10**new_y_min, 10**new_y_max])\\n fig.canvas.draw()\\n plt.pause(0.001)\\n\\n if xm[-1] > nMax:\\n if not converged:\\n print(\\\"PROBLEM WITH CONVERGENCE. INCREASE nMax.\\\")\\n break\\n\\n if overStep is not None:\\n if postConv > overStep:\\n break\\n\\n convRes, stats = self._find_convergence_mixed()\\n print(\\\"CONVERGENCE TEST COMPLETED.\\\")\\n self.needReset = True\\n if withPlots:\\n label = 'Auto-finder: {0} nodes, {1} interval{2}'.format(\\n self.quadm, self.gIntervals,\\n '' if self.gIntervals == 1 else 's')\\n axvlineDict = dict(x=self.quadm*self.gIntervals, color='m',\\n linestyle='--', label=label)\\n ax0.axvline(**axvlineDict)\\n ax1.axvline(**axvlineDict)\\n ax1.legend()\\n fig.canvas.draw()\\n plt.pause(0.1)\\n return converged, outQuad, outInt, fig\",\n \"def sqrtm_loop(Rarr, Tarr, n):\\n\\n # C code\\n code = \\\"\\\"\\\"\\n int j = 0, i = 0, k = 0;\\n std::complex<double> s;\\n for (j = 0; j < n; ++j) {\\n Rarr(j,j) = sqrt(Tarr(j,j));\\n for (i = j-1; i > -1; --i) {\\n s = 0.0;\\n for (k = i+1; k < j; ++k) {\\n s += Rarr(i,k) * Rarr(k,j);\\n }\\n Rarr(i,j) = (Tarr(i,j) - s) / (Rarr(i,i) + Rarr(j,j));\\n }\\n }\\n return_val = 0;\\n \\\"\\\"\\\"\\n return wv.inline(code,['Rarr','Tarr', 'n'],type_converters=wv.converters.blitz)\",\n \"def alternative_iterative_method(x0, n, gamma, b):\\n # Parameters:\\n MAX_ITER = 1000\\n n2 = n**2\\n\\n # Creating NxN versions of vector for easier indexing during iteration\\n b = b.copy().reshape(n, n)\\n b_transposed = b.copy().T\\n x0 = x0.copy().reshape(n, n)\\n x0_transposed = x0.copy().T\\n x1 = x0.copy()\\n x1_transposed = x0_transposed.copy()\\n\\n # No need for M, N, only a smaller tridiagonal system:\\n H = scipy.sparse.diags((-1, 2, -1), (-1, 0, 1), shape=(n, n), format=\\\"csr\\\")\\n gammaI = scipy.sparse.diags((gamma,), (0,), shape=(n, n), format=\\\"csr\\\")\\n M1 = gammaI + H # Corresponds to both (gI + M) & (gI + N) in equations\\n M2 = gammaI - H # Corresponds to both (gI - M) & (gI - N) in equations\\n\\n # Preallocating RHS of equations\\n RHS7 = np.zeros((n, n), dtype=np.float64)\\n RHS8 = np.zeros((n, n), dtype=np.float64)\\n\\n k = 0\\n while k < MAX_ITER:\\n for i in range(n): # Loading RHS values for Equation (7):\\n RHS7[:, i] = scipy.sparse.csr_matrix.dot(M2, x0_transposed[i]) + b_transposed[i]\\n for i in range(n): # Solving N independent tridig mat systems related to Eq(7):\\n x1[i] = scipy.sparse.linalg.spsolve(M1, RHS7[i])\\n RHS8[i] = scipy.sparse.csr_matrix.dot(M2, x1[i]) + b[i] # Loading RHS values for Equation (8):\\n for i in range(n): # Solving N independent tridig mat systems related to Eq(8):\\n x1_transposed[i] = scipy.sparse.linalg.spsolve(M1, RHS8[:, i])\\n\\n k += 1\\n if np.allclose(x1_transposed, x0_transposed, rtol=1e-8):\\n break\\n x0_transposed = x1_transposed.copy()\\n\\n res = x1_transposed.T.reshape(n2)\\n return res, k\",\n \"def SOR_Solve_Opt(A,b,tol=1.0e-6,max_iterations=100,LOUD=False):\\n [Nrow, Ncol] = A.shape\\n assert Nrow == Ncol\\n N = Nrow\\n converged = False\\n iteration = 1\\n omega = 1\\n l = 5\\n p = 2\\n x = np.random.rand(N) #random initial guess \\n x_new = np.zeros(N)\\n while not(converged):\\n x = x_new.copy() #replace old value\\n for row in range(N):\\n x_new[row] = b[row]\\n for column in range(N):\\n if column != row:\\n x_new[row] -= A[row,column]*x_new[column]\\n x_new[row] /= A[row,row]\\n x_new[row] = (1.0-omega) * x[row] + omega*x_new[row]\\n relative_change = np.linalg.norm(x_new-x)/np.linalg.norm(x_new)\\n #record change after iteration k\\n if (l==iteration):\\n dxl = np.linalg.norm(x_new-x)\\n if (l + p == iteration):\\n dxlp = np.linalg.norm(x_new-x)\\n omega = 2.0/(1.0+np.sqrt(1-(dxlp/dxl)**(1.0/p)))\\n if (LOUD):\\n print(\\\"Iteration\\\",iteration,\\\": Relative Change =\\\",relative_change)\\n if (relative_change < tol) or (iteration >= max_iterations):\\n converged = True\\n iteration += 1\\n return x_new\",\n \"def potentialSolver(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 # solve potential\\n for it in np.arange(1,max_it+1):\\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 #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 #check for convergence*/\\n if it%25==0:\\n sum = 0;\\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 R = -self.phi[i][j][k]*(2*dx2+2*dy2+2*dz2) +\\\\\\n 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])\\n\\n sum += R*R;\\n\\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 question27():\\n global conv_residuals\\n def catch(r):\\n \\\"\\\"\\\"Helper function to retrieve residual + steps to convergence for\\n GMRES operation in Scipy. Used as a callback function for\\n scipy.sparse.linalg.gmres\\n \\\"\\\"\\\"\\n global conv_residuals\\n conv_residuals.append(r)\\n return\\n\\n def iterate(rk):\\n \\\"\\\"\\\" Preconditioner Function for GMRES.\\\"\\\"\\\"\\n y = scipy.sparse.linalg.spsolve(P1, rk)\\n RHS = scipy.sparse.csr_matrix.dot(P4, y) + rk\\n zk = scipy.sparse.linalg.spsolve(P3, RHS)\\n return zk\\n\\n\\n N_search = np.array([20, 40, 60, 80, 100, 120, 140, 160, 180])\\n steps_till_conv_N = np.zeros(N_search.size)\\n\\n fig271 = plt.figure(figsize=(13, 8))\\n\\n for i, n in enumerate(N_search):\\n n2 = n**2\\n A = construct_matrix_A(n)\\n b = np.random.randn(n2)\\n M, N = construct_M_N(n)\\n mu_max = scipy.sparse.linalg.eigs(M, k=1, which='LM', return_eigenvectors=False)[0].real\\n mu_min = scipy.sparse.linalg.eigs(M, k=1, which='SM', return_eigenvectors=False)[0].real\\n gamma = np.sqrt(mu_max*mu_min)\\n gammaI = scipy.sparse.diags((gamma,), (0,), shape=(n2, n2), format=\\\"csr\\\")\\n P1 = gammaI + M\\n P2 = gammaI - N\\n P3 = gammaI + N\\n P4 = gammaI - M\\n M = scipy.sparse.linalg.LinearOperator((n2, n2), matvec=iterate)\\n conv_residuals = []\\n x = scipy.sparse.linalg.gmres(A, b, M=M, callback=catch)\\n steps_till_conv_N[i] += len(conv_residuals)\\n n_steps = len(conv_residuals)\\n plt.semilogy(range(n_steps), conv_residuals, label=f\\\"N = {n}\\\")\\n\\n plt.xlabel(\\\"Steps Required for Convergence\\\")\\n plt.ylabel(\\\"Residuals\\\")\\n plt.title(\\\"Figure 271 - GMRES + Preconditioner Residuals for Varying N\\\", fontsize=13)\\n plt.legend()\\n plt.grid()\\n plt.savefig(f\\\"figures/figure271.png\\\")\\n plt.show()\\n\\n\\n fig270 = plt.figure(figsize=(13, 8))\\n plt.plot(N_search, steps_till_conv_N)\\n plt.xlabel(\\\"N\\\")\\n plt.ylabel(\\\"Steps until convergence\\\")\\n plt.title(\\\"Figure 270 - GMRES + Preconditioner Convergence Required for Varying N\\\", fontsize=13)\\n plt.grid()\\n plt.savefig(f\\\"figures/figure270.png\\\")\\n plt.show()\\n return\",\n \"def get_mat_n(T_e, r_0, M, N, E, g_e, R_h, tmpN_t, tmpN_max):\\n mat_n = np.zeros((M, len(T_e))) # matrix for the result\\n for i in range(len(T_e)):\\n R_e = get_R_e(E, M, g_e, T_e[-i-1]) # matrix with transition rates (env)\\n #print get_R_e_test(E, M, g_e, T_e, R_e, 10e-15)\\n R = get_R(R_e, R_h) # total transition rates\\n data = (R, M, N) # arguments for fsolve \\n #-----------solve the nonlinear system of equations-------------------- \\n solution = fsolve(func, r_0,args=data, full_output=1)\\n if solution[2] == 0: # if sol. didnt conv., repeat calcul.\\n print i\\n else:\\n n1 = get_n1(solution[0],N) # occupation number of the ground state\\n n = np.zeros(M) # vector of all occupation numbers\\n n[0], n[1:] = n1 , solution[0] \\n if np.any(n<0.): # if solution is unphysical \\n print \\\"Needed to repeat calculation at Temperature T_e =\\\", T_e[-i-1] \\n n = get_cor_n(i, T_e, r_0, M, N, E, g_e, R_h, tmpN_t, tmpN_max)\\n if n == None:\\n print \\\"Calculation failed! You may choose a larger tmpN_max.\\\"\\n break\\n else:\\n r_0 = n[1:]\\n else:\\n r_0 = solution[0]\\n mat_n[:,-i-1] = n\\n return mat_n\",\n \"def multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \\\"north\\\"):\\n inds = self.mlat_finder(lat1, lat0, pole)[1]\\n NeA = self.NeA[inds]\\n NeB = self.NeB[inds]\\n NeC = self.NeC[inds]\\n\\n secondsA = self.secondsA[inds]\\n secondsB = self.secondsB[inds]\\n secondsC = self.secondsC[inds]\\n\\n\\n mlatA = self.mlatA[inds]\\n mlatB = self.mlatB[inds]\\n mlatC = self.mlatC[inds]\\n\\n mean_range = 5\\n NeA = self.meanie(NeA, mean_range)\\n NeB = self.meanie(NeB, mean_range)\\n NeC = self.meanie(NeC, mean_range)\\n \\n \\n N = int((len(NeA)/n*2) - 1) #nr of windows\\n \\n dx = (secondsB[1]-secondsB[0])*self.velB[0]\\n \\n nBAs = []\\n nBCs = []\\n nACs = []\\n \\n for i in range(N):\\n startind = int(i/2*n)\\n stopind = int((i/2+1)*n)\\n temp_NeA = NeA[startind:stopind]\\n temp_NeB = NeB[startind:stopind]\\n temp_NeC = NeC[startind:stopind]\\n \\n temp_secondsA = secondsA[startind:stopind]\\n temp_secondsB = secondsB[startind:stopind]\\n temp_secondsC = secondsC[startind:stopind]\\n \\n \\n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\\n if np.sum(curr_timediff) > 2:\\n continue\\n \\n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\\n \\n if np.max(gradA) < 0.9:\\n continue\\n \\n stdA = np.std(gradA)\\n stdB = np.std(gradB)\\n stdC = np.std(gradC)\\n \\n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\\n \\n p0A = [1, meanA, stdA]\\n p0B = [1, meanB, stdB]\\n p0C = [1, meanB, stdB]\\n \\n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\\n \\n nBA = poptB[1] - poptA[1]\\n nBC = poptB[1] - poptC[1]\\n nAC = poptA[1] - poptC[1]\\n \\n nBAs.append(nBA)\\n nBCs.append(nBC)\\n nACs.append(nAC)\\n \\n \\n sBA = self.BA_shift/2 #time delay BA\\n sBC = self.BC_shift/2 #time delay BC\\n sAC = (self.BC_shift - self.BA_shift)/2\\n V = self.velA[0]\\n for i in range(len(nBAs)):\\n VBA = self.along_track_velo(V, sBA, nBAs[i])\\n VBC = self.along_track_velo(V, sBC, nBCs[i])\\n VAC = self.along_track_velo(V, sAC, nACs[i])\\n \\n print(VBA)\\n print(VBC)\\n print(VAC)\\n print(\\\"________________________________________\\\")\",\n \"def mr(A, n_iterations, stop=False):\\n assert len(A.sizes) == 2\\n assert A.sizes[0] == A.sizes[1]\\n M = A.same_shape()\\n n = A.sizes[0]\\n @for_range(n)\\n def _(i):\\n e = sfix.Array(n)\\n e.assign_all(0)\\n e[i] = 1\\n M[i] = solve_linear(A, e, n_iterations, stop=stop)\\n return M.transpose()\",\n \"def mbieLoop (self) :\\n self.iterCnt = 0\\n while self.iterCnt < 5000:\\n s = self.mdp.s0\\n for h in range(self.H) :\\n self.QUpper = QBoundsSolver(self.mdp, self.PHat, self.QUpper, self.Ntotal, 0.1, True, self.stop)\\n a = np.argmax(self.QUpper[s])\\n s_, self.R[s,a] = self.mdp.step(s, a)\\n self.updateVisitStatistics(s, a, s_)\\n s = s_\\n\\n if self.iterCnt % 10 == 0: \\n print(self.iterCnt)\\n print(self.QUpper)\\n\\n self.iterCnt += 1\",\n \"def dp_alex(v_space, num_frames_r, num_frames_q, bov_flag, prev_ref=5,\\n next_ref=0):\\n t1 = float(cv2.getTickCount())\\n\\n common.DebugPrint(\\\"Entered dp_alex(): Running dynamic programming...\\\")\\n\\n r, c, d = v_space.shape\\n\\n # We substitute all NaN's of v_space\\n for i in range(d):\\n v_temp = v_space[:, :, i]\\n v_temp[np.isnan(v_temp)] = 0\\n v_space[:, :, i] = v_temp\\n\\n vv = np.zeros((r, c))\\n for j in range(d):\\n vv += v_space[:, :, j]\\n\\n # Checking that vv has positive elements\\n assert np.nonzero(vv < 0.0)[0].size == 0\\n\\n print_matrices = True\\n\\n if common.MY_DEBUG_STDOUT and print_matrices:\\n print(\\\"dp_alex(): r = %d, c = %d\\\" % (r, c))\\n print(\\\"dp_alex(): vv = \\\\n%s\\\" % str(vv))\\n sys.stdout.flush()\\n\\n D = np.zeros((r, c))\\n tback = np.zeros((r, c))\\n\\n for ref in range(r):\\n D[ref, 0] = vv[ref, 0]\\n tback[ref, 0] = -1\\n\\n for qry in range(1, c):\\n for ref in range(r):\\n # We enumerate a few reference frames to find the one with\\n # highest votes\\n lb = ref - prev_ref\\n ub = ref + next_ref\\n\\n if lb < 0:\\n lb = 0\\n if lb >= r:\\n lb = r - 1\\n\\n if ub < 0:\\n ub = 1\\n if ub >= r:\\n ub = r - 1\\n\\n max_pos = lb\\n for i in range(lb + 1, ub + 1):\\n \\\"\\\"\\\"\\n We use <= --> we break ties by going forward in the\\n reference video (incrementing the reference frame for\\n the next query frame).\\n \\\"\\\"\\\"\\n if D[max_pos, qry - 1] <= D[i, qry - 1]:\\n max_pos = i\\n # max_pos is the maximum vote reference frame for query frame qry\\n\\n D[ref, qry] += D[max_pos, qry - 1] + vv[ref, qry]\\n tback[ref, qry] = max_pos\\n\\n if common.MY_DEBUG_STDOUT and print_matrices:\\n print(\\\"D = \\\\n%s\\\" % str(D))\\n print(\\\"tback = \\\\n%s\\\" % str(tback))\\n\\n crossref = np.zeros((num_frames_q, 2))\\n\\n # Find max-cost path (the critical path) for the last query frame:\\n max_pos = 0\\n for ref in range(1, r):\\n \\\"\\\"\\\"\\n We use <= --> we break ties by going forward in the\\n reference video (incrementing the reference frame for\\n the next query frame) - debatable if this is a good idea!!!!TODO.\\n \\\"\\\"\\\"\\n if D[max_pos, c - 1] <= D[ref, c - 1]:\\n max_pos = ref\\n print(\\\"max_pos = %d\\\" % max_pos)\\n\\n print(\\\"dp_alex(): cost critical path = %s\\\" % str(D[max_pos, c - 1]))\\n\\n pos_ref = max_pos\\n for qry in range(c - 1, 0-1, -1):\\n crossref[qry][0] = qry\\n crossref[qry][1] = pos_ref\\n\\n common.DebugPrint(\\\"qry=%d, pos_ref=%d\\\" % (qry, pos_ref))\\n pos_ref = tback[pos_ref, qry]\\n\\n # time took\\n common.DebugPrint(\\\"dp_alex(): crossref = %s\\\" % str(crossref))\\n compute_cost(crossref, vv, \\\"crossref_dp_Alex.txt\\\")\\n # TODO: assert cost computed is = D[max_pos,...]\\n\\n t2 = float(cv2.getTickCount())\\n my_time = (t2 - t1) / cv2.getTickFrequency()\\n print(\\\"dp_alex() took %.6f [sec]\\\" % my_time)\\n\\n y = None\\n x = None\\n return y, x, D, tback, crossref\",\n \"def runLinAdvec():\\n # Courant number \\n c = 0.4\\n #just run and print, for two different Courant numbers\\n main(50, 50, c, displayResults = True)\\n main(400, 400, c, displayResults = True)\\n print(\\\"\\\\n\\\")\\n # run order of convergence tests\\n runErrorTests(c, 50, 300, stepNx=50, display=True)\\n # run timing tests\\n runTimingTests(c, 50, 600, stepNx=50, displayResults=True)\\n # check monotonicity\\n checkMonotonicity(50, 50, c, displayResults = True)\\n # check mass/variance conservation\\n checkConservation(200, 200, c, display=True)\",\n \"def compute(self): \\n Ex=np.zeros((self.nx,self.ny+1))\\n Ey=np.zeros((self.nx+1,self.ny))\\n Hz=np.zeros((self.nx,self.ny))\\n Hzx=np.zeros((self.nx,self.ny))\\n Hzy=np.zeros((self.nx,self.ny))\\n \\n imx = []\\n #eps, mu = self.makeenv()\\n mu=np.ones((self.nx,self.ny))*const.mu_0\\n eps = self.luneberg(int(self.nx/2), int(self.ny*2/3), self.R)\\n eps[:20,:] *= self.q #adself.ds a space of higher permittivity \\n eps[-20:,:] *= self.q #adself.ds a space of higher permittivity \\n eps[:,:20] *= self.q #adself.ds a space of higher permittivity \\n eps[:,-20:] *= self.q #adself.ds a space of higher permittivity \\n\\n c = self.dt/(eps*self.ds)\\n d = self.dt/(mu* self.ds)\\n \\n sigma = self.pml(eps, mu, 20)\\n cax = 1 - (sigma[0] * self.dt / eps)\\n cay = 1 - (sigma[1] * self.dt / eps)\\n dax = 1 - (sigma[2] * self.dt / mu) \\n day = 1 - (sigma[3] * self.dt / mu)\\n \\n bar = progressbar.ProgressBar()\\n for n in bar(range(self.nt+1)):\\n Ex[:,1:-1] = (cay[:,1:]+cay[:,:-1])/2*Ex[:,1:-1] + (c[:,1:]+c[:,:-1])/2*(Hz[:,1:]-Hz[:,:-1])\\n Ey[1:-1,:] = (cax[1:,:]+cax[:-1,:])/2*Ey[1:-1,:] - (c[1:,:]+c[:-1,:])/2*(Hz[1:,:]-Hz[:-1,:])\\n \\n Hzx = dax*Hzx - d*(Ey[1:,:] - Ey[:-1,:])\\n Hzy = day*Hzy + d*(Ex[:,1:] - Ex[:,:-1]) \\n Hz = Hzx + Hzy + self.actualsource(self.source, self.f, n, self.dt) \\n \\n if(n%self.interval == 0): imx.append(Ex[:self.nx,:self.ny]**2 + Ey[:self.nx, :self.ny]**2)\\n\\n return imx\",\n \"def calculate_rn_ratios(vn_event_arrays):\\n vn_event_arrays = array(vn_event_arrays)\\n rn_arrays = []\\n for iorder in range(3, 6):\\n # compute r2, r3, r4\\n rn_array = []\\n for itrig in range(3, len(vn_event_arrays[0, :, 0])):\\n pT_trig = real(vn_event_arrays[0, itrig, 0])\\n dN_trig = real(vn_event_arrays[:, itrig, 1])\\n Qn_trig_array = dN_trig*vn_event_arrays[:, itrig, iorder]\\n nev = len(Qn_trig_array)\\n\\n denorm2_dN = dN_trig*(dN_trig - 1.)\\n denorm2_array = abs(Qn_trig_array)**2. - dN_trig\\n\\n for iasso in range(0, itrig+1):\\n pT_asso = real(vn_event_arrays[0, iasso, 0])\\n dN_asso = real(vn_event_arrays[:, iasso, 1])\\n Qn_asso_array = dN_asso*vn_event_arrays[:, iasso, iorder]\\n\\n num_dN = dN_trig*dN_asso\\n num_array = real(Qn_asso_array*conj(Qn_trig_array))\\n if iasso == itrig:\\n num_dN -= dN_asso\\n num_array = (real(Qn_asso_array*conj(Qn_trig_array))\\n - dN_asso)\\n\\n denorm1_dN = dN_asso*(dN_asso - 1.)\\n denorm1_array = abs(Qn_asso_array)**2. - dN_asso\\n\\n rn_jackknife = zeros(nev)\\n for iev in range(nev):\\n array_idx = [True]*nev\\n array_idx[iev] = False\\n array_idx = array(array_idx)\\n\\n num = mean(num_array[array_idx])/mean(num_dN[array_idx])\\n denorm1 = (mean(denorm1_array[array_idx])\\n /mean(denorm1_dN[array_idx]))\\n denorm2 = (mean(denorm2_array[array_idx])\\n /mean(denorm2_dN[array_idx]))\\n\\n if denorm1 > 0. and denorm2 > 0.:\\n rn_jackknife[iev] = num/sqrt(denorm1*denorm2)\\n\\n rn_mean = mean(rn_jackknife)\\n rn_err = sqrt((nev - 1.)/nev*sum((rn_jackknife - rn_mean)**2.))\\n rn_array.append([pT_trig - pT_asso, rn_mean, rn_err])\\n rn_arrays.append(rn_array)\\n rn_arrays = array(rn_arrays)\\n return(rn_arrays)\",\n \"def iterative_improvement(opt_matrix, w_matrix, r_vector, c_min, c_max, max_iter=None, verbose=True,\\n use_cuda=False):\\n\\n total_time = 0\\n with Timer(\\\"Calculating initial solution...\\\", verbose) as t:\\n opt_matrix = optimal_result(opt_matrix, w_matrix, r_vector)\\n total_time += t.get_time_s()\\n\\n total_per_col = opt_matrix.sum(axis=0)\\n n_rows = opt_matrix.shape[0]\\n over_alloc, under_alloc = print_solution_diagnostic(total_per_col, c_min, c_max, verbose)\\n\\n cuda_interation = CudaIteration(opt_matrix.shape[0], opt_matrix.shape[1])\\n\\n solution_vals = []\\n iteration_n = 0\\n while (sum(over_alloc) > 1 or sum(under_alloc) > 1) and iteration_n != max_iter:\\n solution_vals.append(np.sum(np.multiply(opt_matrix, w_matrix)))\\n iteration_n += 1\\n with Timer(f\\\"Iteration {iteration_n} :\\\\n\\\", verbose) as t:\\n over_alloc_pct, under_alloc_pct, can_add, can_remove = \\\\\\n get_iteration_parameters(total_per_col, c_min, c_max, n_rows)\\n if use_cuda:\\n opt_matrix = cuda_interation(opt_matrix, over_alloc_pct, under_alloc_pct, can_add, can_remove)\\n else:\\n opt_matrix = iteration_improve(opt_matrix, over_alloc_pct, under_alloc_pct, can_add, can_remove)\\n total_per_col = opt_matrix.sum(axis=0)\\n over_alloc, under_alloc = print_solution_diagnostic(total_per_col, c_min, c_max, verbose)\\n total_time += t.get_time_s()\\n solution_vals.append(np.sum(np.multiply(opt_matrix, w_matrix)))\\n\\n cuda_compute_time = cuda_interation.computation_time\\n\\n return solution_vals, total_time, cuda_compute_time\",\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 \"def fAVM(RHOB,Dw,Ds,Df,Dc1,PHIc1,Ck,Dk,PHIk,RSK):\\n#\\n# 5.1.1 Initialise Outputs & Check for missing values in inputs:\\n# --------------------------------------------------------------\\n\\tPHIt=MissingValue\\n\\tPHIe=MissingValue\\n\\tCBW=MissingValue\\n\\tBVW=MissingValue\\n\\tHCPV=MissingValue\\n\\tVf=MissingValue\\n\\tVs=MissingValue\\n\\tSwt=MissingValue\\n\\tSwe=MissingValue\\n\\tVc1=MissingValue\\n\\tVc2=MissingValue\\n\\tVc3=MissingValue\\n\\tVk=MissingValue\\n\\tToc=MissingValue\\n\\tQc=MissingValue\\n\\tGDen=MissingValue\\n\\tif MissingValue in (RHOB,Dw,Ds,Df,Dc1,PHIc1,Ck,Dk,PHIk,RSK):\\n\\t\\treturn PHIt,PHIe,CBW,BVW,HCPV,Vf,Vs,Swt,Swe,Vc1,Vc2,Vc3,Vk,Toc,Qc,GDen\\n#\\n# 5.1.2 Initialise parameters:\\n# ----------------------------\\n\\tNIter=0\\n\\tNIterMax=100\\n\\tErrIter=10000\\n\\tTolErrIter=0.0001\\n\\tIterEnd=0\\n\\tVk=0.000 # Initially assumme no kerogen\\n\\tDh=Df\\n#\\n#\\t5.1.3 Start interative loop:\\n#\\t-----------------------------\\n\\twhile IterEnd==0:\\n#\\n# 5.5.3.1 Organic and Inorganic Component Density Values:\\n# -------------------------------------------------------\\n\\t\\tDBI=(1-PHIc1)*Dc1+(PHIc1*Dw) # Bulk Density of Inorganic Component\\n\\t\\tDBO=(1-PHIk)*Dk+(PHIk*Dh)# Bulk Density of Organic Component\\n#\\n# 5.1.3.2 Compute Volume of Organic and Inorganic Component:\\n# ----------------------------------------------------------\\n\\t\\tVOR=(DBI-RHOB)/(DBI-DBO)\\n\\t\\tVOR=ImposeLimits(VOR,0,1)\\n\\t\\tVIN=(1-VOR)\\n#\\n# 5.1.3.3 Compute Volumetrics, Total & Effective Porosity and Total & Effective Water Saturation:\\n# ---------------------------------------\\t-------------------------------------------------------\\n\\t\\tVc1=VIN*(1-PHIc1)\\n\\t\\tVc2=0.000\\n\\t\\tVc3=0.000\\n\\t\\tVk=VOR*(1-PHIk)\\n\\t\\tPHIt=VIN*PHIc1+VOR*PHIk\\n\\t\\tPHIe=VOR*PHIk\\n\\t\\tSwt=1-((VOR*PHIk)/PHIt)\\n\\t\\tSwt=ImposeLimits(Swt,0,1)\\n\\t\\tSwe=0.000\\n\\t\\tSxot=Swt\\n\\t\\tSxoe=Swe\\n#\\n# 5.1.3.4 Compute Bulk Volume of Water, Hydrocarbon Pore Volume and Pore Space Fluid Properties:\\n# ---------------------------------------\\t------------------------------------------------------\\n\\t\\tBVW=PHIe*Swe\\n\\t\\tHCPV=PHIe*(1-Swe)\\n\\t\\tVs=RSK*Vk # Estimate volume of adsorbed (sorbed) hydrocarbon\\n\\t\\tVs=ImposeLimits(Vs,0,HCPV)\\n\\t\\tVf=(HCPV-Vs)\\n\\t\\tVf=ImposeLimits(Vf,0,(HCPV-Vs))\\n#\\n# 5.1.3.5 Recompute hydrocarbon properties in the pore space:\\n# -----------------------------------------------------------\\n\\t\\tSum=Vs+Vf\\n\\t\\tif(Sum<=0.000):\\n\\t\\t\\tDh=Df\\n\\t\\telse:\\n\\t\\t\\tDh=(Ds*Vs+Df*Vf)/(Vs+Vf)\\n#\\n# 5.1.4 Test for interative computations:\\n# ---------------------------------------\\n\\t\\tNIter=NIter+1\\n\\t\\tif(NIter>=NIterMax):\\n\\t\\t\\tIterEnd=1\\n\\t\\telse:\\t\\t\\t\\n\\t\\t\\tif(NIter<=2):\\n\\t\\t\\t\\tResultOld=[1,1,1,1,1,1,1,1,1] # Initial Setting\\n\\t\\t\\t\\tResultNew=[Vc1,Vc2,Vc3,Vk,Vs,Vf,PHIe,Swt,Swe] # Current Results\\n\\t\\t\\t\\tErrIter=ComputeMatrixDifference(ResultOld,ResultNew)\\n\\t\\t\\t\\tResultOld=ResultNew\\n\\t\\t\\telse:\\n\\t\\t\\t\\tResultNew=[Vc1,Vc2,Vc3,Vk,Vs,Vf,PHIe,Swt,Swe] # Current Results\\n\\t\\t\\t\\tErrIter=ComputeMatrixDifference(ResultOld,ResultNew)\\n\\t\\t\\t\\tResultOld=ResultNew\\n\\t\\t\\t\\tif(ErrIter<=TolErrIter):\\n\\t\\t\\t\\t\\tIterEnd=1\\n#\\n# 5.1.6 Preoutput computations:\\n# ------------------------------\\n\\tQc=MissingValue\\n\\tDc2=0.00\\n\\tDc3=0.00\\n\\tCBW=PHIt-PHIe # The assumption is that all microporosity can be considered to be clay bound water.\\n\\tToc=fToc_Wtf(Vc1,Vc2,Vc3,Vk,0,Ck,Dc1,Dc2,Dc3,Dk,Dw) # TOC-wt fraction. Note: Vrw=0 in fToc_Wtf(Vc1,Vc2,Vc3,Vk,Vrw,Ck,Dc1,Dc2,Dc3,Dk,Dw)\\n\\tGDen=fOrmGDen(Vc1,Vc2,Vc3,Vk,0,Dc1,Dc2,Dc3,Dk,Dw) # Grain Density. Note: Vrw=0 in fOrmGDen(Vc1,Vc2,Vc3,Vk,Vrw,Dc1,Dc2,Dc3,Dk,Dw)\\n#\\n# 5.5.7 Output Results:\\n# \\t-------------------\\n\\treturn PHIt,PHIe,CBW,BVW,HCPV,Vf,Vs,Swt,Swe,Vc1,Vc2,Vc3,Vk,Toc,Qc,GDen\",\n \"def test_eigen_multiple_neighborhoods(self):\\n # vectorized version\\n t0 = time.time()\\n extract_vect = EigenValueVectorizeFeatureExtractor()\\n eigvals_vect = extract_vect.extract(self.point_cloud, self.neigh, None, None, None)\\n print('Timing Vectorize : {}'.format((time.time() - t0)))\\n eigvals_vect = np.vstack(eigvals_vect[:3]).T\\n\\n # serial version\\n eigvals = []\\n t0 = time.time()\\n for n in self.neigh:\\n extract = EigenValueSerial()\\n eigvals.append(extract.extract(self.point_cloud, n, None, None, None))\\n print('Timing Serial : {}'.format((time.time() - t0)))\\n eigvals = np.array(eigvals)\\n\\n np.testing.assert_allclose(eigvals_vect, eigvals)\",\n \"def test_solve_nicv(self):\\n\\n traces = np.array([[1, 2, 3], [4, 5, 6], [7, 0.4, 9], [2, 3, 12]])\\n plain = np.array([[1], [2], [1], [2]])\\n keys = plain\\n resulting_nicvs = np.array([0.23045267, 0.24016342, 0.49382716])\\n calculated_nicvs = NICV.calculate_nicv_array(plain, traces, 0, keys)\\n self.assertTrue(np.allclose(calculated_nicvs, resulting_nicvs))\",\n \"def refugia_adj_5_full_2_iter5 (params, ns):\\n #33 parameters \\n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\\n nu_T0 = [nu1x, nuA]\\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\\n fs.integrate(nu_T0, T0, m=mig0)\\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\\n nu_T1 = [nu1a, nu2a, nu3a]\\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \\n fs.integrate(nu_T1, T1, m=mig1)\\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\\n nu_T2 = [nu1b, nu2b, nu3b]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\\n nu_T3 = [nu1c, nu2c, nu3c]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3)\\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\\n nu_T4 = [nu1d, nu2d, nu3d]\\n fs.integrate(nu_T4, T4) \\n return fs\",\n \"def solve_prep(self):\\n\\n par = self.par\\n sol = self.sol\\n\\n # a. retirement\\n sol.m_ret = np.zeros((par.T,par.Nm_ret))\\n sol.c_ret = np.zeros((par.T,par.Nm_ret))\\n sol.a_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_v_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vm_ret = np.zeros((par.T,par.Nm_ret))\\n sol.inv_vn_ret = np.zeros((par.T,par.Nm_ret))\\n\\n # b. working\\n if par.solmethod == 'G2EGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.ucon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.ucon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.dcon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.dcon_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.acon_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.acon_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.con_v = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.z = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n \\n elif par.solmethod == 'NEGM':\\n\\n sol.c = np.zeros((par.T,par.Nn,par.Nm))\\n sol.d = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_v = np.zeros((par.T,par.Nn,par.Nm))\\n sol.inv_vn = np.zeros((0,0,0))\\n sol.inv_vm = np.zeros((par.T,par.Nn,par.Nm))\\n\\n sol.w = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wa = np.zeros((par.T-1,par.Nb_pd,par.Na_pd))\\n sol.wb = np.zeros((0,0,0))\\n \\n sol.c_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\\n sol.inv_v_pure_c = np.zeros((par.T,par.Nb_pd,par.Nm))\",\n \"def MATSOL(N,A):\\r\\n\\r\\n X = np.zeros((N+1),dtype=float) # X.shape = N+1\\r\\n NROW = np.arange(0,N+1,dtype=int) # NROW.shape = N+1\\r\\n\\r\\n for i in np.arange(N): # loop through rows\\r\\n AMAX = np.max(np.abs(A[NROW[i:],i])) # max value for column, all later rows\\r\\n ip = np.argmax(np.abs(A[NROW[i:],i]))+i # index of above\\r\\n \\r\\n if(abs(AMAX) <= 1E-08):\\r\\n print('Singular matrix --> No unique solution exists')\\r\\n return X\\r\\n \\r\\n if(NROW[i] != NROW[ip]): # swap rows\\r\\n NC = NROW[i].copy()\\r\\n NROW[i] = NROW[ip].copy()\\r\\n NROW[ip] = NC.copy()\\r\\n \\r\\n \\r\\n COEF = A[NROW[i+1:],i]/A[NROW[i],i] # normalize column values by maximum magnitude value (AMAX > 0)\\r\\n A[NROW[i+1:],i+1:] = A[NROW[i+1:],i+1:] - np.dot(COEF[:,None],A[NROW[i],i+1:][None,:]) # normalize/reduce matrix\\r\\n \\r\\n \\r\\n if(abs(A[NROW[N],N]) <= 1E-08):\\r\\n print('Singular matrix --> No unique solution exists')\\r\\n return X\\r\\n \\r\\n X[N] = A[NROW[N],N+1]/A[NROW[N],N] # downstream edge\\r\\n i = N-1\\r\\n while (i >= 0):\\r\\n# SUMM = 0.0\\r\\n# j = i+1\\r\\n \\r\\n SUMM = np.sum(A[NROW[i],i+1:N+1]*X[i+1:N+1]) # do not include final column\\r\\n \\r\\n# while (j <= N-1):\\r\\n# SUMM = A[NROW[i],j]*X[j] + SUMM\\r\\n# j = j+1\\r\\n # print(SUMM,SUMM2)\\r\\n \\r\\n X[i] = (A[NROW[i],N+1] - SUMM)/A[NROW[i],i]\\r\\n i = i-1\\r\\n return X\",\n \"def calculate_vn6_over_vn4(vn_data_array, outputFileName):\\n vn_data_array = array(vn_data_array)\\n nev = len(vn_data_array[:, 0])\\n dN = real(vn_data_array[:, 0])\\n Q1 = dN*vn_data_array[:, 1]\\n Q2 = dN*vn_data_array[:, 2]\\n Q3 = dN*vn_data_array[:, 3]\\n Q4 = dN*vn_data_array[:, 4]\\n Q5 = dN*vn_data_array[:, 5]\\n Q6 = dN*vn_data_array[:, 6]\\n\\n # two-particle correlation\\n N2_weight = dN*(dN - 1.)\\n Q2_2 = abs(Q2)**2. - dN\\n\\n # four-particle correlation\\n N4_weight = dN*(dN - 1.)*(dN - 2.)*(dN - 3.)\\n Q2_4 = ((abs(Q2)**4.) - 2.*real(Q4*conj(Q2)*conj(Q2))\\n - 4.*(dN - 2.)*(abs(Q2)**2.) + abs(Q4)**2.\\n + 2*dN*(dN - 3.))\\n\\n # six-particle correlation\\n N6_weight = dN*(dN - 1.)*(dN - 2.)*(dN - 3.)*(dN - 4.)*(dN - 5.)\\n Q2_6 = (abs(Q2)**6. + 9*(abs(Q4)**2.)*(abs(Q2)**2.)\\n - 6.*real(Q4*Q2*conj(Q2)*conj(Q2)*conj(Q2))\\n + 4.*real(Q6*conj(Q2)*conj(Q2)*conj(Q2))\\n - 12.*real(Q6*conj(Q4)*conj(Q2))\\n + 18.*(dN - 4.)*real(Q4*conj(Q2)*conj(Q2))\\n + 4.*(abs(Q6)**2.)\\n - 9.*(dN - 4.)*((abs(Q2)**4.) + (abs(Q4)**2.))\\n + 18.*(dN - 5.)*(dN - 2.)*(abs(Q2)**2.)\\n - 6.*dN*(dN - 4.)*(dN - 5.))\\n\\n # calcualte observables with Jackknife resampling method\\n r2_array = zeros(nev)\\n gamma1_array = zeros(nev)\\n for iev in range(nev):\\n array_idx = [True]*nev\\n array_idx[iev] = False\\n array_idx = array(array_idx)\\n\\n # C_n{4}\\n C_2_2 = mean(Q2_2[array_idx])/mean(N2_weight[array_idx])\\n C_2_4 = (mean(Q2_4[array_idx])/mean(N4_weight[array_idx])\\n - 2.*(C_2_2**2.))\\n C_2_6 = (mean(Q2_6[array_idx])/mean(N6_weight[array_idx])\\n - 9.*C_2_2*mean(Q2_4[array_idx])/mean(N4_weight[array_idx])\\n + 12.*(C_2_2**3.))\\n if C_2_6 > 0. and C_2_4 < 0. and C_2_2 > 0.:\\n v2_2 = sqrt(C_2_2)\\n v2_6 = (C_2_6/4.)**(1./6.)\\n v2_4 = (-C_2_4)**(1./4.)\\n r2_array[iev] = v2_6/v2_4\\n gamma1_array[iev] = (-6.*sqrt(2)*(v2_4**2.)*(v2_4 - v2_6)\\n /(v2_2**2. - v2_4**2.)**(1.5))\\n\\n r2_mean = mean(r2_array)\\n r2_err = sqrt((nev - 1.)/nev*sum((r2_array - r2_mean)**2.))\\n gamma1_mean = mean(gamma1_array)\\n gamma1_err = sqrt((nev - 1.)/nev*sum((gamma1_array - gamma1_mean)**2.))\\n\\n f = open(outputFileName, 'w')\\n f.write(\\n \\\"# n vn{6}/vn{4} (vn{6}/vn{4})_err gamma_1 gamma_1_err\\\\n\\\")\\n f.write(\\\"%d %.10e %.10e %.10e %.10e\\\\n\\\"\\n % (2, r2_mean, r2_err, gamma1_mean, gamma1_err))\\n f.close()\\n return\",\n \"def test_error1(version='scalar'):\\n Lx = 10\\n Ly = 10\\n c = 1.0\\n\\n def exact(x, y, t):\\n kx = pi/Lx; ky = pi/Ly; omega = sqrt(kx*kx + ky*ky)\\n return cos(omega*t)*sin(kx*x)*sin(ky*y)\\n\\n def I1(x, y):\\n return exact(x, y, 0)\\n\\n def bc(x, y, t):\\n return exact(x, y, t)\\n\\n def f(x, y, t):\\n if isinstance(x, ndarray) and isinstance(y, ndarray):\\n return zeros((x.shape[0], y.shape[1]))\\n else:\\n return 0.0\\n \\n error = []\\n def action(u, xv, yv, t):\\n e = exact(xv, yv, t) - u\\n error.append((t, sqrt(innerproduct(e.flat,e.flat))))\\n\\n t0 = time.clock()\\n implementation = {'ic': version, 'inner': version, 'bc': version}\\n nx = 10; ny = 4; tstop = 20\\n solver(I1, f, c, bc, Lx, Ly, nx, ny, 0, tstop,\\n user_action=action, implementation=implementation)\\n for t, e in error:\\n print 't=%10.2E error=%10.2E' % (t, e)\",\n \"def run_qae_optimization(training_states, n_repetitions, exact=no_noise, noisy=gate_error):\\n result_list = []\\n def proxy(params, training_states, n_repetitions, exact=no_noise, noisy=gate_error):\\n \\\"\\\"\\\"Embedded function version\\n \\\"\\\"\\\"\\n input_list = fix_list(params, all_param_array=all_param, var_param_array=var_param, fixed_vals_array=fixed_vals)\\n fidelities = []\\n for training_state in training_states:\\n fid = cusp_stage2.compute_stage2_cost_function(*input_list, alpha=training_state, n_repetitions=n_repetitions,\\n exact=exact, noisy=noisy)\\n fidelities.append(fid)\\n avg_fid = np.mean(fidelities)\\n result_list.append(1-avg_fid)\\n print(1-avg_fid)\\n return 1. - avg_fid\\n\\n \\n # Initialize parameters\\n half_turn_min = 0\\n half_turn_max = 2\\n init_params = np.random.uniform(low=half_turn_min, high=half_turn_max,\\n size=num_param)\\n\\n # Optimization using Nelder-Mead.\\n h2_qae_wrap = lambda params: proxy(params, training_states=training_states,\\n n_repetitions=n_repetitions, exact=exact, noisy=noisy)\\n \\n if noisy:\\n maxiter = 60\\n else:\\n maxiter = None\\n \\n res = minimize(h2_qae_wrap, init_params, args=(),\\n method='Nelder-Mead', tol=None, \\n options={'disp': False, 'maxiter': maxiter, 'xatol': 0.001,\\n 'return_all': False, 'fatol': 0.001})\\n np.savetxt('stage2_data.csv',result_list, delimiter=',')\\n return res.x\",\n \"def find_min_norm_element(vecs):\\n # Solution lying at the combination of two points\\n\\n\\n vecs_clone = []\\n for i in range(len(vecs)):\\n # assert len(vecs[i]) == 1\\n vecs_task = []\\n for k in range(len(vecs[i])):\\n vecs_task.append(vecs[i][k].view(-1))\\n vecs_clone.append(torch.cat(vecs_task).unsqueeze(0))\\n vecs_clone = torch.cat(vecs_clone)\\n\\n grad_mat = torch.matmul(vecs_clone, vecs_clone.t())\\n\\n # dps = {}\\n init_sol = MinNormSolver._min_norm_2d(grad_mat)\\n \\n n = len(vecs)\\n sol_vec = torch.zeros([n,]).cuda()\\n sol_vec[init_sol[0][0]] = init_sol[1]\\n sol_vec[init_sol[0][1]] = 1 - init_sol[1]\\n# sol_vec = sol_vec.unsqueeze(0)\\n\\n if n < 3:\\n # This is optimal for n=2, so return the solution\\n return sol_vec , init_sol[2]\\n \\n iter_count = 0\\n\\n # grad_mat = np.zeros((n,n))\\n # for i in range(n):\\n # for j in range(n):\\n # grad_mat[i,j] = dps[(i, j)]\\n \\n\\n while iter_count < MinNormSolver.MAX_ITER:\\n grad_dir = -1.0 * torch.matmul(grad_mat, sol_vec)\\n# sol_vec = sol_vec.squeeze()\\n new_point = MinNormSolver._next_point(sol_vec, grad_dir, n)\\n\\n v1v1 = torch.sum(sol_vec.unsqueeze(1).repeat(1, n)*sol_vec.unsqueeze(0).repeat(n, 1)*grad_mat)\\n v1v2 = torch.sum(sol_vec.unsqueeze(1).repeat(1, n)*new_point.unsqueeze(0).repeat(n, 1)*grad_mat)\\n v2v2 = torch.sum(new_point.unsqueeze(1).repeat(1, n)*new_point.unsqueeze(0).repeat(n, 1)*grad_mat)\\n\\n nc, nd = MinNormSolver._min_norm_element_from2(v1v1, v1v2, v2v2)\\n new_sol_vec = nc*sol_vec + (1-nc)*new_point\\n change = new_sol_vec - sol_vec\\n if torch.sum(torch.abs(change)) < MinNormSolver.STOP_CRIT:\\n return sol_vec, nd\\n sol_vec = new_sol_vec\",\n \"def iterative_function_vect(points, numLines, numIter, e_tilde, gamma_tilde, beta_tilde):\\n \\n numPoints = len(points)\\n \\n # Randomly sample pairs and get the corresponding rho and theta parameters for a line fitted to the pair: \\n # Returns a list of tuples - Each tuple has the rho and theta parameters for the line: \\n lines ,idxs = info_rand_sample_fit_lines(points, numLines)\\n \\n \\n # Compute normal distance of each point from each line: Store in a 2-D numpy array: \\n # Points along 1st axis - Rows - axis= 0\\n # Lines along 2nd axis - Columns - axis=1\\n \\n # Initialize the 2-D array: \\n normDist = np.zeros((numPoints, numLines))\\n \\n \\n # Indices for the 2-D array: \\n j,k = 0,0\\n \\n # Loop through points:\\n for point in points: \\n \\n k = 0\\n \\n # Loop through the lines: \\n for line in lines:\\n \\n normDist[j,k] = get_normal_dist(line,point)\\n \\n # Increment the column (line) index:\\n k+=1\\n \\n \\n #Increment the row (point) index\\n j += 1\\n \\n # Transform the Normal Distance matrix to the Probability of Membership matrix: \\n Pr_C = log_dec(normDist,e_tilde)\\n \\n \\n ## Iteratively refine estimates of Prob of Validity - Points and Lines: \\n iterCount = 0\\n \\n # Initialize Probability of Validity of points and lines: \\n initProb =1\\n Pr_A = initProb*np.ones((numPoints,1))\\n Pr_V = np.zeros((numLines,1))\\n \\n \\n # Initialize gamma and beta: Fractions of valid points and lines respectively: \\n gamma = np.zeros_like(Pr_V)\\n beta = np.zeros_like(Pr_A)\\n \\n \\n while iterCount < numIter: \\n \\n # For each line: Compute Gamma:\\n \\n # Compute expected fraction of valid points: \\n gamma = np.dot(Pr_A.T, Pr_C)/np.sum(Pr_A) # Hope the broadcasting works here:\\n \\n \\n # Compute Probability of Validity: \\n Pr_V = log_inc(gamma, gamma_tilde) \\n \\n \\n # For each point: Compute beta:\\n \\n # Compute expected fraction of valid lines in which it is a member: \\n beta = np.dot(Pr_C, Pr_V.T)/np.sum(Pr_V)\\n \\n \\n # Compute Probability of Validity: \\n Pr_A = log_inc(beta, beta_tilde)\\n \\n \\n iterCount +=1\\n \\n # Sort the lines according to Probability of Validity:\\n idx_sort = np.argsort(Pr_V, axis=1)\\n \\n print (\\\" The equations of candidate lines and their probability of validity are: \\\") \\n\\n \\n for idx in idx_sort: \\n print (lines[int(idx)] , end = '-- >')\\n print (Pr_V[idx])\\n \\n return lines, Pr_A, Pr_V\",\n \"def solve(self, regparam):\\n self.regparam = regparam\\n \\n #Some counters for bookkeeping\\n self.stepcounter = 0\\n self.flipcounter = 0\\n self.nochangecounter = 0\\n \\n #Cached results\\n self.evals = np.multiply(self.svals, self.svals)\\n self.newevals = 1. / (self.evals + self.regparam)\\n newevalslamtilde = np.multiply(self.evals, self.newevals)\\n self.D = np.sqrt(newevalslamtilde)\\n #self.D = -newevalslamtilde\\n \\n self.VTY = self.svecs.T * self.Y\\n DVTY = np.multiply(self.D.T, self.svecs.T * self.Y)\\n \\n #Using lists in order to avoid unnecessary matrix slicings\\n self.DVTY_list = []\\n self.YTVDDVTY_list = []\\n self.classFitnessList = []\\n for i in range(self.labelcount):\\n DVTY_i = DVTY[:,i]\\n self.DVTY_list.append(DVTY_i)\\n YTVDDVTY_i = DVTY_i.T * DVTY_i\\n self.YTVDDVTY_list.append(YTVDDVTY_i)\\n fitness_i = self.size - DVTY_i.T * DVTY_i\\n self.classFitnessList.append(fitness_i)\\n \\n self.Dsvecs_list = []\\n self.svecsDDsvecs_list = []\\n for i in range(self.size):\\n Dsvec = np.multiply(self.D.T, self.svecs[i].T)\\n self.Dsvecs_list.append(Dsvec)\\n self.svecsDDsvecs_list.append(Dsvec.T*Dsvec)\\n \\n self.updateA()\\n \\n \\n converged = False\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n while True:\\n \\n converged = self.roundRobin()\\n print(self.classcounts.T)\\n if self.callbackfun is not None:\\n self.callbackfun.callback(self)\\n if converged: break\\n \\n if self.oneclass:\\n self.Y = self.Y[:, 0]\\n self.A = self.A[:, 0]\\n self.results['predicted_clusters_for_training_data'] = self.Y\\n self.predictor = self.svdad.createModel(self)\",\n \"def value_iteration(r,terminal_states_mask, not_slipping_prob=1,\\n initial_policy=None,\\n eps=0.1):\\n V = np.copy(r).astype(np.float)\\n for _ in range(200):\\n Vdet_u = np.copy(V)\\n Vdet_r = np.copy(V)\\n Vdet_l = np.copy(V)\\n Vdet_d = np.copy(V)\\n\\n Vdet_u[1:, :] = V[:-1, :]\\n Vdet_r[:, :-1] = V[:, 1:]\\n Vdet_l[:, 1:] = V[:, :-1]\\n Vdet_d[:-1, :] = V[1:, :]\\n\\n nsp = not_slipping_prob\\n Vnext = np.zeros((4, )+r.shape, dtype=float)\\n Vnext[UP, :, :] = nsp * Vdet_u + 0.5 * (1-nsp) * Vdet_l + 0.5 * (\\n 1-nsp) * Vdet_r\\n Vnext[DOWN, :, :] = nsp * Vdet_d + 0.5 * (1-nsp) * Vdet_l + 0.5 * (\\n 1-nsp) * Vdet_r\\n Vnext[LEFT, :, :] = nsp * Vdet_l + 0.5 * (1-nsp) * Vdet_u + 0.5 * (\\n 1-nsp) * Vdet_d\\n Vnext[RIGHT, :, :] = nsp * Vdet_r + 0.5 * (1-nsp) * Vdet_u + 0.5 * (\\n 1-nsp) * Vdet_d\\n if initial_policy is None:\\n policy = np.argmax(r[None, :, :] + Vnext, axis=0)\\n else:\\n policy = np.copy(initial_policy)\\n\\n Vnew = np.copy(V)\\n for a in [UP, DOWN, LEFT, RIGHT]:\\n ind = np.logical_and(policy == a, ~ terminal_states_mask)\\n Vnew[ind] = r[ind] + Vnext[a][ind]\\n if np.linalg.norm(V - Vnew, ord=np.inf) < eps:\\n break\\n V[:, :] = Vnew\\n return policy, V\",\n \"def analytical_eig(A):\\n n = len(A)\\n h = 1/float(n)\\n d = 2/float(h)**2\\n a = -1/float(h)**2\\n eigenval = np.empty(n)\\n for j in range(1,n+1):\\n eigenval[j-1] = d + 2*a*np.cos((j*np.pi)/(float(n)+1)) # Analytic solution\\n \\n return eigenval\",\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 svd_factorization_projections(A, m, n, orth_tol, max_refin, tol):\\n # SVD Factorization\\n U, s, Vt = scipy.linalg.svd(A, full_matrices=False)\\n\\n # Remove dimensions related with very small singular values\\n U = U[:, s > tol]\\n Vt = Vt[s > tol, :]\\n s = s[s > tol]\\n\\n # z = x - A.T inv(A A.T) A x\\n def null_space(x):\\n # v = U 1/s V.T x = inv(A A.T) A x\\n aux1 = Vt.dot(x)\\n aux2 = 1/s*aux1\\n v = U.dot(aux2)\\n z = x - A.T.dot(v)\\n\\n # Iterative refinement to improve roundoff\\n # errors described in [2]_, algorithm 5.1.\\n k = 0\\n while orthogonality(A, z) > orth_tol:\\n if k >= max_refin:\\n break\\n # v = U 1/s V.T x = inv(A A.T) A x\\n aux1 = Vt.dot(z)\\n aux2 = 1/s*aux1\\n v = U.dot(aux2)\\n # z_next = z - A.T v\\n z = z - A.T.dot(v)\\n k += 1\\n\\n return z\\n\\n # z = inv(A A.T) A x\\n def least_squares(x):\\n # z = U 1/s V.T x = inv(A A.T) A x\\n aux1 = Vt.dot(x)\\n aux2 = 1/s*aux1\\n z = U.dot(aux2)\\n return z\\n\\n # z = A.T inv(A A.T) x\\n def row_space(x):\\n # z = V 1/s U.T x\\n aux1 = U.T.dot(x)\\n aux2 = 1/s*aux1\\n z = Vt.T.dot(aux2)\\n return z\\n\\n return null_space, least_squares, row_space\",\n \"def run_vqe(\\n self,\\n backend=Aer.get_backend(\\\"statevector_simulator\\\"),\\n var_form=None,\\n optimizer=None,\\n reps=None,\\n mode=\\\"min_val\\\",\\n ):\\n # N=int(np.ceil(np.log2(len(self.mat))))\\n # hk = np.zeros((2**N,2**N),dtype='complex')\\n # hk[:self.mat.shape[0], :self.mat.shape[1]] = self.mat\\n N = self.n_qubits()\\n if mode == \\\"max_val\\\":\\n Hamil_mat = aqua.operators.MatrixOperator(-1 * self.mat)\\n # Hamil_mat = MatrixOperator(-1 * self.mat)\\n else:\\n Hamil_mat = aqua.operators.MatrixOperator(self.mat)\\n # Hamil_mat = MatrixOperator(self.mat)\\n Hamil_qop = aqua.operators.op_converter.to_weighted_pauli_operator(\\n Hamil_mat\\n )\\n if var_form is None:\\n if reps is None:\\n reps = 2\\n # reps=5\\n from qiskit.circuit.library import EfficientSU2\\n\\n var_form = EfficientSU2(N, reps=reps)\\n if optimizer is None:\\n vqe = aqua.algorithms.VQE(Hamil_qop, var_form)\\n # vqe = VQE(Hamil_qop, var_form)\\n else:\\n vqe = aqua.algorithms.VQE(Hamil_qop, var_form, optimizer)\\n # vqe = VQE(Hamil_qop, var_form, optimizer)\\n vqe_result = vqe.run(backend)\\n en = np.real(vqe_result[\\\"eigenvalue\\\"])\\n # params=vqe.optimal_params\\n # circuit=vqe.construct_circuit(params)\\n if mode == \\\"max_val\\\":\\n en = -1 * en\\n # states = np.sort(\\n # np.real(\\n # vqe.expectation.convert(\\n # StateFn(vqe.operator, is_measurement=True)\\n # ).to_matrix()\\n # )\\n # )\\n return en, vqe_result, vqe\",\n \"def refugia_adj_5_simsplit_4epochs_iter5 (params, ns):\\n #28 parameters \\n nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T1, T2, T3, T4 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2]) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\\n nu_T1 = [nu1a, nu2a, nu3a]\\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \\n fs.integrate(nu_T1, T1, m=mig1)\\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\\n nu_T2 = [nu1b, nu2b, nu3b]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\\n nu_T3 = [nu1c, nu2c, nu3c]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3)\\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\\n nu_T4 = [nu1d, nu2d, nu3d]\\n fs.integrate(nu_T4, T4) \\n return fs\",\n \"def test_too_low_max_iterations(self):\\n\\n # Set up the problem of finding the square roots of three numbers.\\n constants = np.array([4.0, 9.0, 16.0])\\n initial_values = np.ones(len(constants))\\n\\n def objective_and_gradient(values):\\n objective = values**2 - constants\\n gradient = 2.0 * values\\n return objective, gradient\\n\\n # Obtain and evaluate a tensor containing the roots.\\n roots = newton_root_finder(\\n objective_and_gradient, initial_values, max_iterations=1)\\n _, converged, failed = self.evaluate(roots)\\n\\n # Reference values - we should neither have converged nor failed.\\n converged_bench = np.array([False, False, False])\\n failed_bench = np.array([False, False, False])\\n\\n # Assert that the values we obtained are close to the true values.\\n np.testing.assert_array_equal(converged, converged_bench)\\n np.testing.assert_array_equal(failed, failed_bench)\",\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 value_iteration(P, nS, nA, V, gamma=0.9, tol=1e-8):\\n \\n V_new = V.copy()\\n ############################\\n # YOUR IMPLEMENTATION HERE #\\n while True:\\n deltaV=0;\\n for state in range(nS):\\n # new_value=0;\\n action_policy = np.zeros(nA) \\n for action in range(nA):\\n for p,nextS,r,boolean_v in P[state][action]:\\n action_policy[action] += p*( r + gamma* V[nextS])\\n V_new[state]=max(action_policy)\\n deltaV= max(deltaV, abs(V_new[state]-V[state]))\\n V[state] = V_new[state]\\n #print(value_function)\\n if(deltaV < tol):\\n break\\n policy_new = policy_improvement(P, nS, nA, V_new, gamma)\\n ############################\\n return policy_new, V_new\",\n \"def mt(P_1,V0_1,meanF_1,rho): \\n psi = np.arctan2(V0_1[2],-V0_1[0])\\n \\n # Find swept ares\\n idx_zmax = np.argmax(P_1[:,-1,2])\\n idx_ymax = np.argmax(P_1[:,-1,1])\\n idx_zmin = np.argmin(P_1[:,-1,2])\\n \\n Ad = np.linalg.norm(P_1[idx_zmax,-1,2]-P_1[idx_zmin,-1,2])*P_1[idx_ymax,-1,1]\\n print P_1[idx_zmax,-1,2]\\n V0 = np.linalg.norm(V0_1)\\n \\n Vi_1new = np.zeros_like(V0_1,dtype=float)\\n\\n while True:\\n Vi_1 = Vi_1new\\n \\n Vi_1new[0] = meanF_1[0] / (2 * rho * Ad * np.sqrt( (V0*np.cos(psi)+Vi_1[0])**2 + (-V0*np.sin(psi)+Vi_1[2])**2 )) \\n Vi_1new[2] = meanF_1[2] / (2 * rho * Ad * np.sqrt( (V0*np.cos(psi)+Vi_1[0])**2 + (-V0*np.sin(psi)+Vi_1[2])**2 )) \\n \\n if np.linalg.norm(Vi_1-Vi_1new) < 0.001:\\n break\\n\\n return -Vi_1\",\n \"def _generate_jitted_eigsh_lanczos(jax: types.ModuleType) -> Callable:\\n\\n @functools.partial(jax.jit, static_argnums=(3, 4, 5, 6))\\n def jax_lanczos(matvec, arguments, init, ncv, neig, landelta, reortho):\\n \\\"\\\"\\\"\\n Jitted lanczos routine.\\n Args:\\n matvec: A callable implementing the matrix-vector product of a\\n linear operator.\\n arguments: Arguments to `matvec` additional to an input vector.\\n `matvec` will be called as `matvec(init, *args)`.\\n init: An initial input state to `matvec`.\\n ncv: Number of krylov iterations (i.e. dimension of the Krylov space).\\n neig: Number of eigenvalue-eigenvector pairs to be computed.\\n landelta: Convergence parameter: if the norm of the current Lanczos vector\\n falls below `landelta`, iteration is stopped.\\n reortho: If `True`, reorthogonalize all krylov vectors at each step.\\n This should be used if `neig>1`.\\n Returns:\\n jax.numpy.ndarray: Eigenvalues\\n list: Eigenvectors\\n \\\"\\\"\\\"\\n\\n def body_modified_gram_schmidt(i, vals):\\n vector, krylov_vectors = vals\\n v = krylov_vectors[i, :]\\n vector -= jax.numpy.vdot(v, vector) * jax.numpy.reshape(v, vector.shape)\\n return [vector, krylov_vectors]\\n\\n def body_lanczos(vals):\\n current_vector, krylov_vectors, vector_norms = vals[0:3]\\n diagonal_elements, matvec, args, _ = vals[3:7]\\n threshold, i, maxiteration = vals[7:]\\n norm = jax.numpy.linalg.norm(current_vector)\\n normalized_vector = current_vector / norm\\n normalized_vector, krylov_vectors = jax.lax.cond(\\n reortho, True,\\n lambda x: jax.lax.fori_loop(0, i, body_modified_gram_schmidt,\\n [normalized_vector, krylov_vectors]),\\n False, lambda x: [normalized_vector, krylov_vectors])\\n Av = matvec(normalized_vector, *args)\\n\\n diag_element = jax.numpy.vdot(normalized_vector, Av)\\n\\n res = jax.numpy.reshape(\\n jax.numpy.ravel(Av) -\\n jax.numpy.ravel(normalized_vector) * diag_element -\\n krylov_vectors[i - 1] * norm, Av.shape)\\n krylov_vectors = jax.ops.index_update(krylov_vectors, jax.ops.index[i, :],\\n jax.numpy.ravel(normalized_vector))\\n\\n vector_norms = jax.ops.index_update(vector_norms, jax.ops.index[i - 1],\\n norm)\\n diagonal_elements = jax.ops.index_update(diagonal_elements,\\n jax.ops.index[i - 1],\\n diag_element)\\n\\n return [\\n res, krylov_vectors, vector_norms, diagonal_elements, matvec, args,\\n norm, threshold, i + 1, maxiteration\\n ]\\n\\n def cond_fun(vals):\\n _, _, _, _, _, _, norm, threshold, iteration, maxiteration = vals\\n\\n def check_thresh(check_vals):\\n val, thresh = check_vals\\n return jax.lax.cond(val < thresh, False, lambda x: x, True, lambda x: x)\\n\\n return jax.lax.cond(iteration <= maxiteration, [norm, threshold],\\n check_thresh, False, lambda x: x)\\n\\n numel = jax.numpy.prod(init.shape)\\n krylov_vecs = jax.numpy.zeros((ncv + 1, numel), dtype=init.dtype)\\n norms = jax.numpy.zeros(ncv, dtype=init.dtype)\\n diag_elems = jax.numpy.zeros(ncv, dtype=init.dtype)\\n\\n norms = jax.ops.index_update(norms, jax.ops.index[0], 1.0)\\n\\n norms_dtype = jax.numpy.real(jax.numpy.empty((0, 0),\\n dtype=init.dtype)).dtype\\n initvals = [\\n init, krylov_vecs, norms, diag_elems, matvec, arguments,\\n norms_dtype.type(1.0), landelta, 1, ncv\\n ]\\n output = jax.lax.while_loop(cond_fun, body_lanczos, initvals)\\n final_state, krylov_vecs, norms, diags, _, _, _, _, it, _ = output\\n krylov_vecs = jax.ops.index_update(krylov_vecs, jax.ops.index[it, :],\\n jax.numpy.ravel(final_state))\\n\\n A_tridiag = jax.numpy.diag(diags) + jax.numpy.diag(\\n norms[1:], 1) + jax.numpy.diag(jax.numpy.conj(norms[1:]), -1)\\n eigvals, U = jax.numpy.linalg.eigh(A_tridiag)\\n eigvals = eigvals.astype(A_tridiag.dtype)\\n\\n def body_vector(i, vals):\\n krv, unitary, states = vals\\n dim = unitary.shape[1]\\n n, m = jax.numpy.divmod(i, dim)\\n states = jax.ops.index_add(states, jax.ops.index[n, :],\\n krv[m + 1, :] * unitary[m, n])\\n return [krv, unitary, states]\\n\\n state_vectors = jax.numpy.zeros([neig, numel], dtype=init.dtype)\\n _, _, vectors = jax.lax.fori_loop(0, neig * (krylov_vecs.shape[0] - 1),\\n body_vector,\\n [krylov_vecs, U, state_vectors])\\n\\n return jax.numpy.array(eigvals[0:neig]), [\\n jax.numpy.reshape(vectors[n, :], init.shape) /\\n jax.numpy.linalg.norm(vectors[n, :]) for n in range(neig)\\n ]\\n\\n return jax_lanczos\",\n \"def boxcar(self, box_dm: float = 0.5, n: int = 4, el_included=None, m_uplim: float=np.inf, is_info: bool = False):\\n clone = self.clone()\\n abund = clone.abund()\\n # abun = np.zeros((clone.nzon, len(clone.Elements)))\\n if el_included is None:\\n el_included = clone.Elements\\n if m_uplim is None:\\n m_uplim = np.inf\\n m = clone.m / phys.M_sun\\n dmass = np.diff(m)\\n dmass = np.insert(dmass, -1, dmass[-1])\\n\\n # todo Check left boundary condition fo Fe, Si\\n for l in range(n): # the iteration number\\n logger.debug(f'Attempt # {l}')\\n for k in range(clone.nzon):\\n if m[k] > m_uplim:\\n logger.warn(f'Exit from zone cycle m[k] > m_uplim: k= {k} m= {m[k]:.4f} m_uplim= {m_uplim:.4f}')\\n break # stop because mass is over the limit\\n kk = k + 1\\n dm = dmass[k]\\n while dm < box_dm and kk <= clone.nzon:\\n kk += 1\\n dm = np.sum(dmass[k:kk])\\n\\n logger.debug(f'{k}: kk= {kk} dm= {dm:.4f} m= {m[k]:.4f}')\\n if dm > 1e-6:\\n for i, ename in enumerate(clone.Elements):\\n if ename in el_included:\\n dm_e = np.dot(abund[k:kk, i], dmass[k:kk])\\n abund[k, i] = dm_e / dm\\n # abun[k,i] = x[k]\\n for i, ename in enumerate(clone.Elements):\\n clone.set_chem(ename, abund[:, i]) \\n logger.debug(f\\\"{ename}: {clone.el(ename)}\\\")\\n\\n return clone\",\n \"def evaltr(x_solution): \\n \\n large = 10.0**30\\n pred = np.zeros(cfg.ntrain)\\n e0 = 0.0 # mean of observed values\\n y=0.0\\n for i in range(cfg.ntrain): # Computation of correct piece\\n e0 += cfg.a_unscaled[i][-1]\\n pind = 0\\n ipbest = 0\\n pbest = -large # for max\\n \\n for j1 in range(cfg.nomax):\\n ipmin=pind\\n pmin=large # for min\\n for _ in range(cfg.jk[j1]):\\n piece=x_solution[(pind+1)*cfg.nfea-1] \\n for j3 in range(cfg.nfea-1): #\\n piece += x_solution[pind*cfg.nfea+j3]*cfg.a_unscaled[i][j3]\\n if piece < pmin:\\n ipmin = pind\\n pmin = piece\\n pind += 1 \\n \\n if pmin > pbest:\\n ipbest = ipmin\\n pbest = pmin\\n \\n pred[i] = x_solution[(ipbest+1)*cfg.nfea-1] # Computation of prediction\\n for j1 in range(cfg.nfea-1):\\n pred[i] += x_solution[ipbest*cfg.nfea+j1]*cfg.a_unscaled[i][j1]\\n y += pred[i]\\n \\n y = y/cfg.ntrain \\n e0 = e0/cfg.ntrain\\n \\n # Computation of indices\\n rmse = 0.0\\n mae = 0.0\\n e1 = 0.0\\n for i in range(cfg.ntrain):\\n rmse += (pred[i]-cfg.a_unscaled[i][-1])**2\\n mae += np.abs(pred[i]-cfg.a_unscaled[i][-1]) \\n e1 += (cfg.a_unscaled[i][-1] - e0)**2\\n ce = 1.0 - rmse/e1 \\n rmse = np.sqrt(rmse/cfg.ntrain)\\n mae = mae/cfg.ntrain \\n\\n if cfg.ntrain > 1:\\n sx=0.0\\n sy=0.0\\n rcor=0.0\\n for i in range(cfg.ntrain):\\n sx += (pred[i]-y)**2\\n sy += (cfg.a_unscaled[i][-1]-e0)**2 \\n rcor += (pred[i]-y) * (cfg.a_unscaled[i][-1]-e0) \\n\\n r = rcor/np.sqrt(sx*sy)\\n \\n return rmse,mae,ce,r\",\n \"def solveNonlinear1(A, u_n, F_b, lam=1.5, tol=10e-10, maxiter=100):\\n du = np.copy(u_n)\\n error = 100\\n iter = 0\\n F = A @ u_n - lam / u_n ** 2 - F_b\\n\\n while iter < maxiter and error > tol:\\n #Standard newthons method\\n\\n jacobian = A + np.diag(lam / u_n)\\n\\n du = splin.lgmres(jacobian, -F, du)[0]\\n\\n u_n += du\\n\\n F = A @ u_n - lam / u_n **2 - F_b\\n\\n\\n error = np.nanmax(np.abs(F))\\n iter += 1\\n\\n return u_n, error, iter\",\n \"def calcEVals(self):\\n self.eVals,self.eVecs = np.linalg.eigh(self.rhoOp)\",\n \"def __init__( self ):\\n self.NQ = 16\\n self.Nbranches = 3\\n self.NatomsUC = 1\\n self.dim = 3\\n self.QVectors = np.zeros( ( self.NQ , 3 ) )\\n self.MakeQVectors()\\n self.EigenVectors = np.zeros( [ self.NQ , \\n self.Nbranches ,\\n self.NatomsUC , \\n self.dim ] )\\n self.MakeEigenVectors()\",\n \"def one_step(self):\\r\\n assert (self.uv_vol is not None)\\r\\n assert (self.guv_vol is not None)\\r\\n assert (self.uv_bound is not None)\\r\\n assert (self.vf_vect_bound is not None)\\r\\n assert (self.vF_vect_vol is not None)\\r\\n # Shape checks\\r\\n assert (self.vF_vect_vol.size == self.vF_vect_vol.shape[0])\\r\\n assert (self.vf_vect_bound.size == self.vf_vect_bound.shape[0])\\r\\n assert (self.vF_vect_vol.shape == self.vf_vect_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.uv_vol.shape[1])\\r\\n assert (self.uv_vol.shape == self.guv_vol.shape)\\r\\n assert (self.uv_vol.shape == self.uv_bound.shape)\\r\\n assert (self.uv_vol.shape[0] == self.vF_vect_vol.shape[0])\\r\\n \\r\\n if self.step == 0:\\r\\n self.check_k_matrix_stability()\\r\\n # print(\\\"Epsilon is :\\\"+str(self.Epsilon))\\r\\n # print(\\\"Beta is :\\\"+str(self.Beta))\\r\\n\\r\\n # Form \\\"Stiffness\\\" matrix:\\r\\n K = self.make_k_matrix()\\r\\n # Form \\\"Force\\\" vector: \\r\\n f = self.vF_vect_vol + (self.Epsilon / self.Beta) * self.vf_vect_bound\\r\\n\\r\\n # print(\\\"FORCE VECTOR:\\\")\\r\\n # print(f)\\r\\n # print(\\\"STIFFNESS MATRIX\\\")\\r\\n # print(K)\\r\\n # print(\\\"UV_VOL\\\")\\r\\n # print(self.uv_vol)\\r\\n # print(\\\"EPSILON * GUV_VOL\\\")\\r\\n # print(self.Epsilon * self.guv_vol)\\r\\n # print(\\\"UV_BOUND * COEFF\\\")\\r\\n # print((self.Epsilon / self.Beta) * self.uv_bound)\\r\\n sol = scipy_sparse_linsolve(K, f)\\r\\n # print(\\\"SOLUTION\\\")\\r\\n # print(sol)\\r\\n return sol\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72669476","0.6188595","0.617031","0.6000074","0.5868834","0.58029294","0.5790344","0.57772875","0.5773755","0.5764524","0.56795913","0.5678016","0.5666207","0.56653416","0.5660726","0.5638518","0.5625004","0.5608089","0.56063926","0.56031847","0.55983907","0.5592206","0.5555471","0.55465263","0.5537079","0.55366296","0.55288404","0.55088073","0.5468226","0.5466217","0.5452875","0.5446391","0.54460293","0.54460293","0.543991","0.54354244","0.54292834","0.54242563","0.54196906","0.54115105","0.5410081","0.54000276","0.5392279","0.5388296","0.5386496","0.53859514","0.53595716","0.53537995","0.53497535","0.5349657","0.5345722","0.53427696","0.5337765","0.53183687","0.5318238","0.5310569","0.53053695","0.5302989","0.53011864","0.5298011","0.52938855","0.5290844","0.5289451","0.5286529","0.52828294","0.5274309","0.5263442","0.52523106","0.52438515","0.52431434","0.5238593","0.52319324","0.52241015","0.5216925","0.52153045","0.52150005","0.52118444","0.521176","0.5211191","0.5200727","0.51925874","0.51921356","0.5172576","0.51712865","0.51572466","0.5147953","0.5142312","0.5141556","0.5139682","0.5134786","0.51328635","0.51321393","0.51301056","0.5129749","0.5125871","0.5122754","0.5114759","0.51137954","0.51134235","0.51130146"],"string":"[\n \"0.72669476\",\n \"0.6188595\",\n \"0.617031\",\n \"0.6000074\",\n \"0.5868834\",\n \"0.58029294\",\n \"0.5790344\",\n \"0.57772875\",\n \"0.5773755\",\n \"0.5764524\",\n \"0.56795913\",\n \"0.5678016\",\n \"0.5666207\",\n \"0.56653416\",\n \"0.5660726\",\n \"0.5638518\",\n \"0.5625004\",\n \"0.5608089\",\n \"0.56063926\",\n \"0.56031847\",\n \"0.55983907\",\n \"0.5592206\",\n \"0.5555471\",\n \"0.55465263\",\n \"0.5537079\",\n \"0.55366296\",\n \"0.55288404\",\n \"0.55088073\",\n \"0.5468226\",\n \"0.5466217\",\n \"0.5452875\",\n \"0.5446391\",\n \"0.54460293\",\n \"0.54460293\",\n \"0.543991\",\n \"0.54354244\",\n \"0.54292834\",\n \"0.54242563\",\n \"0.54196906\",\n \"0.54115105\",\n \"0.5410081\",\n \"0.54000276\",\n \"0.5392279\",\n \"0.5388296\",\n \"0.5386496\",\n \"0.53859514\",\n \"0.53595716\",\n \"0.53537995\",\n \"0.53497535\",\n \"0.5349657\",\n \"0.5345722\",\n \"0.53427696\",\n \"0.5337765\",\n \"0.53183687\",\n \"0.5318238\",\n \"0.5310569\",\n \"0.53053695\",\n \"0.5302989\",\n \"0.53011864\",\n \"0.5298011\",\n \"0.52938855\",\n \"0.5290844\",\n \"0.5289451\",\n \"0.5286529\",\n \"0.52828294\",\n \"0.5274309\",\n \"0.5263442\",\n \"0.52523106\",\n \"0.52438515\",\n \"0.52431434\",\n \"0.5238593\",\n \"0.52319324\",\n \"0.52241015\",\n \"0.5216925\",\n \"0.52153045\",\n \"0.52150005\",\n \"0.52118444\",\n \"0.521176\",\n \"0.5211191\",\n \"0.5200727\",\n \"0.51925874\",\n \"0.51921356\",\n \"0.5172576\",\n \"0.51712865\",\n \"0.51572466\",\n \"0.5147953\",\n \"0.5142312\",\n \"0.5141556\",\n \"0.5139682\",\n \"0.5134786\",\n \"0.51328635\",\n \"0.51321393\",\n \"0.51301056\",\n \"0.5129749\",\n \"0.5125871\",\n \"0.5122754\",\n \"0.5114759\",\n \"0.51137954\",\n \"0.51134235\",\n \"0.51130146\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.84747493"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81596,"cells":{"query":{"kind":"string","value":"Set lamp intensity in the range [0, 255]"},"document":{"kind":"string","value":"def set_intensity(self, value):\n self._spectra._set_intensity(self._name, value)"},"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 setLum ( self, newlum ):\n if isinstance( newlum, int ):\n newlum /= 100\n if newlum > 1.0:\n newlum = 1.0\n if newlum < 0.0:\n newlum = 0.0\n self.l = newlum\n self.hsl[2] = newlum\n self.hsla[2] = newlum\n self.updateFromHsl()","def __add_color(self, intensity):\n val = color.rgb2lab(\n (self.image[self.lip_y, self.lip_x] / 255.)\n .reshape(len(self.lip_y), 1, 3)\n ).reshape(len(self.lip_y), 3)\n l_val, a_val, b_val = np.mean(val[:, 0]), np.mean(val[:, 1]), np.mean(val[:, 2])\n l1_val, a1_val, b1_val = color.rgb2lab(\n np.array(\n (self.red_l / 255., self.green_l / 255., self.blue_l / 255.)\n ).reshape(1, 1, 3)\n ).reshape(3,)\n l_final, a_final, b_final = (l1_val - l_val) * \\\n intensity, (a1_val - a_val) * \\\n intensity, (b1_val - b_val) * intensity\n val[:, 0] = np.clip(val[:, 0] + l_final, 0, 100)\n val[:, 1] = np.clip(val[:, 1] + a_final, -127, 128)\n val[:, 2] = np.clip(val[:, 2] + b_final, -127, 128)\n self.image[self.lip_y, self.lip_x] = color.lab2rgb(val.reshape(\n len(self.lip_y), 1, 3)).reshape(len(self.lip_y), 3) * 255","def set_brightness(distance):\n if math.floor(distance / 100) - 1 >= 0 and math.floor(distance / 100) - 1 <= 9:\n return 9 - (math.floor(distance / 100) - 1)\n elif math.floor(distance / 100) - 1 >= 0:\n return 1\n else:\n return 9","def setColourLevels(self):\n minsg = np.min(self.sg)\n maxsg = np.max(self.sg)\n brightness = self.brightnessSlider.value()\n contrast = self.contrastSlider.value()\n colourStart = (brightness / 100.0 * contrast / 100.0) * (maxsg - minsg) + minsg\n colourEnd = (maxsg - minsg) * (1.0 - contrast / 100.0) + colourStart\n for btn in self.picbuttons:\n btn.stopPlayback()\n btn.setImage(self.lut, colourStart, colourEnd, False)\n btn.update()","def lamp_set_color(color):\n addresses = lamp_addresses\n\n r = hex(color[0])[2:].zfill(2)\n g = hex(color[1])[2:].zfill(2)\n b = hex(color[2])[2:].zfill(2)\n\n # the 01 here at the beginning of the message means that\n # the lamp will hold the color even when the connection is lost\n value = \"01\" + r + g + b\n\n for address in addresses:\n command = \"gatttool -b {} -t random --char-write --handle=0x0011 --value={}\".format(address, value)\n logging.debug(\"Sending command to RFduino: \" + command)\n os.system(command)","def _clamp_rgb_coordinate(self, coord):\r\n\r\n if not self.is_upscaled:\r\n return min(max(coord, 0.0), 1.0)\r\n else:\r\n return min(max(coord, 1), 255)","def luminance(self, color):\n return 0.2426 * color[2] + 0.7152 * color[1] + 0.0722 * color[0]","def luminance(self):\n \n return (self.r + self.g + self.b) // 3","def setSurfaceColorScale(low,high):\n dislin.zscale(low,high)","def setMyColorTable(lr,lg,lb):\n dislin.myvlt(lr,lg,lb,len(lr))","def change_brightness(image, value):\n\n return change_light(image, value, \"v\")","def scaleClipl(x):\n x = 0 if x < 0 else x\n x = 1 if x > 1 else x\n return int(round(x*255.))","def update(self):\n self._brightness = self._lj.get_load_level(self._index) / 99 * 255","def _ampl_color(self, amplitude, frame):\n color=(0,0,0)\n for col in self._color:\n if frame >= col[0]:\n color = col[1]\n return color + (int(self._amplfactor * amplitude),)","def log_scale_ds9(im, lexp=1.e12, cmap=[7.97917, 0.8780493], scale=[-0.1,10]):\n import numpy as np\n \n contrast, bias = cmap\n clip = (np.clip(im, scale[0], scale[1])-scale[0])/(scale[1]-scale[0])\n clip_log = np.clip((np.log10(lexp*clip+1)/np.log10(lexp)-bias)*contrast+0.5, 0, 1)\n \n return clip_log","def setColors255(self):\r\n # productive\r\n profprint()\r\n self.color255 = [[0, 0, 0] for i in range(MAXCOL)]\r\n self.color255[0] = [221, 108, 158]\r\n self.color255[1] = [128, 174, 128]\r\n self.color255[2] = [241, 214, 145]\r\n self.color255[3] = [177, 122, 101]\r\n self.color255[4] = [111, 184, 210]\r\n self.color255[5] = [216, 101, 79]\r\n self.color255[6] = [221, 130, 101]\r\n self.color255[7] = [144, 238, 144]\r\n self.color255[8] = [192, 104, 88]\r\n self.color255[9] = [220, 245, 20]\r\n self.color255[10] = [78, 63, 0]\r\n self.color255[11] = [255, 250, 220]\r\n self.color255[12] = [230, 220, 70]\r\n self.color255[13] = [200, 200, 235]\r\n self.color255[14] = [250, 250, 210]\r\n self.color255[15] = [244, 214, 49]\r\n self.color255[16] = [0, 151, 206]\r\n self.color255[17] = [183, 156, 220]\r\n self.color255[18] = [183, 214, 211]\r\n self.color255[19] = [152, 189, 207]\r\n self.color255[20] = [178, 212, 242]\r\n self.color255[21] = [68, 172, 100]\r\n self.color255[22] = [111, 197, 131]\r\n self.color255[23] = [85, 188, 255]\r\n self.color255[24] = [0, 145, 30]\r\n self.color255[25] = [214, 230, 130]\r\n self.color255[26] = [218, 255, 255]\r\n self.color255[27] = [170, 250, 250]\r\n self.color255[28] = [140, 224, 228]\r\n self.color255[29] = [188, 65, 28]\r\n self.color255[30] = [216, 191, 216]\r\n self.color255[31] = [145, 60, 66]\r\n self.color255[32] = [150, 98, 83]\r\n self.color255[33] = [250, 250, 225]\r\n self.color255[34] = [200, 200, 215]\r\n self.color255[35] = [68, 131, 98]\r\n self.color255[36] = [83, 146, 164]\r\n self.color255[37] = [162, 115, 105]\r\n self.color255[38] = [141, 93, 137]\r\n self.color255[39] = [182, 166, 110]\r\n self.color255[40] = [188, 135, 166]\r\n self.color255[41] = [154, 150, 201]\r\n self.color255[42] = [177, 140, 190]\r\n self.color255[43] = [30, 111, 85]\r\n self.color255[44] = [210, 157, 166]\r\n self.color255[45] = [48, 129, 126]\r\n self.color255[46] = [98, 153, 112]\r\n self.color255[47] = [69, 110, 53]\r\n self.color255[48] = [166, 113, 137]\r\n self.color255[49] = [122, 101, 38]\r\n self.color255[50] = [253, 135, 192]\r\n self.color255[51] = [145, 92, 109]\r\n self.color255[52] = [46, 101, 131]\r\n self.color255[53] = [0, 108, 112]\r\n self.color255[54] = [127, 150, 88]\r\n self.color255[55] = [159, 116, 163]\r\n self.color255[56] = [125, 102, 154]\r\n self.color255[57] = [106, 174, 155]\r\n self.color255[58] = [154, 146, 83]\r\n self.color255[59] = [126, 126, 55]\r\n self.color255[60] = [201, 160, 133]\r\n self.color255[61] = [78, 152, 141]\r\n self.color255[62] = [174, 140, 103]\r\n self.color255[63] = [139, 126, 177]\r\n self.color255[64] = [148, 120, 72]\r\n self.color255[65] = [186, 135, 135]\r\n self.color255[66] = [99, 106, 24]\r\n self.color255[67] = [156, 171, 108]\r\n self.color255[68] = [64, 123, 147]\r\n self.color255[69] = [138, 95, 74]\r\n self.color255[70] = [97, 113, 158]\r\n self.color255[71] = [126, 161, 197]\r\n self.color255[72] = [194, 195, 164]\r\n self.color255[73] = [88, 106, 215]\r\n self.color255[74] = [82, 174, 128]\r\n self.color255[75] = [57, 157, 110]\r\n self.color255[76] = [60, 143, 83]\r\n self.color255[77] = [92, 162, 109]\r\n self.color255[78] = [255, 244, 209]\r\n self.color255[79] = [201, 121, 77]\r\n self.color255[80] = [70, 163, 117]\r\n self.color255[81] = [188, 91, 95]\r\n self.color255[82] = [166, 84, 94]\r\n self.color255[83] = [182, 105, 107]\r\n self.color255[84] = [229, 147, 118]\r\n self.color255[85] = [174, 122, 90]\r\n self.color255[86] = [201, 112, 73]\r\n self.color255[87] = [194, 142, 0]\r\n self.color255[88] = [241, 213, 144]\r\n self.color255[89] = [203, 179, 77]\r\n self.color255[90] = [229, 204, 109]\r\n self.color255[91] = [255, 243, 152]\r\n self.color255[92] = [209, 185, 85]\r\n self.color255[93] = [248, 223, 131]\r\n self.color255[94] = [255, 230, 138]\r\n self.color255[95] = [196, 172, 68]\r\n self.color255[96] = [255, 255, 167]\r\n self.color255[97] = [255, 250, 160]\r\n self.color255[98] = [255, 237, 145]\r\n self.color255[99] = [242, 217, 123]\r\n self.color255[100] = [222, 198, 101]\r\n self.color255[101] = [213, 124, 109]\r\n self.color255[102] = [184, 105, 108]\r\n self.color255[103] = [150, 208, 243]\r\n self.color255[104] = [62, 162, 114]\r\n self.color255[105] = [242, 206, 142]\r\n self.color255[106] = [250, 210, 139]\r\n self.color255[107] = [255, 255, 207]\r\n self.color255[108] = [182, 228, 255]\r\n self.color255[109] = [175, 216, 244]\r\n self.color255[110] = [197, 165, 145]\r\n self.color255[111] = [172, 138, 115]\r\n self.color255[112] = [202, 164, 140]\r\n self.color255[113] = [224, 186, 162]\r\n self.color255[114] = [255, 245, 217]\r\n self.color255[115] = [206, 110, 84]\r\n self.color255[116] = [210, 115, 89]\r\n self.color255[117] = [203, 108, 81]\r\n self.color255[118] = [233, 138, 112]\r\n self.color255[119] = [195, 100, 73]\r\n self.color255[120] = [181, 85, 57]\r\n self.color255[121] = [152, 55, 13]\r\n self.color255[122] = [159, 63, 27]\r\n self.color255[123] = [166, 70, 38]\r\n self.color255[124] = [218, 123, 97]\r\n self.color255[125] = [225, 130, 104]\r\n self.color255[126] = [224, 97, 76]\r\n self.color255[127] = [184, 122, 154]\r\n self.color255[128] = [211, 171, 143]\r\n self.color255[129] = [47, 150, 103]\r\n self.color255[130] = [173, 121, 88]\r\n self.color255[131] = [188, 95, 76]\r\n self.color255[132] = [255, 239, 172]\r\n self.color255[133] = [226, 202, 134]\r\n self.color255[134] = [253, 232, 158]\r\n self.color255[135] = [244, 217, 154]\r\n self.color255[136] = [205, 179, 108]\r\n self.color255[137] = [186, 124, 161]\r\n self.color255[138] = [255, 255, 220]\r\n self.color255[139] = [234, 234, 194]\r\n self.color255[140] = [204, 142, 178]\r\n self.color255[141] = [180, 119, 153]\r\n self.color255[142] = [216, 132, 105]\r\n self.color255[143] = [255, 253, 229]\r\n self.color255[144] = [205, 167, 142]\r\n self.color255[145] = [204, 168, 143]\r\n self.color255[146] = [255, 224, 199]\r\n self.color255[147] = [139, 150, 98]\r\n self.color255[148] = [249, 180, 111]\r\n self.color255[149] = [157, 108, 162]\r\n self.color255[150] = [203, 136, 116]\r\n self.color255[151] = [185, 102, 83]\r\n self.color255[152] = [247, 182, 164]\r\n self.color255[153] = [222, 154, 132]\r\n self.color255[154] = [124, 186, 223]\r\n self.color255[155] = [249, 186, 150]\r\n self.color255[156] = [244, 170, 147]\r\n self.color255[157] = [255, 181, 158]\r\n self.color255[158] = [255, 190, 165]\r\n self.color255[159] = [227, 153, 130]\r\n self.color255[160] = [213, 141, 113]\r\n self.color255[161] = [193, 123, 103]\r\n self.color255[162] = [216, 146, 127]\r\n self.color255[163] = [230, 158, 140]\r\n self.color255[164] = [245, 172, 147]\r\n self.color255[165] = [241, 172, 151]\r\n self.color255[166] = [177, 124, 92]\r\n self.color255[167] = [171, 85, 68]\r\n self.color255[168] = [217, 198, 131]\r\n self.color255[169] = [212, 188, 102]\r\n self.color255[170] = [185, 135, 134]\r\n self.color255[171] = [198, 175, 125]\r\n self.color255[172] = [194, 98, 79]\r\n self.color255[173] = [255, 238, 170]\r\n self.color255[174] = [206, 111, 93]\r\n self.color255[175] = [216, 186, 0]\r\n self.color255[176] = [255, 226, 77]\r\n self.color255[177] = [255, 243, 106]\r\n self.color255[178] = [255, 234, 92]\r\n self.color255[179] = [240, 210, 35]\r\n self.color255[180] = [224, 194, 0]\r\n self.color255[181] = [213, 99, 79]\r\n self.color255[182] = [217, 102, 81]\r\n self.color255[183] = [0, 147, 202]\r\n self.color255[184] = [0, 122, 171]\r\n self.color255[185] = [186, 77, 64]\r\n self.color255[186] = [240, 255, 30]\r\n self.color255[187] = [185, 232, 61]\r\n self.color255[188] = [0, 226, 255]\r\n self.color255[189] = [251, 159, 255]\r\n self.color255[190] = [230, 169, 29]\r\n self.color255[191] = [0, 194, 113]\r\n self.color255[192] = [104, 160, 249]\r\n self.color255[193] = [221, 108, 158]\r\n self.color255[194] = [137, 142, 0]\r\n self.color255[195] = [230, 70, 0]\r\n self.color255[196] = [0, 147, 0]\r\n self.color255[197] = [0, 147, 248]\r\n self.color255[198] = [231, 0, 206]\r\n self.color255[199] = [129, 78, 0]\r\n self.color255[200] = [0, 116, 0]\r\n self.color255[201] = [0, 0, 255]\r\n self.color255[202] = [157, 0, 0]\r\n self.color255[203] = [100, 100, 130]\r\n self.color255[204] = [205, 205, 100]\r\n self.color255[205] = [255, 255, 0]\r\n\r\n return self.color255","def intensity(self, value: int, /) -> None:","def setColors255(self):\n #productive\n profprint()\n self.color255= [[0,0,0] for i in range(205)]\n self.color255[0]=[221,108,158]\n self.color255[1]=[128,174,128]\n self.color255[2]=[241,214,145]\n self.color255[3]=[177,122,101]\n self.color255[4]=[111,184,210]\n self.color255[5]=[216,101,79]\n self.color255[6]=[221,130,101]\n self.color255[7]=[144,238,144]\n self.color255[8]=[192,104,88]\n self.color255[9]=[220,245,20]\n self.color255[10]=[78,63,0]\n self.color255[11]=[255,250,220]\n self.color255[12]=[230,220,70]\n self.color255[13]=[200,200,235]\n self.color255[14]=[250,250,210]\n self.color255[15]=[244,214,49]\n self.color255[16]=[0,151,206]\n self.color255[17]=[183,156,220]\n self.color255[18]=[183,214,211]\n self.color255[19]=[152,189,207]\n self.color255[20]=[178,212,242]\n self.color255[21]=[68,172,100]\n self.color255[22]=[111,197,131]\n self.color255[23]=[85,188,255]\n self.color255[24]=[0,145,30]\n self.color255[25]=[214,230,130]\n self.color255[26]=[218,255,255]\n self.color255[27]=[170,250,250]\n self.color255[28]=[140,224,228]\n self.color255[29]=[188,65,28]\n self.color255[30]=[216,191,216]\n self.color255[31]=[145,60,66]\n self.color255[32]=[150,98,83]\n self.color255[33]=[250,250,225]\n self.color255[34]=[200,200,215]\n self.color255[35]=[68,131,98]\n self.color255[36]=[83,146,164]\n self.color255[37]=[162,115,105]\n self.color255[38]=[141,93,137]\n self.color255[39]=[182,166,110]\n self.color255[40]=[188,135,166]\n self.color255[41]=[154,150,201]\n self.color255[42]=[177,140,190]\n self.color255[43]=[30,111,85]\n self.color255[44]=[210,157,166]\n self.color255[45]=[48,129,126]\n self.color255[46]=[98,153,112]\n self.color255[47]=[69,110,53]\n self.color255[48]=[166,113,137]\n self.color255[49]=[122,101,38]\n self.color255[50]=[253,135,192]\n self.color255[51]=[145,92,109]\n self.color255[52]=[46,101,131]\n self.color255[53]=[0,108,112]\n self.color255[54]=[127,150,88]\n self.color255[55]=[159,116,163]\n self.color255[56]=[125,102,154]\n self.color255[57]=[106,174,155]\n self.color255[58]=[154,146,83]\n self.color255[59]=[126,126,55]\n self.color255[60]=[201,160,133]\n self.color255[61]=[78,152,141]\n self.color255[62]=[174,140,103]\n self.color255[63]=[139,126,177]\n self.color255[64]=[148,120,72]\n self.color255[65]=[186,135,135]\n self.color255[66]=[99,106,24]\n self.color255[67]=[156,171,108]\n self.color255[68]=[64,123,147]\n self.color255[69]=[138,95,74]\n self.color255[70]=[97,113,158]\n self.color255[71]=[126,161,197]\n self.color255[72]=[194,195,164]\n self.color255[73]=[88,106,215]\n self.color255[74]=[82,174,128]\n self.color255[75]=[57,157,110]\n self.color255[76]=[60,143,83]\n self.color255[77]=[92,162,109]\n self.color255[78]=[255,244,209]\n self.color255[79]=[201,121,77]\n self.color255[80]=[70,163,117]\n self.color255[81]=[188,91,95]\n self.color255[82]=[166,84,94]\n self.color255[83]=[182,105,107]\n self.color255[84]=[229,147,118]\n self.color255[85]=[174,122,90]\n self.color255[86]=[201,112,73]\n self.color255[87]=[194,142,0]\n self.color255[88]=[241,213,144]\n self.color255[89]=[203,179,77]\n self.color255[90]=[229,204,109]\n self.color255[91]=[255,243,152]\n self.color255[92]=[209,185,85]\n self.color255[93]=[248,223,131]\n self.color255[94]=[255,230,138]\n self.color255[95]=[196,172,68]\n self.color255[96]=[255,255,167]\n self.color255[97]=[255,250,160]\n self.color255[98]=[255,237,145]\n self.color255[99]=[242,217,123]\n self.color255[100]=[222,198,101]\n self.color255[101]=[213,124,109]\n self.color255[102]=[184,105,108]\n self.color255[103]=[150,208,243]\n self.color255[104]=[62,162,114]\n self.color255[105]=[242,206,142]\n self.color255[106]=[250,210,139]\n self.color255[107]=[255,255,207]\n self.color255[108]=[182,228,255]\n self.color255[109]=[175,216,244]\n self.color255[110]=[197,165,145]\n self.color255[111]=[172,138,115]\n self.color255[112]=[202,164,140]\n self.color255[113]=[224,186,162]\n self.color255[114]=[255,245,217]\n self.color255[115]=[206,110,84]\n self.color255[116]=[210,115,89]\n self.color255[117]=[203,108,81]\n self.color255[118]=[233,138,112]\n self.color255[119]=[195,100,73]\n self.color255[120]=[181,85,57]\n self.color255[121]=[152,55,13]\n self.color255[122]=[159,63,27]\n self.color255[123]=[166,70,38]\n self.color255[124]=[218,123,97]\n self.color255[125]=[225,130,104]\n self.color255[126]=[224,97,76]\n self.color255[127]=[184,122,154]\n self.color255[128]=[211,171,143]\n self.color255[129]=[47,150,103]\n self.color255[130]=[173,121,88]\n self.color255[131]=[188,95,76]\n self.color255[132]=[255,239,172]\n self.color255[133]=[226,202,134]\n self.color255[134]=[253,232,158]\n self.color255[135]=[244,217,154]\n self.color255[136]=[205,179,108]\n self.color255[137]=[186,124,161]\n self.color255[138]=[255,255,220]\n self.color255[139]=[234,234,194]\n self.color255[140]=[204,142,178]\n self.color255[141]=[180,119,153]\n self.color255[142]=[216,132,105]\n self.color255[143]=[255,253,229]\n self.color255[144]=[205,167,142]\n self.color255[145]=[204,168,143]\n self.color255[146]=[255,224,199]\n self.color255[147]=[139,150,98]\n self.color255[148]=[249,180,111]\n self.color255[149]=[157,108,162]\n self.color255[150]=[203,136,116]\n self.color255[151]=[185,102,83]\n self.color255[152]=[247,182,164]\n self.color255[153]=[222,154,132]\n self.color255[154]=[124,186,223]\n self.color255[155]=[249,186,150]\n self.color255[156]=[244,170,147]\n self.color255[157]=[255,181,158]\n self.color255[158]=[255,190,165]\n self.color255[159]=[227,153,130]\n self.color255[160]=[213,141,113]\n self.color255[161]=[193,123,103]\n self.color255[162]=[216,146,127]\n self.color255[163]=[230,158,140]\n self.color255[164]=[245,172,147]\n self.color255[165]=[241,172,151]\n self.color255[166]=[177,124,92]\n self.color255[167]=[171,85,68]\n self.color255[168]=[217,198,131]\n self.color255[169]=[212,188,102]\n self.color255[170]=[185,135,134]\n self.color255[171]=[198,175,125]\n self.color255[172]=[194,98,79]\n self.color255[173]=[255,238,170]\n self.color255[174]=[206,111,93]\n self.color255[175]=[216,186,0]\n self.color255[176]=[255,226,77]\n self.color255[177]=[255,243,106]\n self.color255[178]=[255,234,92]\n self.color255[179]=[240,210,35]\n self.color255[180]=[224,194,0]\n self.color255[181]=[213,99,79]\n self.color255[182]=[217,102,81]\n self.color255[183]=[0,147,202]\n self.color255[184]=[0,122,171]\n self.color255[185]=[186,77,64]\n self.color255[186]=[240,255,30]\n self.color255[187]=[185,232,61]\n self.color255[188]=[0,226,255]\n self.color255[189]=[251,159,255]\n self.color255[190]=[230,169,29]\n self.color255[191]=[0,194,113]\n self.color255[192]=[104,160,249]\n self.color255[193]=[221,108,158]\n self.color255[194]=[137,142,0]\n self.color255[195]=[230,70,0]\n self.color255[196]=[0,147,0]\n self.color255[197]=[0,147,248]\n self.color255[198]=[231,0,206]\n self.color255[199]=[129,78,0]\n self.color255[200]=[0,116,0]\n self.color255[201]=[0,0,255]\n self.color255[202]=[157,0,0]\n self.color255[203]=[100,100,130]\n self.color255[204]=[205,205,100]\n \n return self.color255","def lamps(self, **lamp_parameters):\n self._set_state(lamp_parameters.items())","def sRGBLuminance(x):\n lin=linearFromsRGB3(x)\n return lin[0]*0.2126+lin[1]*0.7152+lin[2]*0.0722","def bright(self,l):\n if 1 <= l <= 4:\n self.send(\"\\x1f\\x58%c\" % l)\n else:\n raise ValueError('brightness values have to be between 1 and 4')","def brighten(rgb, factor):\n return [min(255, int(round(factor * c))) for c in rgb]","def _value_as_luminance(self):\n return round(float(self._value), 1)","def calibrate_image(image, tl = 0.5):\n for y in range(len(image)):\n for x in range(len(image[y])):\n # Convert the exiting pixel color to HLS model.\n h, l, s = rgb_to_hls(image[y, x])\n\n # We convert the HLS model back to RGB, but using our target \n # brightness value `tl`.\n r, g, b = colorsys.hls_to_rgb(h, tl, s)\n \n # Set the new pixel color.\n image[y][x] = [r * 255, g * 255, b * 255]\n\n return image","def convert_lf(self, lf):\n lf = np.float32(lf)\n if np.max(lf) > 1:\n lf = lf/256\n lf = np.uint8(lf*256)\n \n if lf.shape[-1] > 3:\n lf[lf[:,:,:,:,3] == 0] = (255,255,255,0) #convert alpha to white. \n lf = lf[:,:,:,:,:3]\n # while lf.ndim < 6:\n # lf = np.expand_dims(lf, 0)\n \n lf = resize_lightfield(lf, (self.width, self.height)) \n return lf","def setColourMap(self):\n cmap = self.config['cmap']\n\n pos, colour, mode = colourMaps.colourMaps(cmap)\n\n cmap = pg.ColorMap(pos, colour,mode)\n self.lut = cmap.getLookupTable(0.0, 1.0, 256)\n minsg = np.min(self.sg)\n maxsg = np.max(self.sg)\n self.colourStart = (self.config['brightness'] / 100.0 * self.config['contrast'] / 100.0) * (maxsg - minsg) + minsg\n self.colourEnd = (maxsg - minsg) * (1.0 - self.config['contrast'] / 100.0) + self.colourStart","def refresh_color(self):\n self.color = max(0, int(math.sqrt(self.vx ** 2\n + self.vy ** 2)) + 100)","def setLeds(number: int, red: int, green: int, blue: int):\n pass","def high_bri(self):\r\n for light in self.lights:\r\n bri = self.b.get_light(light,'bri')\r\n bri = bri + 50 \r\n if bri > 255:\r\n bri = 255 \r\n self.b.set_light(light,'bri',bri)","def setColourMap(self):\n cmap = self.config['cmap']\n\n pos, colour, mode = colourMaps.colourMaps(cmap)\n\n cmap = pg.ColorMap(pos, colour, mode)\n self.lut = cmap.getLookupTable(0.0, 1.0, 256)\n minsg = np.min(self.sg)\n maxsg = np.max(self.sg)\n self.colourStart = (self.config['brightness'] / 100.0 * self.config['contrast'] / 100.0) * (\n maxsg - minsg) + minsg\n self.colourEnd = (maxsg - minsg) * (1.0 - self.config['contrast'] / 100.0) + self.colourStart","def light(brightness, filter):\n brightness = clamp(MIN_BRIGHTNESS, round(brightness), MAX_BRIGHTNESS)\n for col in range(DISPLAY_WIDTH):\n for row in range(DISPLAY_HEIGHT):\n if filter(col, row):\n microbit.display.set_pixel(col, row, brightness)","def set_intensity(self,intensity):\n intensity=int(intensity)\n assert intensity>=0 and intensity<=100\n self.usbdev.ctrl_transfer(bmRequestType=0x21, bRequest=0x09, wValue=0x03a6, wIndex=0, data_or_wLength=[0xa6,0x00,intensity])\n self.intensity=intensity","def set_lam_nll(self, lam_nll=1.0):\n zero_ary = np.zeros((1,))\n new_lam = zero_ary + lam_nll\n self.lam_nll.set_value(to_fX(new_lam))\n return","def setColors(self):\n #productive\n profprint()\n self.color= [[0,0,0] for i in range(205)]\n self.color255= self.setColors255()\n for i in range(205):\n for j in range(3):\n self.color[i][j] = self.color255[i][j]/float(255)\n\n return self.color","def compute_luminosity(red, green, blue):\r\n return (0.299 * red) + (0.587 * green) + (0.114 * blue)","def setColorBarRange(start=1,end=254):\n dislin.colran(start,end)","def setAutoColorResolution(nx, ny):\n dislin.autres(nx,ny)","def scale_to_01(color: C3I) -> C3F:\n r, g, b = color\n return r / 255, g / 255, b / 255","def flicker_lights(self):\n print 'Lights Set'","def set_intensity(intensity):\n ret = _LIB.led_matrix_click_set_intensity(intensity)\n if ret < 0:\n raise Exception(\"led matrix click set intensity failed\")","def make_lulc_raster(raster_path, lulc_val):\r\n lulc_array = numpy.zeros((100, 100), dtype=numpy.int8)\r\n lulc_array[50:, :] = lulc_val\r\n make_raster_from_array(lulc_array, raster_path)","def adjust_illuminant(self, il):\n # store mean luminance\n mean_lum = self.mean_luminance\n\n # adjust il wavelength\n il.wave = self.wave\n\n # update photons\n self.photons *= il.photons / self.illuminant.photons\n\n # update illuminant spd\n self.illuminant = il\n\n # make sure mean luminance is not changed\n self.mean_luminance = mean_lum","def grayscale(self):\n\n luminance = self.get_luminance() & 0xFF\n self.r = luminance\n self.g = luminance\n self.b = luminance","def normalize_01(x):\n return x / 255.0","def set_brightness(self, level):\n print(\"Got request to set brightness with level: %s\" % (level))\n # Home assistant sets brightness on a scale of 0 to 255\n if level > 0 and level < 255:\n new_level = level / 255\n print(\"Setting brightness to %s\" % (new_level))\n self.turn_on(r=self.r, g=self.g, b=self.b, brightness=new_level)\n self.client.publish(BRIGHTNESS_STATE_TOPIC, level) #publish","def normalize_image(self, factor, luminosity=None):\n if not luminosity:\n luminosity = self.average_luminosity()\n\n for i in range(len(self.pixels)):\n self.pixels[i] = self.pixels[i] * (factor / luminosity)","def brightness(self, factor):\n\n channels = [\"r\", \"g\", \"b\"]\n total_lumes = clamp(self.get_luminance() + (255.0 * factor) - 255.0, 0.0, 255.0)\n\n if total_lumes == 255.0:\n # white\n self.r, self.g, self.b = 0xFF, 0xFF, 0xFF\n elif total_lumes == 0.0:\n # black\n self.r, self.g, self.b = 0x00, 0x00, 0x00\n else:\n # Adjust Brightness\n pts = (total_lumes - 0.299 * self.r - 0.587 * self.g - 0.114 * self.b)\n slots = set(channels)\n components = [float(self.r) + pts, float(self.g) + pts, float(self.b) + pts]\n count = 0\n for c in channels:\n overage, components[count] = self._get_overage(components[count])\n if overage:\n slots.remove(c)\n components = list(self._distribute_overage(components, overage, slots))\n count += 1\n\n self.r = clamp(round_int(components[0]), 0, 255) & 0xFF\n self.g = clamp(round_int(components[1]), 0, 255) & 0xFF\n self.b = clamp(round_int(components[2]), 0, 255) & 0xFF","def adjust_saturation(image, factor):\r\n image[..., 1] = np.clip(image[..., 1] * factor, 0, 255)\r\n return image","def setPixelColor(self, n, color):\n\t\t#print \"pxl %s = %s\" % (n, color)\n\t\tif isinstance(n, slice):\n\t\t\tself.leds[n] = [color]*len(self.leds[n])\n\t\telse:\n\t\t\tif n >= 0 or n <= self.size:\n\t\t\t\tself.leds[n] = color\n\t\t#pprint(self.leds)","def changeColor( self ):\n\t\t\n\t\tx, y = self.position.xy\n\t\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))","def darker(image):\r\n # Demonstrate looping over all the pixels of an image,\r\n # changing each pixel to be half its original intensity.\r\n for pixel in image:\r\n pixel.red = pixel.red // 2\r\n pixel.green = pixel.green // 2\r\n pixel.blue = pixel.blue // 2","def setAlpha ( self, newalpha ):\n if isinstance( newalpha, int ):\n raise ValueError('Expects a float value in the [ 0.0 - 1.0 ] range!')\n if newalpha > 1.0:\n newalpha = 1.0\n if newalpha < 0.0:\n newalpha = 0.0\n self.a = newalpha\n self.hsla[3] = newalpha\n self.rgba[3] = newalpha","def _monochrome(self):\r\n\r\n self.img = self.img.convert('L')\r\n self.img = Image.eval(self.img, lambda a: 0 if a <= MONOWEIGHT else 255)","def setHsla ( self, h, s = 0.0, l = 0.0, a = 1.0 ):\n #self.reset()\n\n # Check if argument is list\n if isinstance(h, list):\n s = h[1]\n l = h[2]\n if len(h) == 4: # Alpha in the list\n a = h[3]\n h = h[0]\n\n # If any component is int ( 0 - 255 ) convert to float ( 0 - 1)\n hsla = [ h, s, l, a ]\n for i in range(len(hsla)):\n if isinstance( hsla[i], int ):\n hsla[i] = hsla[i] / 360.0 if i == 0 else hsla[i] / 100.0\n\n self.h = hsla[0]\n self.s = hsla[1]\n self.l = hsla[2]\n self.a = hsla[3]\n self.hsl = [ hsla[0], hsla[1], hsla[2] ]\n self.hsla = [ hsla[0], hsla[1], hsla[2], hsla[3] ]\n\n self.updateFromHsl()","def solarize(img, threshold):\n \n for x, y, col in img:\n\n # Invert the values of all RGB components less than 128,\n # leaving components with higher values unchanged.\n\n red, green, blue = col\n\n if red < threshold:\n red = 255 - red\n\n if green < threshold:\n green = 255 - green\n\n if blue < threshold:\n blue = 255 - blue\n\n col = create_color(red, green, blue)\n set_color(img, x, y, col)","def bndy_plasma(self):\n self.ne[0], self.ne[-1] = 1e11, 1e11\n self.ni[0], self.ni[-1] = 1e11, 1e11\n self.nn[0], self.nn[-1] = 1e11, 1e11\n self.Te[0], self.Te[-1] = 0.1, 0.1\n self.Ti[0], self.Ti[-1] = 0.01, 0.01\n # self.coll_em[0], self.coll_em[-1] = 1e5, 1e5\n # self.coll_im[0], self.coll_im[-1] = 1e5, 1e5","def set_contrast(level):\n send_command(0x81)\n send_command(level)","def lut(threshold):\n\n return [255 if i<=threshold else 0 for i in range(256)]","def turn_on(self, **kwargs: Any) -> None:\n self._light.brightness = kwargs.get(ATTR_BRIGHTNESS, 255)\n self._light.turn_on()","def setLCLimits(*args):\n args[0].Limit.LCLimit.lc_limit = args[1]","def scaleLandsat(self,img):\n\t\tthermal = img.select(ee.List(['thermal'])).multiply(0.1)\n\t\tscaled = ee.Image(img).select(self.env.divideBands).multiply(ee.Number(0.0001))\n\t\t\n\t\treturn img.select([]).addBands(scaled).addBands(thermal)","def set_laser_power(self, power: int):\n self.logger.info(f'Setting laser power to {power}')\n power = int(power)\n if power <= 1:\n self.electronics.servo = 0\n else:\n self.electronics.servo = 1\n\n self.electronics.laser_power = power\n self.config['laser']['power'] = power","def lapsharp(image, maskret = False):\n #padded_image = np.pad(img, (1, 1), mode = 'symmetric')\n # lap is linear therefore;\n # lap f(x,y) = f(x + 1, y) + f(x - 1, y) + f(x, y + 1) + f(x, y - 1) - 4f(x,y)...\n #--------------------\n c = -1 # Depends on kernel\n # make zero kernal\n lapmask = np.zeros((3, 3))\n \n # add values to kernel\n lapmask[0,0] = 1\n lapmask[0,1] = 1\n lapmask[0,2] = 1\n\n lapmask[1,0] = 1\n lapmask[1,1] = -8\n lapmask[1,2] = 1\n\n lapmask[2,0] = 1\n lapmask[2,1] = 1\n lapmask[2,2] = 1\n #--------------------\n mask = convolve2d(image, lapmask, mode = 'same')\n result = image + c*mask\n\n # Map values to 0-255\n g1 = image - np.min(image)\n g = g1/np.max(g1) *255\n g = g.astype('uint8')\n\n if maskret == True:\n return g, mask\n else:\n return g.astype('uint8')","def enhance_contrast(img):\n for y in range(frame_height):\n for x in range(frame_width):\n if img[y, x, 1] > 100:\n # range of blues to limit of puppet motion 255/(frame_width - 150)\n img[y][x][0] = x*0.4\n if img[y, x, 1] <= 100:\n img[y][x][2] = img[y][x][2]*0.5\n cv2.imwrite(\"contrasted.png\", img)","def adjust_brightness(image, delta):\r\n return _clip(image + delta * 255)","def set_color_brightness(color, brightness):\n if brightness == 0:\n put_light_state(False, 0, 0, 16000)\n else:\n put_light_state(\n True,\n 254 * color // 100,\n 254 * brightness // 100,\n 16000\n )","def set_alpha(self, alpha=1.0):\r\n self.unif[17] = alpha","def __init__(self,\r\n lightpos=(10, -10, 20),\r\n lightcol=(1.0, 1.0, 1.0),\r\n lightamb=(0.1, 0.1, 0.2)):\r\n super(Light, self).__init__()\r\n self.lightpos = lightpos\r\n self.lightcol = lightcol\r\n self.lightamb = lightamb","def intensity(self) -> int:","def set_fade_threshold(self, address):\n self.model.fade_address = address","def pixelLuminance (r, g, b):\n assert (type(r) == int and type(g) == int and type(b) == int)\n assert (0<=r<=255 and 0<=g<=255 and 0<=b<=255)\n return roundHalfUp((.2126*r)+(.7152*g)+(.0722*b))","def set_colormap_full_range(self):\n if(self.plot.image is None):\n return\n \n cmin = self.settingsWidget.ui.colormap_min\n cmax = self.settingsWidget.ui.colormap_max\n data_min = numpy.min(self.plot.image)\n data_max = numpy.max(self.plot.image)\n cmin.setText(str(data_min))\n cmax.setText(str(data_max))\n self.set_colormap_range()","def off(l):\n l.do_static_colour(255, 0, 0, 0)","def set_color(group, color, pct=1):\n for l, v in zip(group, color):\n l.brightness_pct = v * pct","def get_luminosity(self):\n\n if self.no_dist is False and self.no_flux is False:\n\n dist = self.distance\n snu = self.snu_at_1GHz\n lum = lumin(dist, snu)\n\n self.lum = lum\n else:\n self.lum = -1 # use -1 to indicate unknown luminosity\n return self.lum","def rescale_intensity(image, thres=(1.0, 99.0)):\n val_l, val_h = np.percentile(image, thres)\n image2 = image\n image2[image < val_l] = val_l\n image2[image > val_h] = val_h\n image2 = (image2.astype(np.float32) - val_l) / (val_h - val_l)\n return image2","def filterToLight( bmp, savefile = '' ):\n for h in range(bmp.height):\n for w in range(bmp.width):\n HSL = RGBtoHSL( bmp.pixels[h][w] )\n lit = int(255*HSL[2]) # convert to 0-255 range\n bmp.pixels[h][w] = (lit,lit,lit)\n if( savefile != '' ):\n bmp.save(savefile)\n return bmp","def luminance(rgb):\n \n (r, g, b) = rgb\n return (r + g + b) // 3","def set_light(self, light, num=0):\r\n #TODO (pg) need MAXLIGHTS global variable, room for two now but shader\r\n # only uses 1.\r\n if num > 1 or num < 0:\r\n num = 0\r\n stn = 24 + num * 9\r\n self.unif[stn:(stn + 3)] = light.lightpos[0:3]\r\n self.unif[(stn + 3):(stn + 6)] = light.lightcol[0:3]\r\n self.unif[(stn + 6):(stn + 9)] = light.lightamb[0:3]","def larkin_autocor_model(x,y,amplitude=1.,x_mean_0=0.,y_mean_0=0.,width=1.,background=0.):\n intensity = 1./(2*np.pi) * (width/((x-x_mean_0)**2 + (y-y_mean_0)**2 + width**2)**1.5) # 2D Lorentzian works well\n intensity *= amplitude / np.max(intensity)\n intensity += background\n return intensity","def intensityPSF_Blues(N=1000):\n col_seq = [( 0/255., 20/255., 80/255.), ( 8/255., 48/255., 107/255.),\n ( 8/255., 81/255., 156/255.), ( 33/255., 113/255., 181/255.),\n ( 66/255., 146/255., 198/255.), (107/255., 174/255., 214/255.),\n (158/255., 202/255., 225/255.), (198/255., 219/255., 239/255.),\n (222/255., 235/255., 247/255.), (247/255., 251/255., 255/255.)]\n\n cdict = {'red': ((0.00, col_seq[0][0], col_seq[0][0]),\n (0.02, col_seq[1][0], col_seq[1][0]),\n (0.06, col_seq[2][0], col_seq[2][0]),\n (0.10, col_seq[3][0], col_seq[3][0]),\n (0.20, col_seq[4][0], col_seq[4][0]),\n (0.30, col_seq[5][0], col_seq[5][0]),\n (0.50, col_seq[6][0], col_seq[6][0]),\n (0.75, col_seq[7][0], col_seq[7][0]),\n (0.90, col_seq[8][0], col_seq[8][0]),\n (1.00, col_seq[9][0], col_seq[9][0])),\n 'green': ((0.00, col_seq[0][1], col_seq[0][1]),\n (0.02, col_seq[1][1], col_seq[1][1]),\n (0.06, col_seq[2][1], col_seq[2][1]),\n (0.10, col_seq[3][1], col_seq[3][1]),\n (0.20, col_seq[4][1], col_seq[4][1]),\n (0.30, col_seq[5][1], col_seq[5][1]),\n (0.50, col_seq[6][1], col_seq[6][1]),\n (0.75, col_seq[7][1], col_seq[7][1]),\n (0.90, col_seq[8][1], col_seq[8][1]),\n (1.00, col_seq[9][1], col_seq[9][1])),\n 'blue': ((0.00, col_seq[0][2], col_seq[0][2]),\n (0.02, col_seq[1][2], col_seq[1][2]),\n (0.06, col_seq[2][2], col_seq[2][2]),\n (0.10, col_seq[3][2], col_seq[3][2]),\n (0.20, col_seq[4][2], col_seq[4][2]),\n (0.30, col_seq[5][2], col_seq[5][2]),\n (0.50, col_seq[6][2], col_seq[6][2]),\n (0.75, col_seq[7][2], col_seq[7][2]),\n (0.90, col_seq[8][2], col_seq[8][2]),\n (1.00, col_seq[9][2], col_seq[9][2]))}\n\n psfblues = _mplb.colors.LinearSegmentedColormap('psfblues', cdict, N)\n return psfblues","def intensity_spread(img, L):\n\n pixels = img.flatten()\n min_pix = np.amin(pixels)\n max_pix = np.amax(pixels)\n res = np.zeros(pixels.shape)\n\n for idx, p in enumerate(pixels):\n res[idx] = (L - 1) * ((p - min_pix) / (max_pix - min_pix))\n\n return np.reshape(res, img.shape)","def increase_brightness(image, value=18):\n hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n h, s, v = cv2.split(hsv)\n\n lim = 255 - value\n v[v > lim] = 255\n v[v <= lim] += value\n\n final_hsv = cv2.merge((h, s, v))\n image = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)\n return image","def setColorResolution(width=1,height=1):\n dislin.setres(width,height)","def set_contrast(value):\n command([0x21, 0x14, value, 0x20, 0x0c])","def change_brightness(img,k=0):\n\n img_copy = np.copy(img)\n img_copy = img_copy.astype(int)\n img_copy += k\n\n return img_copy","def changeColor(self):\n self.layer.new_colormap()","def mel_to_linear(\n self, mel_amp: np.ndarray, threshold: float = 1e-10\n ) -> np.ndarray:\n return np.maximum(threshold, np.dot(self._inv_mel_basis, mel_amp))","def set_UVLO_threshold(self, i: int = 0):\n dic = {0: \"101\", 1: \"110\", 2: \"111\", 3: \"000\"}\n self.set_byte(\"d6\", \"00000\" + dic[i])\n self.get_UVLO_threshold()","def set_red(x, y, value, slot = 0):\r\n __g[slot].pixels_rgb[__g[slot].width * 3 * y + x * 3] = value","def light_number(self, number, position):\n for [x, y] in number:\n uh.set_pixel(x+position[0], y+position[1], 183, 0, 255)\n uh.show()","def rgb_to_lab(img, l=False, ab=False):\n img = img / 255\n l_chan = color.rgb2lab(img)[:, :, 0]\n l_chan = l_chan / 50 - 1\n l_chan = l_chan[..., np.newaxis]\n\n ab_chan = color.rgb2lab(img)[:, :, 1:]\n ab_chan = (ab_chan + 128) / 255 * 2 - 1\n if l:\n return l_chan\n else:\n return ab_chan","def all_off():\n Leds.red_left.brightness = 0\n Leds.red_right.brightness = 0\n Leds.green_left.brightness = 0\n Leds.green_right.brightness = 0\n Leds.blue_left.brightness = 0\n Leds.blue_right.brightness = 0","def luminosity(r,T,autoDebug=True):\n\t#-----------BEGIN ERROR CHECKING----------\n\tif autoDebug:\n\t\tsam.type_check(r, sam.TYPES_math, \"r\")\n\t\tsam.type_check(T, sam.TYPES_math, \"T\")\n\t\tsam.value_check(r,.0,\">\",\"r\")\n\t\tsam.value_check(T,.0,\">\",\"T\")\n\t#-----------END ERROR CHECKING----------\n\n\tL = 4 * sam.CONSTANT_pi * r**2 * sam.CONSTANT_SB* T**4\n\treturn L","def change_value(image):\n\n out = None\n\n #####################################\n # START YOUR CODE HERE #\n #####################################\n image = image / 255\n out = np.empty_like(image)\n height, width, _ = image.shape\n for h in range(height):\n for w in range(width):\n x_p = image[h,w]\n x_n = (x_p * x_p) * 0.5\n out[h,w] = x_n\n ######################################\n # END OF YOUR CODE #\n ######################################\n\n return out","def lower_bri(self):\r\n for light in self.lights:\r\n bri = self.b.get_light(light,'bri')\r\n bri = bri - 50\r\n if bri < 0:\r\n bri = 1\r\n self.b.set_light(light,'bri',bri)","def set_pixel(self, x, y, value):\n if x < 0 or x > 7 or y < 0 or y > 15:\n # Ignore out of bounds pixels.\n return\n if y < 8:\n self.set_led( y * 16 + x, value)\n else:\n self.set_led((y-8) * 16 + (x+8), value)","def augment_brightness(image):\n rand_brightness = .25 + np.random.uniform()\n image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)\n image[:, :, 2] = image[:, :, 2] * rand_brightness\n image = cv2.cvtColor(image, cv2.COLOR_HSV2RGB)\n return image","def setColors(self):\r\n # productive\r\n profprint()\r\n self.color = [[0, 0, 0] for i in range(MAXCOL)]\r\n self.color255 = self.setColors255()\r\n for i in range(MAXCOL):\r\n for j in range(3):\r\n self.color[i][j] = self.color255[i][j] / float(255)\r\n\r\n return self.color","def turn_on(self, **kwargs: Any) -> None:\n if self._dimmable:\n level = kwargs.get(ATTR_BRIGHTNESS, self._last_brightness)\n else:\n level = 255\n self._light.turn_on(to_futurenow_level(level))"],"string":"[\n \"def setLum ( self, newlum ):\\n if isinstance( newlum, int ):\\n newlum /= 100\\n if newlum > 1.0:\\n newlum = 1.0\\n if newlum < 0.0:\\n newlum = 0.0\\n self.l = newlum\\n self.hsl[2] = newlum\\n self.hsla[2] = newlum\\n self.updateFromHsl()\",\n \"def __add_color(self, intensity):\\n val = color.rgb2lab(\\n (self.image[self.lip_y, self.lip_x] / 255.)\\n .reshape(len(self.lip_y), 1, 3)\\n ).reshape(len(self.lip_y), 3)\\n l_val, a_val, b_val = np.mean(val[:, 0]), np.mean(val[:, 1]), np.mean(val[:, 2])\\n l1_val, a1_val, b1_val = color.rgb2lab(\\n np.array(\\n (self.red_l / 255., self.green_l / 255., self.blue_l / 255.)\\n ).reshape(1, 1, 3)\\n ).reshape(3,)\\n l_final, a_final, b_final = (l1_val - l_val) * \\\\\\n intensity, (a1_val - a_val) * \\\\\\n intensity, (b1_val - b_val) * intensity\\n val[:, 0] = np.clip(val[:, 0] + l_final, 0, 100)\\n val[:, 1] = np.clip(val[:, 1] + a_final, -127, 128)\\n val[:, 2] = np.clip(val[:, 2] + b_final, -127, 128)\\n self.image[self.lip_y, self.lip_x] = color.lab2rgb(val.reshape(\\n len(self.lip_y), 1, 3)).reshape(len(self.lip_y), 3) * 255\",\n \"def set_brightness(distance):\\n if math.floor(distance / 100) - 1 >= 0 and math.floor(distance / 100) - 1 <= 9:\\n return 9 - (math.floor(distance / 100) - 1)\\n elif math.floor(distance / 100) - 1 >= 0:\\n return 1\\n else:\\n return 9\",\n \"def setColourLevels(self):\\n minsg = np.min(self.sg)\\n maxsg = np.max(self.sg)\\n brightness = self.brightnessSlider.value()\\n contrast = self.contrastSlider.value()\\n colourStart = (brightness / 100.0 * contrast / 100.0) * (maxsg - minsg) + minsg\\n colourEnd = (maxsg - minsg) * (1.0 - contrast / 100.0) + colourStart\\n for btn in self.picbuttons:\\n btn.stopPlayback()\\n btn.setImage(self.lut, colourStart, colourEnd, False)\\n btn.update()\",\n \"def lamp_set_color(color):\\n addresses = lamp_addresses\\n\\n r = hex(color[0])[2:].zfill(2)\\n g = hex(color[1])[2:].zfill(2)\\n b = hex(color[2])[2:].zfill(2)\\n\\n # the 01 here at the beginning of the message means that\\n # the lamp will hold the color even when the connection is lost\\n value = \\\"01\\\" + r + g + b\\n\\n for address in addresses:\\n command = \\\"gatttool -b {} -t random --char-write --handle=0x0011 --value={}\\\".format(address, value)\\n logging.debug(\\\"Sending command to RFduino: \\\" + command)\\n os.system(command)\",\n \"def _clamp_rgb_coordinate(self, coord):\\r\\n\\r\\n if not self.is_upscaled:\\r\\n return min(max(coord, 0.0), 1.0)\\r\\n else:\\r\\n return min(max(coord, 1), 255)\",\n \"def luminance(self, color):\\n return 0.2426 * color[2] + 0.7152 * color[1] + 0.0722 * color[0]\",\n \"def luminance(self):\\n \\n return (self.r + self.g + self.b) // 3\",\n \"def setSurfaceColorScale(low,high):\\n dislin.zscale(low,high)\",\n \"def setMyColorTable(lr,lg,lb):\\n dislin.myvlt(lr,lg,lb,len(lr))\",\n \"def change_brightness(image, value):\\n\\n return change_light(image, value, \\\"v\\\")\",\n \"def scaleClipl(x):\\n x = 0 if x < 0 else x\\n x = 1 if x > 1 else x\\n return int(round(x*255.))\",\n \"def update(self):\\n self._brightness = self._lj.get_load_level(self._index) / 99 * 255\",\n \"def _ampl_color(self, amplitude, frame):\\n color=(0,0,0)\\n for col in self._color:\\n if frame >= col[0]:\\n color = col[1]\\n return color + (int(self._amplfactor * amplitude),)\",\n \"def log_scale_ds9(im, lexp=1.e12, cmap=[7.97917, 0.8780493], scale=[-0.1,10]):\\n import numpy as np\\n \\n contrast, bias = cmap\\n clip = (np.clip(im, scale[0], scale[1])-scale[0])/(scale[1]-scale[0])\\n clip_log = np.clip((np.log10(lexp*clip+1)/np.log10(lexp)-bias)*contrast+0.5, 0, 1)\\n \\n return clip_log\",\n \"def setColors255(self):\\r\\n # productive\\r\\n profprint()\\r\\n self.color255 = [[0, 0, 0] for i in range(MAXCOL)]\\r\\n self.color255[0] = [221, 108, 158]\\r\\n self.color255[1] = [128, 174, 128]\\r\\n self.color255[2] = [241, 214, 145]\\r\\n self.color255[3] = [177, 122, 101]\\r\\n self.color255[4] = [111, 184, 210]\\r\\n self.color255[5] = [216, 101, 79]\\r\\n self.color255[6] = [221, 130, 101]\\r\\n self.color255[7] = [144, 238, 144]\\r\\n self.color255[8] = [192, 104, 88]\\r\\n self.color255[9] = [220, 245, 20]\\r\\n self.color255[10] = [78, 63, 0]\\r\\n self.color255[11] = [255, 250, 220]\\r\\n self.color255[12] = [230, 220, 70]\\r\\n self.color255[13] = [200, 200, 235]\\r\\n self.color255[14] = [250, 250, 210]\\r\\n self.color255[15] = [244, 214, 49]\\r\\n self.color255[16] = [0, 151, 206]\\r\\n self.color255[17] = [183, 156, 220]\\r\\n self.color255[18] = [183, 214, 211]\\r\\n self.color255[19] = [152, 189, 207]\\r\\n self.color255[20] = [178, 212, 242]\\r\\n self.color255[21] = [68, 172, 100]\\r\\n self.color255[22] = [111, 197, 131]\\r\\n self.color255[23] = [85, 188, 255]\\r\\n self.color255[24] = [0, 145, 30]\\r\\n self.color255[25] = [214, 230, 130]\\r\\n self.color255[26] = [218, 255, 255]\\r\\n self.color255[27] = [170, 250, 250]\\r\\n self.color255[28] = [140, 224, 228]\\r\\n self.color255[29] = [188, 65, 28]\\r\\n self.color255[30] = [216, 191, 216]\\r\\n self.color255[31] = [145, 60, 66]\\r\\n self.color255[32] = [150, 98, 83]\\r\\n self.color255[33] = [250, 250, 225]\\r\\n self.color255[34] = [200, 200, 215]\\r\\n self.color255[35] = [68, 131, 98]\\r\\n self.color255[36] = [83, 146, 164]\\r\\n self.color255[37] = [162, 115, 105]\\r\\n self.color255[38] = [141, 93, 137]\\r\\n self.color255[39] = [182, 166, 110]\\r\\n self.color255[40] = [188, 135, 166]\\r\\n self.color255[41] = [154, 150, 201]\\r\\n self.color255[42] = [177, 140, 190]\\r\\n self.color255[43] = [30, 111, 85]\\r\\n self.color255[44] = [210, 157, 166]\\r\\n self.color255[45] = [48, 129, 126]\\r\\n self.color255[46] = [98, 153, 112]\\r\\n self.color255[47] = [69, 110, 53]\\r\\n self.color255[48] = [166, 113, 137]\\r\\n self.color255[49] = [122, 101, 38]\\r\\n self.color255[50] = [253, 135, 192]\\r\\n self.color255[51] = [145, 92, 109]\\r\\n self.color255[52] = [46, 101, 131]\\r\\n self.color255[53] = [0, 108, 112]\\r\\n self.color255[54] = [127, 150, 88]\\r\\n self.color255[55] = [159, 116, 163]\\r\\n self.color255[56] = [125, 102, 154]\\r\\n self.color255[57] = [106, 174, 155]\\r\\n self.color255[58] = [154, 146, 83]\\r\\n self.color255[59] = [126, 126, 55]\\r\\n self.color255[60] = [201, 160, 133]\\r\\n self.color255[61] = [78, 152, 141]\\r\\n self.color255[62] = [174, 140, 103]\\r\\n self.color255[63] = [139, 126, 177]\\r\\n self.color255[64] = [148, 120, 72]\\r\\n self.color255[65] = [186, 135, 135]\\r\\n self.color255[66] = [99, 106, 24]\\r\\n self.color255[67] = [156, 171, 108]\\r\\n self.color255[68] = [64, 123, 147]\\r\\n self.color255[69] = [138, 95, 74]\\r\\n self.color255[70] = [97, 113, 158]\\r\\n self.color255[71] = [126, 161, 197]\\r\\n self.color255[72] = [194, 195, 164]\\r\\n self.color255[73] = [88, 106, 215]\\r\\n self.color255[74] = [82, 174, 128]\\r\\n self.color255[75] = [57, 157, 110]\\r\\n self.color255[76] = [60, 143, 83]\\r\\n self.color255[77] = [92, 162, 109]\\r\\n self.color255[78] = [255, 244, 209]\\r\\n self.color255[79] = [201, 121, 77]\\r\\n self.color255[80] = [70, 163, 117]\\r\\n self.color255[81] = [188, 91, 95]\\r\\n self.color255[82] = [166, 84, 94]\\r\\n self.color255[83] = [182, 105, 107]\\r\\n self.color255[84] = [229, 147, 118]\\r\\n self.color255[85] = [174, 122, 90]\\r\\n self.color255[86] = [201, 112, 73]\\r\\n self.color255[87] = [194, 142, 0]\\r\\n self.color255[88] = [241, 213, 144]\\r\\n self.color255[89] = [203, 179, 77]\\r\\n self.color255[90] = [229, 204, 109]\\r\\n self.color255[91] = [255, 243, 152]\\r\\n self.color255[92] = [209, 185, 85]\\r\\n self.color255[93] = [248, 223, 131]\\r\\n self.color255[94] = [255, 230, 138]\\r\\n self.color255[95] = [196, 172, 68]\\r\\n self.color255[96] = [255, 255, 167]\\r\\n self.color255[97] = [255, 250, 160]\\r\\n self.color255[98] = [255, 237, 145]\\r\\n self.color255[99] = [242, 217, 123]\\r\\n self.color255[100] = [222, 198, 101]\\r\\n self.color255[101] = [213, 124, 109]\\r\\n self.color255[102] = [184, 105, 108]\\r\\n self.color255[103] = [150, 208, 243]\\r\\n self.color255[104] = [62, 162, 114]\\r\\n self.color255[105] = [242, 206, 142]\\r\\n self.color255[106] = [250, 210, 139]\\r\\n self.color255[107] = [255, 255, 207]\\r\\n self.color255[108] = [182, 228, 255]\\r\\n self.color255[109] = [175, 216, 244]\\r\\n self.color255[110] = [197, 165, 145]\\r\\n self.color255[111] = [172, 138, 115]\\r\\n self.color255[112] = [202, 164, 140]\\r\\n self.color255[113] = [224, 186, 162]\\r\\n self.color255[114] = [255, 245, 217]\\r\\n self.color255[115] = [206, 110, 84]\\r\\n self.color255[116] = [210, 115, 89]\\r\\n self.color255[117] = [203, 108, 81]\\r\\n self.color255[118] = [233, 138, 112]\\r\\n self.color255[119] = [195, 100, 73]\\r\\n self.color255[120] = [181, 85, 57]\\r\\n self.color255[121] = [152, 55, 13]\\r\\n self.color255[122] = [159, 63, 27]\\r\\n self.color255[123] = [166, 70, 38]\\r\\n self.color255[124] = [218, 123, 97]\\r\\n self.color255[125] = [225, 130, 104]\\r\\n self.color255[126] = [224, 97, 76]\\r\\n self.color255[127] = [184, 122, 154]\\r\\n self.color255[128] = [211, 171, 143]\\r\\n self.color255[129] = [47, 150, 103]\\r\\n self.color255[130] = [173, 121, 88]\\r\\n self.color255[131] = [188, 95, 76]\\r\\n self.color255[132] = [255, 239, 172]\\r\\n self.color255[133] = [226, 202, 134]\\r\\n self.color255[134] = [253, 232, 158]\\r\\n self.color255[135] = [244, 217, 154]\\r\\n self.color255[136] = [205, 179, 108]\\r\\n self.color255[137] = [186, 124, 161]\\r\\n self.color255[138] = [255, 255, 220]\\r\\n self.color255[139] = [234, 234, 194]\\r\\n self.color255[140] = [204, 142, 178]\\r\\n self.color255[141] = [180, 119, 153]\\r\\n self.color255[142] = [216, 132, 105]\\r\\n self.color255[143] = [255, 253, 229]\\r\\n self.color255[144] = [205, 167, 142]\\r\\n self.color255[145] = [204, 168, 143]\\r\\n self.color255[146] = [255, 224, 199]\\r\\n self.color255[147] = [139, 150, 98]\\r\\n self.color255[148] = [249, 180, 111]\\r\\n self.color255[149] = [157, 108, 162]\\r\\n self.color255[150] = [203, 136, 116]\\r\\n self.color255[151] = [185, 102, 83]\\r\\n self.color255[152] = [247, 182, 164]\\r\\n self.color255[153] = [222, 154, 132]\\r\\n self.color255[154] = [124, 186, 223]\\r\\n self.color255[155] = [249, 186, 150]\\r\\n self.color255[156] = [244, 170, 147]\\r\\n self.color255[157] = [255, 181, 158]\\r\\n self.color255[158] = [255, 190, 165]\\r\\n self.color255[159] = [227, 153, 130]\\r\\n self.color255[160] = [213, 141, 113]\\r\\n self.color255[161] = [193, 123, 103]\\r\\n self.color255[162] = [216, 146, 127]\\r\\n self.color255[163] = [230, 158, 140]\\r\\n self.color255[164] = [245, 172, 147]\\r\\n self.color255[165] = [241, 172, 151]\\r\\n self.color255[166] = [177, 124, 92]\\r\\n self.color255[167] = [171, 85, 68]\\r\\n self.color255[168] = [217, 198, 131]\\r\\n self.color255[169] = [212, 188, 102]\\r\\n self.color255[170] = [185, 135, 134]\\r\\n self.color255[171] = [198, 175, 125]\\r\\n self.color255[172] = [194, 98, 79]\\r\\n self.color255[173] = [255, 238, 170]\\r\\n self.color255[174] = [206, 111, 93]\\r\\n self.color255[175] = [216, 186, 0]\\r\\n self.color255[176] = [255, 226, 77]\\r\\n self.color255[177] = [255, 243, 106]\\r\\n self.color255[178] = [255, 234, 92]\\r\\n self.color255[179] = [240, 210, 35]\\r\\n self.color255[180] = [224, 194, 0]\\r\\n self.color255[181] = [213, 99, 79]\\r\\n self.color255[182] = [217, 102, 81]\\r\\n self.color255[183] = [0, 147, 202]\\r\\n self.color255[184] = [0, 122, 171]\\r\\n self.color255[185] = [186, 77, 64]\\r\\n self.color255[186] = [240, 255, 30]\\r\\n self.color255[187] = [185, 232, 61]\\r\\n self.color255[188] = [0, 226, 255]\\r\\n self.color255[189] = [251, 159, 255]\\r\\n self.color255[190] = [230, 169, 29]\\r\\n self.color255[191] = [0, 194, 113]\\r\\n self.color255[192] = [104, 160, 249]\\r\\n self.color255[193] = [221, 108, 158]\\r\\n self.color255[194] = [137, 142, 0]\\r\\n self.color255[195] = [230, 70, 0]\\r\\n self.color255[196] = [0, 147, 0]\\r\\n self.color255[197] = [0, 147, 248]\\r\\n self.color255[198] = [231, 0, 206]\\r\\n self.color255[199] = [129, 78, 0]\\r\\n self.color255[200] = [0, 116, 0]\\r\\n self.color255[201] = [0, 0, 255]\\r\\n self.color255[202] = [157, 0, 0]\\r\\n self.color255[203] = [100, 100, 130]\\r\\n self.color255[204] = [205, 205, 100]\\r\\n self.color255[205] = [255, 255, 0]\\r\\n\\r\\n return self.color255\",\n \"def intensity(self, value: int, /) -> None:\",\n \"def setColors255(self):\\n #productive\\n profprint()\\n self.color255= [[0,0,0] for i in range(205)]\\n self.color255[0]=[221,108,158]\\n self.color255[1]=[128,174,128]\\n self.color255[2]=[241,214,145]\\n self.color255[3]=[177,122,101]\\n self.color255[4]=[111,184,210]\\n self.color255[5]=[216,101,79]\\n self.color255[6]=[221,130,101]\\n self.color255[7]=[144,238,144]\\n self.color255[8]=[192,104,88]\\n self.color255[9]=[220,245,20]\\n self.color255[10]=[78,63,0]\\n self.color255[11]=[255,250,220]\\n self.color255[12]=[230,220,70]\\n self.color255[13]=[200,200,235]\\n self.color255[14]=[250,250,210]\\n self.color255[15]=[244,214,49]\\n self.color255[16]=[0,151,206]\\n self.color255[17]=[183,156,220]\\n self.color255[18]=[183,214,211]\\n self.color255[19]=[152,189,207]\\n self.color255[20]=[178,212,242]\\n self.color255[21]=[68,172,100]\\n self.color255[22]=[111,197,131]\\n self.color255[23]=[85,188,255]\\n self.color255[24]=[0,145,30]\\n self.color255[25]=[214,230,130]\\n self.color255[26]=[218,255,255]\\n self.color255[27]=[170,250,250]\\n self.color255[28]=[140,224,228]\\n self.color255[29]=[188,65,28]\\n self.color255[30]=[216,191,216]\\n self.color255[31]=[145,60,66]\\n self.color255[32]=[150,98,83]\\n self.color255[33]=[250,250,225]\\n self.color255[34]=[200,200,215]\\n self.color255[35]=[68,131,98]\\n self.color255[36]=[83,146,164]\\n self.color255[37]=[162,115,105]\\n self.color255[38]=[141,93,137]\\n self.color255[39]=[182,166,110]\\n self.color255[40]=[188,135,166]\\n self.color255[41]=[154,150,201]\\n self.color255[42]=[177,140,190]\\n self.color255[43]=[30,111,85]\\n self.color255[44]=[210,157,166]\\n self.color255[45]=[48,129,126]\\n self.color255[46]=[98,153,112]\\n self.color255[47]=[69,110,53]\\n self.color255[48]=[166,113,137]\\n self.color255[49]=[122,101,38]\\n self.color255[50]=[253,135,192]\\n self.color255[51]=[145,92,109]\\n self.color255[52]=[46,101,131]\\n self.color255[53]=[0,108,112]\\n self.color255[54]=[127,150,88]\\n self.color255[55]=[159,116,163]\\n self.color255[56]=[125,102,154]\\n self.color255[57]=[106,174,155]\\n self.color255[58]=[154,146,83]\\n self.color255[59]=[126,126,55]\\n self.color255[60]=[201,160,133]\\n self.color255[61]=[78,152,141]\\n self.color255[62]=[174,140,103]\\n self.color255[63]=[139,126,177]\\n self.color255[64]=[148,120,72]\\n self.color255[65]=[186,135,135]\\n self.color255[66]=[99,106,24]\\n self.color255[67]=[156,171,108]\\n self.color255[68]=[64,123,147]\\n self.color255[69]=[138,95,74]\\n self.color255[70]=[97,113,158]\\n self.color255[71]=[126,161,197]\\n self.color255[72]=[194,195,164]\\n self.color255[73]=[88,106,215]\\n self.color255[74]=[82,174,128]\\n self.color255[75]=[57,157,110]\\n self.color255[76]=[60,143,83]\\n self.color255[77]=[92,162,109]\\n self.color255[78]=[255,244,209]\\n self.color255[79]=[201,121,77]\\n self.color255[80]=[70,163,117]\\n self.color255[81]=[188,91,95]\\n self.color255[82]=[166,84,94]\\n self.color255[83]=[182,105,107]\\n self.color255[84]=[229,147,118]\\n self.color255[85]=[174,122,90]\\n self.color255[86]=[201,112,73]\\n self.color255[87]=[194,142,0]\\n self.color255[88]=[241,213,144]\\n self.color255[89]=[203,179,77]\\n self.color255[90]=[229,204,109]\\n self.color255[91]=[255,243,152]\\n self.color255[92]=[209,185,85]\\n self.color255[93]=[248,223,131]\\n self.color255[94]=[255,230,138]\\n self.color255[95]=[196,172,68]\\n self.color255[96]=[255,255,167]\\n self.color255[97]=[255,250,160]\\n self.color255[98]=[255,237,145]\\n self.color255[99]=[242,217,123]\\n self.color255[100]=[222,198,101]\\n self.color255[101]=[213,124,109]\\n self.color255[102]=[184,105,108]\\n self.color255[103]=[150,208,243]\\n self.color255[104]=[62,162,114]\\n self.color255[105]=[242,206,142]\\n self.color255[106]=[250,210,139]\\n self.color255[107]=[255,255,207]\\n self.color255[108]=[182,228,255]\\n self.color255[109]=[175,216,244]\\n self.color255[110]=[197,165,145]\\n self.color255[111]=[172,138,115]\\n self.color255[112]=[202,164,140]\\n self.color255[113]=[224,186,162]\\n self.color255[114]=[255,245,217]\\n self.color255[115]=[206,110,84]\\n self.color255[116]=[210,115,89]\\n self.color255[117]=[203,108,81]\\n self.color255[118]=[233,138,112]\\n self.color255[119]=[195,100,73]\\n self.color255[120]=[181,85,57]\\n self.color255[121]=[152,55,13]\\n self.color255[122]=[159,63,27]\\n self.color255[123]=[166,70,38]\\n self.color255[124]=[218,123,97]\\n self.color255[125]=[225,130,104]\\n self.color255[126]=[224,97,76]\\n self.color255[127]=[184,122,154]\\n self.color255[128]=[211,171,143]\\n self.color255[129]=[47,150,103]\\n self.color255[130]=[173,121,88]\\n self.color255[131]=[188,95,76]\\n self.color255[132]=[255,239,172]\\n self.color255[133]=[226,202,134]\\n self.color255[134]=[253,232,158]\\n self.color255[135]=[244,217,154]\\n self.color255[136]=[205,179,108]\\n self.color255[137]=[186,124,161]\\n self.color255[138]=[255,255,220]\\n self.color255[139]=[234,234,194]\\n self.color255[140]=[204,142,178]\\n self.color255[141]=[180,119,153]\\n self.color255[142]=[216,132,105]\\n self.color255[143]=[255,253,229]\\n self.color255[144]=[205,167,142]\\n self.color255[145]=[204,168,143]\\n self.color255[146]=[255,224,199]\\n self.color255[147]=[139,150,98]\\n self.color255[148]=[249,180,111]\\n self.color255[149]=[157,108,162]\\n self.color255[150]=[203,136,116]\\n self.color255[151]=[185,102,83]\\n self.color255[152]=[247,182,164]\\n self.color255[153]=[222,154,132]\\n self.color255[154]=[124,186,223]\\n self.color255[155]=[249,186,150]\\n self.color255[156]=[244,170,147]\\n self.color255[157]=[255,181,158]\\n self.color255[158]=[255,190,165]\\n self.color255[159]=[227,153,130]\\n self.color255[160]=[213,141,113]\\n self.color255[161]=[193,123,103]\\n self.color255[162]=[216,146,127]\\n self.color255[163]=[230,158,140]\\n self.color255[164]=[245,172,147]\\n self.color255[165]=[241,172,151]\\n self.color255[166]=[177,124,92]\\n self.color255[167]=[171,85,68]\\n self.color255[168]=[217,198,131]\\n self.color255[169]=[212,188,102]\\n self.color255[170]=[185,135,134]\\n self.color255[171]=[198,175,125]\\n self.color255[172]=[194,98,79]\\n self.color255[173]=[255,238,170]\\n self.color255[174]=[206,111,93]\\n self.color255[175]=[216,186,0]\\n self.color255[176]=[255,226,77]\\n self.color255[177]=[255,243,106]\\n self.color255[178]=[255,234,92]\\n self.color255[179]=[240,210,35]\\n self.color255[180]=[224,194,0]\\n self.color255[181]=[213,99,79]\\n self.color255[182]=[217,102,81]\\n self.color255[183]=[0,147,202]\\n self.color255[184]=[0,122,171]\\n self.color255[185]=[186,77,64]\\n self.color255[186]=[240,255,30]\\n self.color255[187]=[185,232,61]\\n self.color255[188]=[0,226,255]\\n self.color255[189]=[251,159,255]\\n self.color255[190]=[230,169,29]\\n self.color255[191]=[0,194,113]\\n self.color255[192]=[104,160,249]\\n self.color255[193]=[221,108,158]\\n self.color255[194]=[137,142,0]\\n self.color255[195]=[230,70,0]\\n self.color255[196]=[0,147,0]\\n self.color255[197]=[0,147,248]\\n self.color255[198]=[231,0,206]\\n self.color255[199]=[129,78,0]\\n self.color255[200]=[0,116,0]\\n self.color255[201]=[0,0,255]\\n self.color255[202]=[157,0,0]\\n self.color255[203]=[100,100,130]\\n self.color255[204]=[205,205,100]\\n \\n return self.color255\",\n \"def lamps(self, **lamp_parameters):\\n self._set_state(lamp_parameters.items())\",\n \"def sRGBLuminance(x):\\n lin=linearFromsRGB3(x)\\n return lin[0]*0.2126+lin[1]*0.7152+lin[2]*0.0722\",\n \"def bright(self,l):\\n if 1 <= l <= 4:\\n self.send(\\\"\\\\x1f\\\\x58%c\\\" % l)\\n else:\\n raise ValueError('brightness values have to be between 1 and 4')\",\n \"def brighten(rgb, factor):\\n return [min(255, int(round(factor * c))) for c in rgb]\",\n \"def _value_as_luminance(self):\\n return round(float(self._value), 1)\",\n \"def calibrate_image(image, tl = 0.5):\\n for y in range(len(image)):\\n for x in range(len(image[y])):\\n # Convert the exiting pixel color to HLS model.\\n h, l, s = rgb_to_hls(image[y, x])\\n\\n # We convert the HLS model back to RGB, but using our target \\n # brightness value `tl`.\\n r, g, b = colorsys.hls_to_rgb(h, tl, s)\\n \\n # Set the new pixel color.\\n image[y][x] = [r * 255, g * 255, b * 255]\\n\\n return image\",\n \"def convert_lf(self, lf):\\n lf = np.float32(lf)\\n if np.max(lf) > 1:\\n lf = lf/256\\n lf = np.uint8(lf*256)\\n \\n if lf.shape[-1] > 3:\\n lf[lf[:,:,:,:,3] == 0] = (255,255,255,0) #convert alpha to white. \\n lf = lf[:,:,:,:,:3]\\n # while lf.ndim < 6:\\n # lf = np.expand_dims(lf, 0)\\n \\n lf = resize_lightfield(lf, (self.width, self.height)) \\n return lf\",\n \"def setColourMap(self):\\n cmap = self.config['cmap']\\n\\n pos, colour, mode = colourMaps.colourMaps(cmap)\\n\\n cmap = pg.ColorMap(pos, colour,mode)\\n self.lut = cmap.getLookupTable(0.0, 1.0, 256)\\n minsg = np.min(self.sg)\\n maxsg = np.max(self.sg)\\n self.colourStart = (self.config['brightness'] / 100.0 * self.config['contrast'] / 100.0) * (maxsg - minsg) + minsg\\n self.colourEnd = (maxsg - minsg) * (1.0 - self.config['contrast'] / 100.0) + self.colourStart\",\n \"def refresh_color(self):\\n self.color = max(0, int(math.sqrt(self.vx ** 2\\n + self.vy ** 2)) + 100)\",\n \"def setLeds(number: int, red: int, green: int, blue: int):\\n pass\",\n \"def high_bri(self):\\r\\n for light in self.lights:\\r\\n bri = self.b.get_light(light,'bri')\\r\\n bri = bri + 50 \\r\\n if bri > 255:\\r\\n bri = 255 \\r\\n self.b.set_light(light,'bri',bri)\",\n \"def setColourMap(self):\\n cmap = self.config['cmap']\\n\\n pos, colour, mode = colourMaps.colourMaps(cmap)\\n\\n cmap = pg.ColorMap(pos, colour, mode)\\n self.lut = cmap.getLookupTable(0.0, 1.0, 256)\\n minsg = np.min(self.sg)\\n maxsg = np.max(self.sg)\\n self.colourStart = (self.config['brightness'] / 100.0 * self.config['contrast'] / 100.0) * (\\n maxsg - minsg) + minsg\\n self.colourEnd = (maxsg - minsg) * (1.0 - self.config['contrast'] / 100.0) + self.colourStart\",\n \"def light(brightness, filter):\\n brightness = clamp(MIN_BRIGHTNESS, round(brightness), MAX_BRIGHTNESS)\\n for col in range(DISPLAY_WIDTH):\\n for row in range(DISPLAY_HEIGHT):\\n if filter(col, row):\\n microbit.display.set_pixel(col, row, brightness)\",\n \"def set_intensity(self,intensity):\\n intensity=int(intensity)\\n assert intensity>=0 and intensity<=100\\n self.usbdev.ctrl_transfer(bmRequestType=0x21, bRequest=0x09, wValue=0x03a6, wIndex=0, data_or_wLength=[0xa6,0x00,intensity])\\n self.intensity=intensity\",\n \"def set_lam_nll(self, lam_nll=1.0):\\n zero_ary = np.zeros((1,))\\n new_lam = zero_ary + lam_nll\\n self.lam_nll.set_value(to_fX(new_lam))\\n return\",\n \"def setColors(self):\\n #productive\\n profprint()\\n self.color= [[0,0,0] for i in range(205)]\\n self.color255= self.setColors255()\\n for i in range(205):\\n for j in range(3):\\n self.color[i][j] = self.color255[i][j]/float(255)\\n\\n return self.color\",\n \"def compute_luminosity(red, green, blue):\\r\\n return (0.299 * red) + (0.587 * green) + (0.114 * blue)\",\n \"def setColorBarRange(start=1,end=254):\\n dislin.colran(start,end)\",\n \"def setAutoColorResolution(nx, ny):\\n dislin.autres(nx,ny)\",\n \"def scale_to_01(color: C3I) -> C3F:\\n r, g, b = color\\n return r / 255, g / 255, b / 255\",\n \"def flicker_lights(self):\\n print 'Lights Set'\",\n \"def set_intensity(intensity):\\n ret = _LIB.led_matrix_click_set_intensity(intensity)\\n if ret < 0:\\n raise Exception(\\\"led matrix click set intensity failed\\\")\",\n \"def make_lulc_raster(raster_path, lulc_val):\\r\\n lulc_array = numpy.zeros((100, 100), dtype=numpy.int8)\\r\\n lulc_array[50:, :] = lulc_val\\r\\n make_raster_from_array(lulc_array, raster_path)\",\n \"def adjust_illuminant(self, il):\\n # store mean luminance\\n mean_lum = self.mean_luminance\\n\\n # adjust il wavelength\\n il.wave = self.wave\\n\\n # update photons\\n self.photons *= il.photons / self.illuminant.photons\\n\\n # update illuminant spd\\n self.illuminant = il\\n\\n # make sure mean luminance is not changed\\n self.mean_luminance = mean_lum\",\n \"def grayscale(self):\\n\\n luminance = self.get_luminance() & 0xFF\\n self.r = luminance\\n self.g = luminance\\n self.b = luminance\",\n \"def normalize_01(x):\\n return x / 255.0\",\n \"def set_brightness(self, level):\\n print(\\\"Got request to set brightness with level: %s\\\" % (level))\\n # Home assistant sets brightness on a scale of 0 to 255\\n if level > 0 and level < 255:\\n new_level = level / 255\\n print(\\\"Setting brightness to %s\\\" % (new_level))\\n self.turn_on(r=self.r, g=self.g, b=self.b, brightness=new_level)\\n self.client.publish(BRIGHTNESS_STATE_TOPIC, level) #publish\",\n \"def normalize_image(self, factor, luminosity=None):\\n if not luminosity:\\n luminosity = self.average_luminosity()\\n\\n for i in range(len(self.pixels)):\\n self.pixels[i] = self.pixels[i] * (factor / luminosity)\",\n \"def brightness(self, factor):\\n\\n channels = [\\\"r\\\", \\\"g\\\", \\\"b\\\"]\\n total_lumes = clamp(self.get_luminance() + (255.0 * factor) - 255.0, 0.0, 255.0)\\n\\n if total_lumes == 255.0:\\n # white\\n self.r, self.g, self.b = 0xFF, 0xFF, 0xFF\\n elif total_lumes == 0.0:\\n # black\\n self.r, self.g, self.b = 0x00, 0x00, 0x00\\n else:\\n # Adjust Brightness\\n pts = (total_lumes - 0.299 * self.r - 0.587 * self.g - 0.114 * self.b)\\n slots = set(channels)\\n components = [float(self.r) + pts, float(self.g) + pts, float(self.b) + pts]\\n count = 0\\n for c in channels:\\n overage, components[count] = self._get_overage(components[count])\\n if overage:\\n slots.remove(c)\\n components = list(self._distribute_overage(components, overage, slots))\\n count += 1\\n\\n self.r = clamp(round_int(components[0]), 0, 255) & 0xFF\\n self.g = clamp(round_int(components[1]), 0, 255) & 0xFF\\n self.b = clamp(round_int(components[2]), 0, 255) & 0xFF\",\n \"def adjust_saturation(image, factor):\\r\\n image[..., 1] = np.clip(image[..., 1] * factor, 0, 255)\\r\\n return image\",\n \"def setPixelColor(self, n, color):\\n\\t\\t#print \\\"pxl %s = %s\\\" % (n, color)\\n\\t\\tif isinstance(n, slice):\\n\\t\\t\\tself.leds[n] = [color]*len(self.leds[n])\\n\\t\\telse:\\n\\t\\t\\tif n >= 0 or n <= self.size:\\n\\t\\t\\t\\tself.leds[n] = color\\n\\t\\t#pprint(self.leds)\",\n \"def changeColor( self ):\\n\\t\\t\\n\\t\\tx, y = self.position.xy\\n\\t\\tself.color = ( int((x / WINDOW_X) * 128), int((x / WINDOW_X) * 128) + int((y / WINDOW_Y) * 128 ), int((y / WINDOW_Y) * 128))\",\n \"def darker(image):\\r\\n # Demonstrate looping over all the pixels of an image,\\r\\n # changing each pixel to be half its original intensity.\\r\\n for pixel in image:\\r\\n pixel.red = pixel.red // 2\\r\\n pixel.green = pixel.green // 2\\r\\n pixel.blue = pixel.blue // 2\",\n \"def setAlpha ( self, newalpha ):\\n if isinstance( newalpha, int ):\\n raise ValueError('Expects a float value in the [ 0.0 - 1.0 ] range!')\\n if newalpha > 1.0:\\n newalpha = 1.0\\n if newalpha < 0.0:\\n newalpha = 0.0\\n self.a = newalpha\\n self.hsla[3] = newalpha\\n self.rgba[3] = newalpha\",\n \"def _monochrome(self):\\r\\n\\r\\n self.img = self.img.convert('L')\\r\\n self.img = Image.eval(self.img, lambda a: 0 if a <= MONOWEIGHT else 255)\",\n \"def setHsla ( self, h, s = 0.0, l = 0.0, a = 1.0 ):\\n #self.reset()\\n\\n # Check if argument is list\\n if isinstance(h, list):\\n s = h[1]\\n l = h[2]\\n if len(h) == 4: # Alpha in the list\\n a = h[3]\\n h = h[0]\\n\\n # If any component is int ( 0 - 255 ) convert to float ( 0 - 1)\\n hsla = [ h, s, l, a ]\\n for i in range(len(hsla)):\\n if isinstance( hsla[i], int ):\\n hsla[i] = hsla[i] / 360.0 if i == 0 else hsla[i] / 100.0\\n\\n self.h = hsla[0]\\n self.s = hsla[1]\\n self.l = hsla[2]\\n self.a = hsla[3]\\n self.hsl = [ hsla[0], hsla[1], hsla[2] ]\\n self.hsla = [ hsla[0], hsla[1], hsla[2], hsla[3] ]\\n\\n self.updateFromHsl()\",\n \"def solarize(img, threshold):\\n \\n for x, y, col in img:\\n\\n # Invert the values of all RGB components less than 128,\\n # leaving components with higher values unchanged.\\n\\n red, green, blue = col\\n\\n if red < threshold:\\n red = 255 - red\\n\\n if green < threshold:\\n green = 255 - green\\n\\n if blue < threshold:\\n blue = 255 - blue\\n\\n col = create_color(red, green, blue)\\n set_color(img, x, y, col)\",\n \"def bndy_plasma(self):\\n self.ne[0], self.ne[-1] = 1e11, 1e11\\n self.ni[0], self.ni[-1] = 1e11, 1e11\\n self.nn[0], self.nn[-1] = 1e11, 1e11\\n self.Te[0], self.Te[-1] = 0.1, 0.1\\n self.Ti[0], self.Ti[-1] = 0.01, 0.01\\n # self.coll_em[0], self.coll_em[-1] = 1e5, 1e5\\n # self.coll_im[0], self.coll_im[-1] = 1e5, 1e5\",\n \"def set_contrast(level):\\n send_command(0x81)\\n send_command(level)\",\n \"def lut(threshold):\\n\\n return [255 if i<=threshold else 0 for i in range(256)]\",\n \"def turn_on(self, **kwargs: Any) -> None:\\n self._light.brightness = kwargs.get(ATTR_BRIGHTNESS, 255)\\n self._light.turn_on()\",\n \"def setLCLimits(*args):\\n args[0].Limit.LCLimit.lc_limit = args[1]\",\n \"def scaleLandsat(self,img):\\n\\t\\tthermal = img.select(ee.List(['thermal'])).multiply(0.1)\\n\\t\\tscaled = ee.Image(img).select(self.env.divideBands).multiply(ee.Number(0.0001))\\n\\t\\t\\n\\t\\treturn img.select([]).addBands(scaled).addBands(thermal)\",\n \"def set_laser_power(self, power: int):\\n self.logger.info(f'Setting laser power to {power}')\\n power = int(power)\\n if power <= 1:\\n self.electronics.servo = 0\\n else:\\n self.electronics.servo = 1\\n\\n self.electronics.laser_power = power\\n self.config['laser']['power'] = power\",\n \"def lapsharp(image, maskret = False):\\n #padded_image = np.pad(img, (1, 1), mode = 'symmetric')\\n # lap is linear therefore;\\n # lap f(x,y) = f(x + 1, y) + f(x - 1, y) + f(x, y + 1) + f(x, y - 1) - 4f(x,y)...\\n #--------------------\\n c = -1 # Depends on kernel\\n # make zero kernal\\n lapmask = np.zeros((3, 3))\\n \\n # add values to kernel\\n lapmask[0,0] = 1\\n lapmask[0,1] = 1\\n lapmask[0,2] = 1\\n\\n lapmask[1,0] = 1\\n lapmask[1,1] = -8\\n lapmask[1,2] = 1\\n\\n lapmask[2,0] = 1\\n lapmask[2,1] = 1\\n lapmask[2,2] = 1\\n #--------------------\\n mask = convolve2d(image, lapmask, mode = 'same')\\n result = image + c*mask\\n\\n # Map values to 0-255\\n g1 = image - np.min(image)\\n g = g1/np.max(g1) *255\\n g = g.astype('uint8')\\n\\n if maskret == True:\\n return g, mask\\n else:\\n return g.astype('uint8')\",\n \"def enhance_contrast(img):\\n for y in range(frame_height):\\n for x in range(frame_width):\\n if img[y, x, 1] > 100:\\n # range of blues to limit of puppet motion 255/(frame_width - 150)\\n img[y][x][0] = x*0.4\\n if img[y, x, 1] <= 100:\\n img[y][x][2] = img[y][x][2]*0.5\\n cv2.imwrite(\\\"contrasted.png\\\", img)\",\n \"def adjust_brightness(image, delta):\\r\\n return _clip(image + delta * 255)\",\n \"def set_color_brightness(color, brightness):\\n if brightness == 0:\\n put_light_state(False, 0, 0, 16000)\\n else:\\n put_light_state(\\n True,\\n 254 * color // 100,\\n 254 * brightness // 100,\\n 16000\\n )\",\n \"def set_alpha(self, alpha=1.0):\\r\\n self.unif[17] = alpha\",\n \"def __init__(self,\\r\\n lightpos=(10, -10, 20),\\r\\n lightcol=(1.0, 1.0, 1.0),\\r\\n lightamb=(0.1, 0.1, 0.2)):\\r\\n super(Light, self).__init__()\\r\\n self.lightpos = lightpos\\r\\n self.lightcol = lightcol\\r\\n self.lightamb = lightamb\",\n \"def intensity(self) -> int:\",\n \"def set_fade_threshold(self, address):\\n self.model.fade_address = address\",\n \"def pixelLuminance (r, g, b):\\n assert (type(r) == int and type(g) == int and type(b) == int)\\n assert (0<=r<=255 and 0<=g<=255 and 0<=b<=255)\\n return roundHalfUp((.2126*r)+(.7152*g)+(.0722*b))\",\n \"def set_colormap_full_range(self):\\n if(self.plot.image is None):\\n return\\n \\n cmin = self.settingsWidget.ui.colormap_min\\n cmax = self.settingsWidget.ui.colormap_max\\n data_min = numpy.min(self.plot.image)\\n data_max = numpy.max(self.plot.image)\\n cmin.setText(str(data_min))\\n cmax.setText(str(data_max))\\n self.set_colormap_range()\",\n \"def off(l):\\n l.do_static_colour(255, 0, 0, 0)\",\n \"def set_color(group, color, pct=1):\\n for l, v in zip(group, color):\\n l.brightness_pct = v * pct\",\n \"def get_luminosity(self):\\n\\n if self.no_dist is False and self.no_flux is False:\\n\\n dist = self.distance\\n snu = self.snu_at_1GHz\\n lum = lumin(dist, snu)\\n\\n self.lum = lum\\n else:\\n self.lum = -1 # use -1 to indicate unknown luminosity\\n return self.lum\",\n \"def rescale_intensity(image, thres=(1.0, 99.0)):\\n val_l, val_h = np.percentile(image, thres)\\n image2 = image\\n image2[image < val_l] = val_l\\n image2[image > val_h] = val_h\\n image2 = (image2.astype(np.float32) - val_l) / (val_h - val_l)\\n return image2\",\n \"def filterToLight( bmp, savefile = '' ):\\n for h in range(bmp.height):\\n for w in range(bmp.width):\\n HSL = RGBtoHSL( bmp.pixels[h][w] )\\n lit = int(255*HSL[2]) # convert to 0-255 range\\n bmp.pixels[h][w] = (lit,lit,lit)\\n if( savefile != '' ):\\n bmp.save(savefile)\\n return bmp\",\n \"def luminance(rgb):\\n \\n (r, g, b) = rgb\\n return (r + g + b) // 3\",\n \"def set_light(self, light, num=0):\\r\\n #TODO (pg) need MAXLIGHTS global variable, room for two now but shader\\r\\n # only uses 1.\\r\\n if num > 1 or num < 0:\\r\\n num = 0\\r\\n stn = 24 + num * 9\\r\\n self.unif[stn:(stn + 3)] = light.lightpos[0:3]\\r\\n self.unif[(stn + 3):(stn + 6)] = light.lightcol[0:3]\\r\\n self.unif[(stn + 6):(stn + 9)] = light.lightamb[0:3]\",\n \"def larkin_autocor_model(x,y,amplitude=1.,x_mean_0=0.,y_mean_0=0.,width=1.,background=0.):\\n intensity = 1./(2*np.pi) * (width/((x-x_mean_0)**2 + (y-y_mean_0)**2 + width**2)**1.5) # 2D Lorentzian works well\\n intensity *= amplitude / np.max(intensity)\\n intensity += background\\n return intensity\",\n \"def intensityPSF_Blues(N=1000):\\n col_seq = [( 0/255., 20/255., 80/255.), ( 8/255., 48/255., 107/255.),\\n ( 8/255., 81/255., 156/255.), ( 33/255., 113/255., 181/255.),\\n ( 66/255., 146/255., 198/255.), (107/255., 174/255., 214/255.),\\n (158/255., 202/255., 225/255.), (198/255., 219/255., 239/255.),\\n (222/255., 235/255., 247/255.), (247/255., 251/255., 255/255.)]\\n\\n cdict = {'red': ((0.00, col_seq[0][0], col_seq[0][0]),\\n (0.02, col_seq[1][0], col_seq[1][0]),\\n (0.06, col_seq[2][0], col_seq[2][0]),\\n (0.10, col_seq[3][0], col_seq[3][0]),\\n (0.20, col_seq[4][0], col_seq[4][0]),\\n (0.30, col_seq[5][0], col_seq[5][0]),\\n (0.50, col_seq[6][0], col_seq[6][0]),\\n (0.75, col_seq[7][0], col_seq[7][0]),\\n (0.90, col_seq[8][0], col_seq[8][0]),\\n (1.00, col_seq[9][0], col_seq[9][0])),\\n 'green': ((0.00, col_seq[0][1], col_seq[0][1]),\\n (0.02, col_seq[1][1], col_seq[1][1]),\\n (0.06, col_seq[2][1], col_seq[2][1]),\\n (0.10, col_seq[3][1], col_seq[3][1]),\\n (0.20, col_seq[4][1], col_seq[4][1]),\\n (0.30, col_seq[5][1], col_seq[5][1]),\\n (0.50, col_seq[6][1], col_seq[6][1]),\\n (0.75, col_seq[7][1], col_seq[7][1]),\\n (0.90, col_seq[8][1], col_seq[8][1]),\\n (1.00, col_seq[9][1], col_seq[9][1])),\\n 'blue': ((0.00, col_seq[0][2], col_seq[0][2]),\\n (0.02, col_seq[1][2], col_seq[1][2]),\\n (0.06, col_seq[2][2], col_seq[2][2]),\\n (0.10, col_seq[3][2], col_seq[3][2]),\\n (0.20, col_seq[4][2], col_seq[4][2]),\\n (0.30, col_seq[5][2], col_seq[5][2]),\\n (0.50, col_seq[6][2], col_seq[6][2]),\\n (0.75, col_seq[7][2], col_seq[7][2]),\\n (0.90, col_seq[8][2], col_seq[8][2]),\\n (1.00, col_seq[9][2], col_seq[9][2]))}\\n\\n psfblues = _mplb.colors.LinearSegmentedColormap('psfblues', cdict, N)\\n return psfblues\",\n \"def intensity_spread(img, L):\\n\\n pixels = img.flatten()\\n min_pix = np.amin(pixels)\\n max_pix = np.amax(pixels)\\n res = np.zeros(pixels.shape)\\n\\n for idx, p in enumerate(pixels):\\n res[idx] = (L - 1) * ((p - min_pix) / (max_pix - min_pix))\\n\\n return np.reshape(res, img.shape)\",\n \"def increase_brightness(image, value=18):\\n hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\\n h, s, v = cv2.split(hsv)\\n\\n lim = 255 - value\\n v[v > lim] = 255\\n v[v <= lim] += value\\n\\n final_hsv = cv2.merge((h, s, v))\\n image = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)\\n return image\",\n \"def setColorResolution(width=1,height=1):\\n dislin.setres(width,height)\",\n \"def set_contrast(value):\\n command([0x21, 0x14, value, 0x20, 0x0c])\",\n \"def change_brightness(img,k=0):\\n\\n img_copy = np.copy(img)\\n img_copy = img_copy.astype(int)\\n img_copy += k\\n\\n return img_copy\",\n \"def changeColor(self):\\n self.layer.new_colormap()\",\n \"def mel_to_linear(\\n self, mel_amp: np.ndarray, threshold: float = 1e-10\\n ) -> np.ndarray:\\n return np.maximum(threshold, np.dot(self._inv_mel_basis, mel_amp))\",\n \"def set_UVLO_threshold(self, i: int = 0):\\n dic = {0: \\\"101\\\", 1: \\\"110\\\", 2: \\\"111\\\", 3: \\\"000\\\"}\\n self.set_byte(\\\"d6\\\", \\\"00000\\\" + dic[i])\\n self.get_UVLO_threshold()\",\n \"def set_red(x, y, value, slot = 0):\\r\\n __g[slot].pixels_rgb[__g[slot].width * 3 * y + x * 3] = value\",\n \"def light_number(self, number, position):\\n for [x, y] in number:\\n uh.set_pixel(x+position[0], y+position[1], 183, 0, 255)\\n uh.show()\",\n \"def rgb_to_lab(img, l=False, ab=False):\\n img = img / 255\\n l_chan = color.rgb2lab(img)[:, :, 0]\\n l_chan = l_chan / 50 - 1\\n l_chan = l_chan[..., np.newaxis]\\n\\n ab_chan = color.rgb2lab(img)[:, :, 1:]\\n ab_chan = (ab_chan + 128) / 255 * 2 - 1\\n if l:\\n return l_chan\\n else:\\n return ab_chan\",\n \"def all_off():\\n Leds.red_left.brightness = 0\\n Leds.red_right.brightness = 0\\n Leds.green_left.brightness = 0\\n Leds.green_right.brightness = 0\\n Leds.blue_left.brightness = 0\\n Leds.blue_right.brightness = 0\",\n \"def luminosity(r,T,autoDebug=True):\\n\\t#-----------BEGIN ERROR CHECKING----------\\n\\tif autoDebug:\\n\\t\\tsam.type_check(r, sam.TYPES_math, \\\"r\\\")\\n\\t\\tsam.type_check(T, sam.TYPES_math, \\\"T\\\")\\n\\t\\tsam.value_check(r,.0,\\\">\\\",\\\"r\\\")\\n\\t\\tsam.value_check(T,.0,\\\">\\\",\\\"T\\\")\\n\\t#-----------END ERROR CHECKING----------\\n\\n\\tL = 4 * sam.CONSTANT_pi * r**2 * sam.CONSTANT_SB* T**4\\n\\treturn L\",\n \"def change_value(image):\\n\\n out = None\\n\\n #####################################\\n # START YOUR CODE HERE #\\n #####################################\\n image = image / 255\\n out = np.empty_like(image)\\n height, width, _ = image.shape\\n for h in range(height):\\n for w in range(width):\\n x_p = image[h,w]\\n x_n = (x_p * x_p) * 0.5\\n out[h,w] = x_n\\n ######################################\\n # END OF YOUR CODE #\\n ######################################\\n\\n return out\",\n \"def lower_bri(self):\\r\\n for light in self.lights:\\r\\n bri = self.b.get_light(light,'bri')\\r\\n bri = bri - 50\\r\\n if bri < 0:\\r\\n bri = 1\\r\\n self.b.set_light(light,'bri',bri)\",\n \"def set_pixel(self, x, y, value):\\n if x < 0 or x > 7 or y < 0 or y > 15:\\n # Ignore out of bounds pixels.\\n return\\n if y < 8:\\n self.set_led( y * 16 + x, value)\\n else:\\n self.set_led((y-8) * 16 + (x+8), value)\",\n \"def augment_brightness(image):\\n rand_brightness = .25 + np.random.uniform()\\n image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)\\n image[:, :, 2] = image[:, :, 2] * rand_brightness\\n image = cv2.cvtColor(image, cv2.COLOR_HSV2RGB)\\n return image\",\n \"def setColors(self):\\r\\n # productive\\r\\n profprint()\\r\\n self.color = [[0, 0, 0] for i in range(MAXCOL)]\\r\\n self.color255 = self.setColors255()\\r\\n for i in range(MAXCOL):\\r\\n for j in range(3):\\r\\n self.color[i][j] = self.color255[i][j] / float(255)\\r\\n\\r\\n return self.color\",\n \"def turn_on(self, **kwargs: Any) -> None:\\n if self._dimmable:\\n level = kwargs.get(ATTR_BRIGHTNESS, self._last_brightness)\\n else:\\n level = 255\\n self._light.turn_on(to_futurenow_level(level))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6964496","0.63056415","0.6125189","0.6003263","0.5950201","0.59406114","0.5883176","0.5873168","0.58662814","0.5791942","0.5753206","0.5749067","0.5714888","0.57111955","0.56980145","0.5697827","0.56953377","0.5693024","0.56886524","0.5638608","0.56340116","0.56283975","0.5627892","0.5617596","0.56144434","0.56096053","0.55913955","0.5586467","0.5585896","0.5557544","0.55459136","0.5544747","0.5544632","0.55394256","0.5528909","0.5508208","0.55068296","0.54968995","0.5488387","0.54844","0.54801","0.54635054","0.5462406","0.54570323","0.5447109","0.54466546","0.5441454","0.5433913","0.5427634","0.54271406","0.5421635","0.54136026","0.5412383","0.5409047","0.5392626","0.5390065","0.5388923","0.53859997","0.5382325","0.5367936","0.53652555","0.5359901","0.53413266","0.5333799","0.5310247","0.53085387","0.52969027","0.5296717","0.52962345","0.52950656","0.5294522","0.5286769","0.52857393","0.528243","0.5278659","0.52764714","0.52728546","0.52711284","0.5269161","0.5268368","0.5265661","0.5262352","0.5248634","0.5246872","0.5243159","0.52426535","0.5242617","0.52412236","0.52372104","0.5233577","0.5230811","0.5228564","0.52207935","0.52192533","0.52183545","0.52167124","0.52136034","0.5213017","0.5212978","0.52124786"],"string":"[\n \"0.6964496\",\n \"0.63056415\",\n \"0.6125189\",\n \"0.6003263\",\n \"0.5950201\",\n \"0.59406114\",\n \"0.5883176\",\n \"0.5873168\",\n \"0.58662814\",\n \"0.5791942\",\n \"0.5753206\",\n \"0.5749067\",\n \"0.5714888\",\n \"0.57111955\",\n \"0.56980145\",\n \"0.5697827\",\n \"0.56953377\",\n \"0.5693024\",\n \"0.56886524\",\n \"0.5638608\",\n \"0.56340116\",\n \"0.56283975\",\n \"0.5627892\",\n \"0.5617596\",\n \"0.56144434\",\n \"0.56096053\",\n \"0.55913955\",\n \"0.5586467\",\n \"0.5585896\",\n \"0.5557544\",\n \"0.55459136\",\n \"0.5544747\",\n \"0.5544632\",\n \"0.55394256\",\n \"0.5528909\",\n \"0.5508208\",\n \"0.55068296\",\n \"0.54968995\",\n \"0.5488387\",\n \"0.54844\",\n \"0.54801\",\n \"0.54635054\",\n \"0.5462406\",\n \"0.54570323\",\n \"0.5447109\",\n \"0.54466546\",\n \"0.5441454\",\n \"0.5433913\",\n \"0.5427634\",\n \"0.54271406\",\n \"0.5421635\",\n \"0.54136026\",\n \"0.5412383\",\n \"0.5409047\",\n \"0.5392626\",\n \"0.5390065\",\n \"0.5388923\",\n \"0.53859997\",\n \"0.5382325\",\n \"0.5367936\",\n \"0.53652555\",\n \"0.5359901\",\n \"0.53413266\",\n \"0.5333799\",\n \"0.5310247\",\n \"0.53085387\",\n \"0.52969027\",\n \"0.5296717\",\n \"0.52962345\",\n \"0.52950656\",\n \"0.5294522\",\n \"0.5286769\",\n \"0.52857393\",\n \"0.528243\",\n \"0.5278659\",\n \"0.52764714\",\n \"0.52728546\",\n \"0.52711284\",\n \"0.5269161\",\n \"0.5268368\",\n \"0.5265661\",\n \"0.5262352\",\n \"0.5248634\",\n \"0.5246872\",\n \"0.5243159\",\n \"0.52426535\",\n \"0.5242617\",\n \"0.52412236\",\n \"0.52372104\",\n \"0.5233577\",\n \"0.5230811\",\n \"0.5228564\",\n \"0.52207935\",\n \"0.52192533\",\n \"0.52183545\",\n \"0.52167124\",\n \"0.52136034\",\n \"0.5213017\",\n \"0.5212978\",\n \"0.52124786\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5315991"},"document_rank":{"kind":"string","value":"64"}}},{"rowIdx":81597,"cells":{"query":{"kind":"string","value":"Produce a sequence of IOTool commands to enable and disable given Spectra lamps. Keyword arguments must be lamp names, as specified in the scope configuration. The values specified must be True to enable that lamp, False to disable, or None to do nothing (unspecified lamps are also not altered)."},"document":{"kind":"string","value":"def _iotool_lamp_commands(self, **lamps):\n commands = []\n for lamp, enabled in lamps.items():\n if enabled is None:\n continue\n pin = self._spconfig.IOTOOL_LAMP_PINS[lamp]\n if enabled:\n commands.append(self._iotool.commands.set_high(pin))\n else:\n commands.append(self._iotool.commands.set_low(pin))\n return commands"},"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 lamps(self, **lamp_parameters):\n self._set_state(lamp_parameters.items())","def all_lamps_slow():\n HOUSE = pre_process.get_house()\n\n for id_num, lamp in HOUSE.lamps.items():\n lamp.turn_on()\n lamp.set_transition_time(500)\n lamp.set_brigthness(254)\n lamp.send_command()","def run_lammps(lammps_executable, input_file, output_file):\n # run lammps\n lammps_command = f\"{lammps_executable} -in {input_file} \"\n print(\"run command:\", lammps_command)\n with open(\"tmp2False.out\", \"w+\") as fout:\n subprocess.call(lammps_command.split(), stdout=fout)","def silkscreen_commands(self, commands):\n self.pcb_layers[\"silkscreen\"].commands = commands","def get_all_switches(name):\n return [False,False,False,False] #TODO Implement","def list_litnacionals_cmd():\n return ListLitnacionalCommand()","def init_switches(inds):\n for i in inds:\n GPIO.setup(i, GPIO.OUT, initial=0)","def _arm_and_offboard(self):\n arming_client = rospy.ServiceProxy('/mavros/cmd/arming', CommandBool)\n set_mode_client = rospy.ServiceProxy('/mavros/set_mode', SetMode)\n\n offb_set_mode = SetMode()\n offb_set_mode.custom_mode = \"OFFBOARD\"\n\n arm_cmd = CommandBool()\n arm_cmd.value = True\n\n wait_time = rospy.Duration(1)\n\n last_request = rospy.Time.now()\n while not rospy.is_shutdown() and (self.mavros_state.mode != \"OFFBOARD\" or not self.mavros_state.armed):\n if self.mavros_state.mode != \"OFFBOARD\" and (rospy.Time.now() - last_request > wait_time):\n res = set_mode_client(0, offb_set_mode.custom_mode)\n if res and res.mode_sent:\n rospy.loginfo(self.name + \": Offboard enabled\")\n last_request = rospy.Time.now()\n else:\n if not self.mavros_state.armed and (rospy.Time.now() - last_request > wait_time):\n res = arming_client(True)\n if res and res.success:\n rospy.loginfo(self.name + \": Vehicle armed\")\n last_request = rospy.Time.now()\n return","def initiate_lmp(self, cs_springs):\n lmp = lammps()\n \n lmp.command('units metal')\n lmp.command('atom_style full')\n \n large_tilt = self._check_large_tilt()\n if large_tilt:\n lmp.command('box tilt large')\n\n lmp.command('read_data {}'.format(self.file_name))\n \n lmp.command('group cores type {}'.format(self.type_core()))\n if len(self.bond_types) != 0:\n lmp.command('group shells type {}'.format(self.type_shell()))\n\n if cs_springs:\n lmp.command('pair_style buck/coul/long/cs 10.0')\n lmp.command('pair_coeff * * 0 1 0')\n\n lmp.command('bond_style harmonic') \n for bond in self.bond_types:\n lmp.command(bond.bond_string())\n else:\n lmp.command('pair_style buck/coul/long 10.0')\n lmp.command('pair_coeff * * 0 1 0')\n\n lmp.command('kspace_style ewald 1e-6')\n\n #setup for minimization\n lmp.command('min_style cg')\n return lmp","def set_pulse_on_hit_and_enable_and_release_and_disable_rule(self, enable_switch, disable_switch, coil):\n raise NotImplementedError","def setLightingOptions(lightID, val, otype):\n odict = {'ambient':'AMBIENT','diffuse':'DIFFUSE','specular':'SPECULAR',\n 'constant':'CONSTANT','linear':'LINEAR','quadratic':'QUADRATIC'}\n dislin.litopt(lightID, val, odict[otype])","def do_attribute_switches(self):\n event = None\n if self.rhs:\n event = self.get_event_from_args(self.rhs, check_host=True)\n else:\n proj = self.project\n if not proj:\n raise self.CalCmdError(\n \"You must use /create first or specify an event.\"\n )\n if \"largesse\" in self.switches:\n return self.set_largesse(event)\n if \"date\" in self.switches or \"reschedule\" in self.switches:\n return self.set_date(event)\n if \"location\" in self.switches:\n return self.set_location(event)\n if \"desc\" in self.switches:\n return self.set_event_desc(event)\n if \"roomdesc\" in self.switches:\n return self.set_room_desc(event)\n if \"plotroom\" in self.switches:\n return self.set_plotroom(event)\n if \"private\" in self.switches:\n return self.set_private(event)\n if \"host\" in self.switches:\n return self.add_or_remove_host(event)\n if \"gm\" in self.switches:\n return self.add_or_remove_gm(event)\n if \"invite\" in self.switches:\n return self.invite_org_or_player(event)\n if \"uninvite\" in self.switches:\n return self.uninvite_org_or_player(event)\n if \"action\" in self.switches:\n return self.set_crisis_action(event)\n if \"risk\" in self.switches:\n return self.set_risk(event)","def magic_lsmagic(self, parameter_s = ''):\n print 'Available magic functions:\\n@'+' @'.join(self.lsmagic())\n print '\\n' + Magic.auto_status[self.rc.automagic]\n return None","def __init__(self):\r\n self.label = \"OVL Tools\"\r\n self.alias = \"\"\r\n\r\n # List of tool classes associated with this toolbox\r\n self.tools = [OVLtoFeature, BatchOVLtoFeature]","def set_lo1ab_off(self):\n self.seq.add_param(self.mng_name, \"testTonePowerLevel\", \"-110\", 4)\n self.seq.add_param(self.mng_name, \"loPowerLevel\", \"-110\", 1)\n self.seq.add_param(self.mng_name, \"autoSetLOPowerLevel\", \"0\", 3)\n self.seq.add_param(self.mng_name, \"S4\", \"4\")\n self.seq.add_param(self.mng_name, \"S8\", \"5\")\n self.seq.add_param(self.mng_name, \"S12\", \"1\")","def _setup_loom_ops(self, named_ops):\n # Make a PassThroughOp for each TypeShape. Then set up mappings between\n # names, op indices and ops with the PassThrough ops having the same\n # indices as their type_shapes and no names.\n pass_through_ops = [PassThroughLoomOp(ts) for ts in self._type_shapes]\n\n non_passthrough_op_names = sorted(six.iterkeys(named_ops))\n\n # _loom_op_names: a list of names for all the ops (including autogenerated\n # names for the PassThroughLoomOps for debugging purposes.)\n #\n # The first len(self._type_shapes) ops are forced to be the passthrough ops\n # for the corresponding TypeShape. This is enforced in VerifyLoomMetadata.\n self._loom_op_names = (\n [self._pass_through_name(ts) for ts in self._type_shapes] +\n non_passthrough_op_names)\n\n # _loom_ops: a list of the supported LoomOps (including autogenerated\n # PassThroughOps)\n self._loom_ops = (\n pass_through_ops + [named_ops[k] for k in non_passthrough_op_names])\n\n # _loom_total_args: The sum of the number of arguments across all loom ops.\n self._loom_total_args = sum(\n len(op.input_type_shapes) for op in self._loom_ops)\n\n # _loom_op_name_to_idx: a dict mapping the names in '_op_names' back to into\n # indices usable with '_ops' and '_op_names'.\n self._loom_op_name_to_idx = {\n name: idx for idx, name in enumerate(self._loom_op_names)}","def get_lamp_specs(self):\n return {lamp: self._LAMP_SPECS[lamp] for lamp in self._available_lamps}","def turn_on(self, **kwargs: Any) -> None:\n commands = []\n _LOGGER.debug(\"light kwargs-> %s\", kwargs)\n\n if (\n DPCODE_LIGHT in self.tuya_device.status\n and DPCODE_SWITCH not in self.tuya_device.status\n ):\n commands += [{\"code\": DPCODE_LIGHT, \"value\": True}]\n else:\n commands += [{\"code\": DPCODE_SWITCH, \"value\": True}]\n\n if ATTR_BRIGHTNESS in kwargs:\n if self._work_mode().startswith(WORK_MODE_COLOUR):\n colour_data = self._get_hsv()\n v_range = self._tuya_hsv_v_range()\n colour_data[\"v\"] = int(\n self.remap(kwargs[ATTR_BRIGHTNESS], 0, 255, v_range[0], v_range[1])\n )\n commands += [\n {\"code\": self.dp_code_colour, \"value\": json.dumps(colour_data)}\n ]\n else:\n new_range = self._tuya_brightness_range()\n tuya_brightness = int(\n self.remap(\n kwargs[ATTR_BRIGHTNESS], 0, 255, new_range[0], new_range[1]\n )\n )\n commands += [{\"code\": self.dp_code_bright, \"value\": tuya_brightness}]\n\n if ATTR_HS_COLOR in kwargs:\n colour_data = self._get_hsv()\n # hsv h\n colour_data[\"h\"] = int(kwargs[ATTR_HS_COLOR][0])\n # hsv s\n ha_s = kwargs[ATTR_HS_COLOR][1]\n s_range = self._tuya_hsv_s_range()\n colour_data[\"s\"] = int(\n self.remap(\n ha_s,\n HSV_HA_SATURATION_MIN,\n HSV_HA_SATURATION_MAX,\n s_range[0],\n s_range[1],\n )\n )\n # hsv v\n ha_v = self.brightness\n v_range = self._tuya_hsv_v_range()\n colour_data[\"v\"] = int(self.remap(ha_v, 0, 255, v_range[0], v_range[1]))\n\n commands += [\n {\"code\": self.dp_code_colour, \"value\": json.dumps(colour_data)}\n ]\n if self.tuya_device.status[DPCODE_WORK_MODE] != \"colour\":\n commands += [{\"code\": DPCODE_WORK_MODE, \"value\": \"colour\"}]\n\n if ATTR_COLOR_TEMP in kwargs:\n # temp color\n new_range = self._tuya_temp_range()\n color_temp = self.remap(\n self.max_mireds - kwargs[ATTR_COLOR_TEMP] + self.min_mireds,\n self.min_mireds,\n self.max_mireds,\n new_range[0],\n new_range[1],\n )\n commands += [{\"code\": self.dp_code_temp, \"value\": int(color_temp)}]\n\n # brightness\n ha_brightness = self.brightness\n new_range = self._tuya_brightness_range()\n tuya_brightness = self.remap(\n ha_brightness, 0, 255, new_range[0], new_range[1]\n )\n commands += [{\"code\": self.dp_code_bright, \"value\": int(tuya_brightness)}]\n\n if self.tuya_device.status[DPCODE_WORK_MODE] != \"white\":\n commands += [{\"code\": DPCODE_WORK_MODE, \"value\": \"white\"}]\n\n self._send_command(commands)","def SetStandbyLPMode(self):\n handler = self.get_command_object(\"SetStandbyLPMode\")\n handler()","def process_cl_args():\n\n parser = argparse.ArgumentParser(add_help=False)\n parser.add_argument('commands', nargs='*')\n parser.add_argument('--help', '-h', action='store_true')\n parser.add_argument('--version', '-v', action='store_true')\n parser.add_argument('--debug', '-d', action='store_true')\n parser.add_argument('--logging', '-l', action='store_true')\n parser.add_argument('--no-autosize', action='store_true')\n parser.add_argument('--no-preload', action='store_true')\n args = parser.parse_args()\n\n if args.version:\n xprint(get_version_info())\n xprint(\"\")\n sys.exit()\n\n elif args.help:\n for x in helptext():\n xprint(x[2])\n sys.exit()\n\n if args.debug or os.environ.get(\"mpsytdebug\") == \"1\":\n xprint(get_version_info())\n g.debug_mode = True\n g.no_clear_screen = True\n logfile = os.path.join(tempfile.gettempdir(), \"mpsyt.log\")\n logging.basicConfig(level=logging.DEBUG, filename=logfile)\n logging.getLogger(\"pafy\").setLevel(logging.DEBUG)\n\n elif args.logging or os.environ.get(\"mpsytlog\") == \"1\":\n logfile = os.path.join(tempfile.gettempdir(), \"mpsyt.log\")\n logging.basicConfig(level=logging.DEBUG, filename=logfile)\n logging.getLogger(\"pafy\").setLevel(logging.DEBUG)\n\n if args.no_autosize:\n g.detectable_size = False\n\n g.command_line = \"playurl\" in args.commands or \"dlurl\" in args.commands\n if g.command_line:\n g.no_clear_screen = True\n\n if args.no_preload:\n g.preload_disabled = True\n\n g.argument_commands = args.commands","async def power_on(self) -> str:\n return f\"d2 lamp is {await self.hw_device.lamp('d2')}; halogen lamp is {await self.hw_device.lamp('hal')}\"","def Lvl1SimulationSequence( flags = None ):\n # for the New JO migration\n # from AthenaCommon.ComponentAccumulator import ComponentAccumulator\n # acc = ComponentAccumulator()\n # all tools then should be added to the acc, cond folders as well.\n # L1ConfigSvc CA has to be imported and merged\n # at the end the sequence added to the CA\n #\n from AthenaCommon.Logging import logging\n log = logging.getLogger('TriggerJobOpts.Lvl1Simulation')\n from AthenaConfiguration.ComponentAccumulator import conf2toConfigurable\n from AthenaCommon.CFElements import seqAND\n from AthenaCommon.AppMgr import ServiceMgr as svcMgr\n from AthenaCommon.AlgSequence import AthSequencer\n from TriggerJobOpts.TriggerFlags import TriggerFlags\n\n # this configuration of the LVL1ConfigSvc is only temporary\n TriggerFlags.readLVL1configFromXML = True\n TriggerFlags.outputLVL1configFile = None\n log.info(\"setting up LVL1ConfigSvc, including the menu generation\")\n from TrigConfigSvc.TrigConfigSvcCfg import getL1ConfigSvc\n svcMgr += conf2toConfigurable(getL1ConfigSvc(flags))\n\n ##################################################\n # Calo\n ##################################################\n\n if flags.Trigger.enableL1CaloLegacy:\n\n from TrigT1CaloSim.TrigT1CaloSimRun2Config import Run2TriggerTowerMaker\n caloTowerMaker = Run2TriggerTowerMaker(\"Run2TriggerTowerMaker25ns\")\n caloTowerMaker.ExtraInputs = [\"LArTTL1Container#LArTTL1EM\", \"LArTTL1Container#LArTTL1HAD\", \"TileTTL1Container#TileTTL1Cnt\" ]\n caloTowerMaker.ZeroSuppress = True\n caloTowerMaker.CellType = 3\n\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__Run2CPMTowerMaker\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__Run2JetElementMaker\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__CPMSim\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JEMJetSim\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JEMEnergySim\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__CPCMX\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JetCMX\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__EnergyCMX\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__RoIROD\n\n from TrigT1MBTS.TrigT1MBTSConf import LVL1__TrigT1MBTS\n from TrigT1ZDC.TrigT1ZDCConf import LVL1__TrigT1ZDC\n\n l1CaloSim = seqAND('l1CaloSim',[\n caloTowerMaker,\n #LVL1__Run2CPMTowerMaker( 'CPMTowerMaker', ExtraInputs=[\"XYZ#1\"], ExtraOutputs=[\"XYZ#2\"]) ,\n LVL1__Run2CPMTowerMaker( 'CPMTowerMaker') ,\n LVL1__Run2JetElementMaker( 'JetElementMaker'),\n LVL1__CPMSim( 'CPMSim' ) ,\n LVL1__JEMJetSim( 'JEMJetSim' ) ,\n LVL1__JEMEnergySim( 'JEMEnergySim' ) ,\n LVL1__CPCMX( 'CPCMX' ) ,\n LVL1__JetCMX( 'JetCMX' ) ,\n LVL1__EnergyCMX( 'EnergyCMX' ) ,\n LVL1__RoIROD( 'RoIROD' ),\n LVL1__TrigT1MBTS(),\n LVL1__TrigT1ZDC()\n ])\n\n from IOVDbSvc.CondDB import conddb\n L1CaloFolderList = []\n #L1CaloFolderList += [\"/TRIGGER/L1Calo/V1/Calibration/Physics/PprChanCalib\"]\n L1CaloFolderList += [\"/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib\"]\n #L1CaloFolderList += [\"/TRIGGER/L1Calo/V1/Conditions/RunParameters\"]\n #L1CaloFolderList += [\"/TRIGGER/L1Calo/V1/Conditions/DerivedRunPars\"]\n #L1CaloFolderList += [\"/TRIGGER/Receivers/Conditions/VgaDac\"]\n #L1CaloFolderList += [\"/TRIGGER/Receivers/Conditions/Strategy\"]\n L1CaloFolderList += [\"/TRIGGER/L1Calo/V2/Conditions/DisabledTowers\"]\n L1CaloFolderList += [\"/TRIGGER/L1Calo/V2/Calibration/PpmDeadChannels\"]\n L1CaloFolderList += [\"/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults\"]\n\n for l1calofolder in L1CaloFolderList:\n #conddb.addFolderWithTag(\"TRIGGER_OFL\", l1calofolder, \"HEAD\")\n conddb.addFolder( \"TRIGGER_OFL\", l1calofolder )\n\n ##################################################\n # Muons\n ##################################################\n \n from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigitTool\n MuonRdoToMuonDigitTool = MuonRdoToMuonDigitTool (DecodeMdtRDO = False,\n DecodeRpcRDO = True,\n DecodeTgcRDO = True,\n DecodeCscRDO = False,\n DecodeSTGC_RDO = False,\n DecodeMM_RDO = False,\n # for those subdetectors where the decoding is turned off, no need to create a RDO_Decoder ToolHandle\n mdtRdoDecoderTool=\"\",\n cscRdoDecoderTool=\"\",\n stgcRdoDecoderTool=\"\",\n mmRdoDecoderTool=\"\",\n RpcDigitContainer = \"RPC_DIGITS_L1\",\n TgcDigitContainer = \"TGC_DIGITS_L1\")\n \n MuonRdoToMuonDigitTool.cscCalibTool = \"CscCalibTool\"\n from AthenaCommon.AppMgr import ToolSvc\n ToolSvc += MuonRdoToMuonDigitTool\n\n from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigit\n from TrigT1RPCsteering.TrigT1RPCsteeringConf import TrigT1RPC \n from TrigT1TGC.TrigT1TGCConf import LVL1TGCTrigger__LVL1TGCTrigger\n\n TrigT1RPC.useRun3Config = flags.Trigger.enableL1Phase1\n LVL1TGCTrigger__LVL1TGCTrigger.useRun3Config = flags.Trigger.enableL1Phase1\n\n if flags.Trigger.enableL1Phase1:\n # Placeholder for phase-I MUCTPI simulation\n log.info(\"Configuring Phase-I MUCTPI simulation\")\n from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1\n from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1Tool\n\n ToolSvc += L1MuctpiPhase1Tool(\"MUCTPI_AthTool\")\n ToolSvc.MUCTPI_AthTool.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc\n\n muctpi = L1MuctpiPhase1()\n muctpi.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc\n\n else:\n log.info(\"Configuring legacy (Run 2) MUCTPI simulation\")\n from TrigT1Muctpi.TrigT1MuctpiConfig import L1Muctpi\n from TrigT1Muctpi.TrigT1MuctpiConfig import L1MuctpiTool\n\n ToolSvc += L1MuctpiTool(\"L1MuctpiTool\")\n ToolSvc.L1MuctpiTool.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc\n\n muctpi = L1Muctpi()\n muctpi.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc\n\n # Sets up and configures the muon alignment and detector manager\n from MuonRecExample import MuonAlignConfig # noqa: F401\n\n l1MuonSim = seqAND(\"l1MuonSim\", [\n \n MuonRdoToMuonDigit( \"MuonRdoToMuonDigit\",\n MuonRdoToMuonDigitTool = ToolSvc.MuonRdoToMuonDigitTool),\n\n TrigT1RPC(\"TrigT1RPC\",\n Hardware = True, # not sure if needed, not there in old config, present in JO\n DataDetail = False,\n RPCbytestream = False,\n RPCbytestreamFile = \"\",\n RPCDigitContainer = \"RPC_DIGITS_L1\"),\n \n # based on Trigger/TrigT1/TrigT1TGC/python/TrigT1TGCConfig.py\n # interesting is that this JO sets inexisting properties, commented out below\n LVL1TGCTrigger__LVL1TGCTrigger(\"LVL1TGCTrigger\",\n InputData_perEvent = \"TGC_DIGITS_L1\", \n MuCTPIInput_TGC = \"L1MuctpiStoreTGC\",\n MaskFileName12 = \"TrigT1TGCMaskedChannel._12.db\"),\n muctpi\n ])\n \n # only needed for MC\n conddb.addFolder(\"TGC_OFL\", \"/TGC/TRIGGER/CW_EIFI\", className=\"CondAttrListCollection\")\n conddb.addFolder(\"TGC_OFL\", \"/TGC/TRIGGER/CW_BW\", className=\"CondAttrListCollection\")\n conddb.addFolder(\"TGC_OFL\", \"/TGC/TRIGGER/CW_TILE\", className=\"CondAttrListCollection\")\n condSeq = AthSequencer(\"AthCondSeq\")\n from MuonCondSvc.MuonCondSvcConf import TGCTriggerDbAlg\n condSeq += TGCTriggerDbAlg()\n\n ##################################################\n # Topo\n ##################################################\n\n l1TopoSim = None\n if flags.Trigger.enableL1Phase1:\n log.info(\"No phase1 configuration for L1Topo simulation is available\")\n else:\n from L1TopoSimulation.L1TopoSimulationConfig import L1TopoSimulation\n l1TopoSim = L1TopoSimulation()\n\n l1TopoSim.MuonInputProvider.ROIBResultLocation = \"\" #disable input from RoIBResult\n l1TopoSim.MuonInputProvider.MuctpiSimTool = ToolSvc.L1MuctpiTool\n\n # enable the reduced (coarse) granularity topo simulation\n # currently only for MC\n from AthenaCommon.GlobalFlags import globalflags\n if globalflags.DataSource()!='data':\n l1TopoSim.MuonInputProvider.MuonEncoding = 1\n else:\n l1TopoSim.MuonInputProvider.MuonEncoding = 0\n\n ##################################################\n # CTP\n ##################################################\n\n from TrigT1CTP.TrigT1CTPConfig import CTPSimulationInReco\n ctp = CTPSimulationInReco(\"CTPSimulation\")\n ctp.DoLUCID = False\n ctp.DoBCM = False\n ctp.DoL1Topo = not flags.Trigger.enableL1Phase1\n ctp.UseCondL1Menu = False\n ctp.TrigConfigSvc = svcMgr.LVL1ConfigSvc\n ctpSim = seqAND(\"ctpSim\", [ctp])\n\n if flags.Trigger.enableL1CaloLegacy or not flags.Trigger.enableL1Phase1:\n from TrigT1RoIB.TrigT1RoIBConfig import RoIBuilder\n roib = RoIBuilder(\"RoIBuilder\")\n roib.DoCalo = flags.Trigger.enableL1CaloLegacy\n roib.DoMuon = not flags.Trigger.enableL1Phase1\n ctpSim += [roib]\n\n #l1Sim = seqAND(\"l1Sim\", [caloTowerMaker] )\n if l1TopoSim:\n l1Sim = seqAND(\"l1Sim\", [l1CaloSim, l1MuonSim, l1TopoSim, ctpSim] )\n else:\n l1Sim = seqAND(\"l1Sim\", [l1CaloSim, l1MuonSim, ctpSim] )\n\n return l1Sim","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def setEnabled(*args):","def turnLightingSystemOn():\n dislin.light('ON')","def set_opt_fuctions(self) -> None:\n self._ordered_opt_functions = self.get_rights()[1]","def arm_and_takeoff(aTargetAltitude):\n cmds = vehicle1.commands\n\n print(\" Clear any existing commands\")\n cmds.clear() \n\n # create command using mavlink mission command message \n # http://ardupilot.org/plane/docs/common-mavlink-mission-command-messages-mav_cmd.html#mav-cmd-nav-takeoff\n # param1=pitch angle at takeoff, param7=desired altitude\n cmds.add(Command(0,0,0, mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT, mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,\n 0, 0, 0, 0, 0, 0,\n home_lat, home_lon, aTargetAltitude)) # first command in the mission is ignored for some reason, see https://github.com/dronekit/dronekit-python/blob/source-system-filtering/examples/avoidance/avoidance-manytests-plane.py#L376\n \n cmds.add(Command( 0, 0, 0, \n mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT, \n mavutil.mavlink.MAV_CMD_NAV_TAKEOFF,\n 0, 0, 0, 0, 0, 0, 0, 0, aTargetAltitude))\n\n cmds.add(Command(0,0,0, mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT, mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,\n 0, 0, 0, 0, 0, 0,\n home_lat, home_lon, aTargetAltitude))\n\n print(\" Upload new commands to vehicle\")\n cmds.upload()\n\n print (\"Param: %s\" % vehicle1.parameters['ARMING_CHECK'])\n # Disable all arming checks since we are flying in sitl\n # vehicle1.parameters['ARMING_CHECK']=1\n \n\n print(\"Basic pre-arm checks\")\n # Don't let the user try to arm until autopilot is ready\n # If you need to disable the arming check,\n # just comment it with your own responsibility.\n while not vehicle1.is_armable:\n print(\" Waiting for vehicle to initialise...\")\n time.sleep(1)\n\n # Plane can only take of in auto-mode and with a mission loaded\n # while not vehicle1.mode == VehicleMode('AUTO'):\n # Set the vehicle into auto mode\n vehicle1.mode = VehicleMode(\"AUTO\")\n\n while not vehicle1.armed:\n print(\" Waiting for arming...\")\n vehicle1.armed = True\n time.sleep(1)\n print('Motor armed')\n\n print('System status: %s' % (vehicle1.system_status))\n \n print(\"Taking off!\")\n # vehicle1.groundspeed=200.0\n while True:\n print (\" Altitude: \", vehicle1.location.global_relative_frame.alt)\n print('System status: %s' % (vehicle1.system_status))\n #Break and return from function just below target altitude.\n if vehicle1.location.global_relative_frame.alt>=aTargetAltitude*0.95:\n print (\"Reached target altitude\")\n break\n time.sleep(1)","def definearguments(self, customparser):\n if not customparser:\n return\n\n self.cmdbase.add_login_arguments_group(customparser)\n self.options_argument_group(customparser)\n subcommand_parser = customparser.add_subparsers(dest=\"command\")\n default_parser = subcommand_parser.add_parser(\n \"default\",\n help=\"Obtain iLO management networking interface details and configure basic \"\n \"properties such as enablement/disablement, domain name servers, ipv4 and ipv6 \"\n \"networking configuration.\",\n formatter_class=RawDescriptionHelpFormatter,\n )\n default_parser.add_argument(\n \"--enable_nic\",\n dest=\"enable_nic\",\n help=\"Enable network interfaces. List each interface to be enabled by ID: \"\n \"Ex: ethernet --enable_nic 1,2,3. **Note**: Non-existent interfaces will be omitted from \"\n \"configuration.\",\n type=str,\n default=None,\n )\n default_parser.add_argument(\n \"--disable_nic\",\n dest=\"disable_nic\",\n help=\"Disable network interfaces. List each interface to be disabled by ID: \"\n \"Ex: ethernet --disable_nic 1,2,3. **Note**: Non-existent interfaces will be omitted from \"\n \"configuration.\",\n type=str,\n default=None,\n )\n default_parser.add_argument(\n \"--enable_vnic\",\n dest=\"enable_vnic\",\n help=\"\"\"Enable virtual network interfaces of management network.\n Ex: ethernet --enable_vnic\"\"\",\n action=\"store_true\",\n default=False,\n )\n default_parser.add_argument(\n \"--disable_vnic\",\n dest=\"disable_vnic\",\n help=\"\"\"Disable virtual network interfaces of management network.\n Ex: ethernet --disable_vnic\"\"\",\n action=\"store_true\",\n default=False,\n )\n default_parser.add_argument(\n \"--disable_enhanced_downloads\",\n dest=\"disable_enhanced_downloads\",\n help=\"\"\"Disable enhanced download for virtual media and firmware update.\n Ex: ethernet --disable_enhanced_downloads\"\"\",\n action=\"store_true\",\n default=False,\n )\n default_parser.add_argument(\n \"--enable_enhanced_downloads\",\n dest=\"enable_enhanced_downloads\",\n help=\"\"\"Enable enhanced download for virtual media and firmware update.\n Ex: ethernet --enable_enhanced_downloads\"\"\",\n action=\"store_true\",\n default=False,\n )\n default_parser.add_argument(\n \"--nameservers\",\n dest=\"nameservers\",\n help=\"Configure physical and shared management network interface domain name \"\n \"servers (DNS) in a list as follows: <DNS1> <DNS2> \"\n \"Ex: ethernet --nameservers 8.8.8.8,1.1.1.1, ethernet --nameservers dns_resolver1.aws.com, \"\n \"dns_resolver2.aws.com\",\n default=None,\n )\n default_parser.add_argument(\n \"--proxy\",\n dest=\"proxy\",\n type=str,\n help=\"Configure or clear proxy server for the network \"\n \"Ex:\\nTo set proxy\\nethernet --proxy http://proxy.abc.net:8080 or \\n\"\n \"To clear proxy settings\\n\"\n \"ethernet --proxy None\",\n default=None,\n )\n default_parser.add_argument(\n \"--network_ipv4\",\n dest=\"network_ipv4\",\n help=\"Configure physical and shared management network interface static IPv4 \"\n \"settings. Settings provided in a list as follows: \"\n \"<ipv4 address>, <ipv4 gateway>, <ipv4 network mask>. Ex: ethernet --network_ipv4 \"\n \"192.168.1.10, 192.168.1.1, 255.255.0.0\",\n default=None,\n )\n default_parser.add_argument(\n \"--network_ipv6\",\n dest=\"network_ipv6\",\n help=\"Configure physical and shared management network interface static IPv6 \"\n \"settings. Settings provided in a list as follows: \"\n \"<ipv6 address>, <ipv6 gateway>, <ipv6 network mask>. Ex: ethernet --network_ipv6 \"\n \"0:0:0:0:ffff:c0a8:10e, 0:0:0:0:0:ffff:c0a8:101, 64. **Note**: IPv6 network mask\"\n \"is restricted to '64' bits.\",\n default=None,\n )\n default_parser.add_argument(\n \"-j\",\n \"--json\",\n dest=\"json\",\n action=\"store_true\",\n help=\"Optionally include this flag if you wish to change the \"\n \"displayed output to JSON format.\",\n default=False,\n )\n self.cmdbase.add_login_arguments_group(default_parser)\n save_help = \"Save a Network Configuration.\"\n save_parser = subcommand_parser.add_parser(\n __subparsers__[0],\n help=save_help,\n description=\"{0}\\n\\texample: ethernet save\\n\\n\\tSave iLO ethernet network management interface \"\n \"settings to a non-default file name.\\n\\tEx: ethernet save -f networking.json\\n\\n\\tSave \"\n \"an encrypted iLO networking configuration file\\n\\texample: ethernet save --encryption \"\n \"<ENCRYPTION_KEY>\".format(save_help),\n formatter_class=RawDescriptionHelpFormatter,\n )\n self.cmdbase.add_login_arguments_group(save_parser)\n self.options_argument_group(save_parser)\n load_help = \"Load a Network Configuration.\"\n load_parser = subcommand_parser.add_parser(\n __subparsers__[1],\n help=load_help,\n description=\"{0}\\n\\texample: ethernet load\\n\\n\\tLoad iLO ethernet networking management interface \"\n \"settings from a non-default file name.\\n\\tEx: ethernet load -f \"\n \"networking.json\\n\\n\\tLoad an encrypted iLO networking configuration file\\n\\texample: \"\n \"ethernet load --encryption <ENCRYPTION KEY>\".format(load_help),\n formatter_class=RawDescriptionHelpFormatter,\n )\n self.cmdbase.add_login_arguments_group(load_parser)\n self.options_argument_group(load_parser)","def select_layers(m, enable, disable):\n for l in m.layers:\n if l.name in enable:\n l.active = True\n if l.name in disable:\n l.active = False","def disable_lldp_on_device_ports(self, ports=None):\n pass","def set_up_all_ao(self):\n self.set_as_active()\n \n # sets up ambient occlusion lighting\n self.set_up_world_ao()\n self.comp_add_ao()","def enable_cl1_pll1(self):\n self.write_versa5(0x17,0x02) ## Change top multiplier to 0x22\n self.write_versa5(0x18,0x20)\n self.write_versa5(0x10,0xc0) ## Enable xtal and clock\n self.write_versa5(0x13,0x03) ## Switch to clock\n self.write_versa5(0x10,0x40) ## Enable clock input only, won't lock to master","def on_off_action(speaker, action, args, soco_function, use_local_speaker_list):\n if action == \"group_mute\":\n speaker = speaker.group\n soco_function = \"mute\"\n np = len(args)\n if np == 0:\n state = \"on\" if getattr(speaker, soco_function) else \"off\"\n print(state)\n elif np == 1:\n arg = args[0].lower()\n if arg == \"on\":\n setattr(speaker, soco_function, True)\n elif arg == \"off\":\n setattr(speaker, soco_function, False)\n else:\n parameter_type_error(action, \"on|off\")\n return False\n return True","def setLaserPower(self,wavelength, power, job, seq=1):\n self.emptyCMDlist()\n\n c = \"/cli:python /app:matrix /sys:1 /cmd:adjustls /seq:\" + str(seq) + \" /exp:\" + job\n if int(wavelength) == 405:\n c += \" /lsq:uv /lid:405\"\n else:\n c += \" /lsq:vis /lid:\" + str(wavelength)\n c+= \" /tar:laser /value:\" + str(float(power))\n self.addtoCMDlist(c)\n self.sendCMDlist()","def list_rulesets(command):\n namespace = app.main(command)\n assert namespace.command == 'lr' or namespace.command == \"listrulesets\"","def l_action(option,opt_str,value,parser):\n boolean_option_action(option,opt_str,value,parser)\n from topo.misc.legacy import install_legacy_support\n print \"Enabling legacy support.\"\n install_legacy_support()","def connect_hooks():\n\n mc.refresh()\n\n if not mc.objExists('world_CTL'):\n return\n\n # Constrain ll hooks\n hook_node_attrs = mc.ls('*_'+utils.get_suffix('hook')+'.hookDriver')\n att_node_attrs = mc.ls('*_'+utils.get_suffix('attrDriver')+'.attrDriver')\n world_hook = mc.ls('*_worldRoot_*.allCtrlsVis')[0].split('.')[0]\n\n for attr in hook_node_attrs:\n print 'Connecting: '+attr\n\n driver = mc.ls(mc.getAttr(attr) or '')\n hook = attr.split('.')[0]\n\n if mc.getAttr(attr) and not driver:\n print ' \\t***Cannot find driver for : '+attr\n\n if not driver:\n continue\n\n # remove any contraints\n utils.set_attrs(hook, 't r s', k=1, l=0)\n cons = utils.get_constraints(hook)\n if cons:\n mc.delete(cons)\n\n # create new contraints on HOOK\n if mc.objExists(hook+'.connectXforms'):\n mc.connectAttr(driver[0]+'.t', hook+'.t')\n mc.connectAttr(driver[0]+'.r', hook+'.r')\n mc.connectAttr(driver[0]+'.s', hook+'.s')\n\n else:\n constraint.constraint_mtx(driver[0], hook)\n #mc.parentConstraint(driver[0], hook, mo=1)\n #mc.scaleConstraint(driver[0], hook, mo=1)\n\n # connect vis attrs to world nod\n hook_parents = utils.get_children('parts_'+utils.get_suffix('transform'))\n world_node = mc.ls('world_CTL')\n vis_node = mc.ls('visibility_CTL')\n\n utils.set_attrs(world_node[0], 'worldScale', l=1, k=0)\n\n attrs = ['allCtrlsVis', 'offsetCtrlsVis', 'jointsVis', 'jointsSelectable']\n\n if hook_parents and world_node:\n for hook_parent in hook_parents:\n for attr in attrs:\n mc.connectAttr(vis_node[0]+'.'+attr, hook_parent+'.'+attr)\n\n # recreate any attrs from hook nodes onto driver nodes\n driven_hooks = [a.split('.')[0] for a in hook_node_attrs+att_node_attrs]\n hook_drivers = [mc.getAttr(a) or '' for a in hook_node_attrs+att_node_attrs]\n ignore = ['isRequired', 'hookDriver', 'worldScale']\n\n for i, hook in enumerate(driven_hooks):\n driver = hook_drivers[i]\n\n if mc.objExists(hook):\n\n # copy attrs from original leg ctrl to new foot ctrl\n data = udAttributes.get_data(hook)\n if not data:\n continue\n\n if 'worldScale' in data[hook]['data'].keys():\n del data[hook]['data']['worldScale']\n\n if 'worldScale' in data[hook]['attr_order']:\n data[hook]['attr_order'].remove('worldScale')\n\n data[driver] = data[hook]\n if hook != driver:\n del data[hook]\n\n udAttributes.set_data(data, verbose=False)\n\n #drive ik leg ctrl attrs with foot ctrl\n attrs = data[driver]['attr_order']\n for attr in attrs:\n if attr not in ignore:\n try:\n mc.connectAttr(driver+'.'+attr, hook+'.'+attr)\n except:\n pass\n\n utils.break_connections('C_worldRoot_GRP', 'allCtrlsVis')\n utils.set_attrs(hook_parents, l=1, k=1)\n\n #hide no transforms\n mc.hide(mc.ls('noXform_'+utils.get_suffix('transform')))","def _add_lamp_outlets(self):\r\n lst = self.model.get_all_lamp_outlets()\r\n\r\n for itm in lst:\r\n self._add_lamp_outlet(itm)","def command(command_list):\n def add_attribute(func):\n if not hasattr(func, \"command\"):\n func.command = []\n func.command.append(command_list)\n return func\n return add_attribute","def modsToggle(self, connect=False, verbose=True):\n try:\n if self._mods_available:\n if connect: \n if verbose: self.logger.info('Enabling mods...')\n self.syslogger.info('Enabling mods...')\n self.sh('echo {} > {}'.format(CONFIG.DEVICE.MODS_ON_OFF['on'], CONFIG.DEVICE.MODS_PATH))\n self._mods_enabled = False\n else:\n if verbose: self.logger.info('Disabling mods...')\n self.syslogger.info('Disabling mods...')\n self.sh('echo {} > {}'.format(CONFIG.DEVICE.MODS_ON_OFF['off'], CONFIG.DEVICE.MODS_PATH))\n self._mods_enabled = False\n except Exception as e:\n self.logger.error('Mods connot be enabled/disabled: {}'.format(e), self.syslogger)","def lsextpool(self, args: str = \"\") -> List[str]:\n\n lsextpool_cmd = f\"{self.base_cmd} lsextpool {args}\"\n lsextpool_out = runsub.cmd(lsextpool_cmd)\n\n return lsextpool_out","def manipulator(self):\n manipulator = ConfigurationManipulator()\n \n num_options = len(self.passes)-1\n \n # choose for a sequence of at most `max_passes` passes\n for i in range(self.max_passes):\n passNum = 'pass_' + str(i)\n # some pass\n manipulator.add_parameter(IntegerParameter(passNum, 0, num_options))\n # and whether to turn it on or off\n manipulator.add_parameter(EnumParameter('enable_' + passNum, [True, False]))\n \n # choose from a set of knobs\n for knob, minInt, maxInt in self.knobs:\n manipulator.add_parameter(IntegerParameter(knob, minInt, maxInt))\n manipulator.add_parameter(EnumParameter('enable_' + knob, [True, False]))\n \n return manipulator","def set_light_mode(self, is_lid):\n raise NotImplementedError()","def enable_automations(self):\n for sound in self.sounds_and_channels:\n for auto in self.sounds_and_channels[sound].automation_blocks:\n logging.debug(\"Attaching automation %s to sound %s\" % (auto, sound))\n # give each automation a known unique name\n self.attach_automation(sound, auto, \"%s_%s\" % (auto, self.unique_name()))","def before_unlock_actions(self):\n for command in self.before_unlock_commands:\n addr = command[\"address\"]\n prop = command[\"property\"]\n if len(command[\"argument\"]) == 0:\n arg = [0]\n else:\n try:\n arg = [eval(command[\"argument\"])]\n except:\n arg = [command[\"argument\"]]\n if command[\"type\"] == \"set\":\n tine.set(addr, prop, arg)\n elif command[\"type\"] == \"query\":\n tine.query(addr, prop, arg[0])","def intial_configuration():\n print(('You will be asked a few questions to configure latools\\n'\n 'for your specific laboratory needs.'))\n lab_name = input('What is the name of your lab? : ')\n\n params = {}\n OK = False\n while ~OK:\n srmfile = input('Where is your SRM.csv file? [blank = default] : ')\n if srmfile != '':\n if os.path.exists(srmfile):\n params['srmfile'] = srmfile\n OK = True\n else:\n print((\"You told us the SRM data file was at: \" + semfile +\n \"\\nlatools can't find that file. Please check it \"\n \"exists, and \\ncheck that the path was correct. \"\n \"The file path must be complete, not relative.\"))\n else:\n print((\"No path provided. Using default GeoRem values for \"\n \"NIST610, NIST612 and NIST614.\"))\n OK = True\n\n OK = False\n\n while ~OK:\n dataformatfile = input(('Where is your dataformat.dict file? '\n '[blank = default] : '))\n if dataformatfile != '':\n if os.path.exists(dataformatfile):\n params['srmfile'] = dataformatfile\n OK = True\n else:\n print((\"You told us the dataformat file was at: \" +\n dataformatfile + \"\\nlatools can't find that file. \"\n \"Please check it exists, and \\ncheck that the path \"\n \"was correct. The file path must be complete, not \"\n \"relative.\"))\n else:\n print((\"No path provided. Using default dataformat \"\n \"for the UC Davis Agilent 7700.\"))\n OK = True\n\n make_default = input(('Do you want to use these files as your '\n 'default? [Y/n] : ')).lower() != 'n'\n\n add_config(lab_name, params, make_default=make_default)\n\n print(\"\\nConfiguration set. You're good to go!\")\n\n return","def CommandLineMode(self):\n for var in COMMAND_CONFIG:\n self.Cover(var, COMMAND_CONFIG[var], layer = COMMAND_LINE_LAYER)","def export_lights(lamps, file, scene, global_matrix, tab_write):\n\n from .render import write_matrix, tab_write\n\n # Incremented after each lamp export to declare its target\n # currently used for Fresnel diffuse shader as their slope vector:\n global exported_lights_count\n # Get all lamps and keep their count in a global variable\n for exported_lights_count, ob in enumerate(lamps, start=1):\n lamp = ob.data\n\n matrix = global_matrix @ ob.matrix_world\n\n # Color is no longer modified by energy\n # any way to directly get bpy_prop_array as tuple?\n color = tuple(lamp.color)\n\n tab_write(file, \"light_source {\\n\")\n tab_write(file, \"< 0,0,0 >\\n\")\n tab_write(file, \"color srgb<%.3g, %.3g, %.3g>\\n\" % color)\n\n if lamp.type == \"POINT\":\n pass\n elif lamp.type == \"SPOT\":\n tab_write(file, \"spotlight\\n\")\n\n # Falloff is the main radius from the centre line\n tab_write(file, \"falloff %.2f\\n\" % (degrees(lamp.spot_size) / 2.0)) # 1 TO 179 FOR BOTH\n tab_write(\n file, \"radius %.6f\\n\" % ((degrees(lamp.spot_size) / 2.0) * (1.0 - lamp.spot_blend))\n )\n\n # Blender does not have a tightness equivalent, 0 is most like blender default.\n tab_write(file, \"tightness 0\\n\") # 0:10f\n\n tab_write(file, \"point_at <0, 0, -1>\\n\")\n if lamp.pov.use_halo:\n tab_write(file, \"looks_like{\\n\")\n tab_write(file, \"sphere{<0,0,0>,%.6f\\n\" % lamp.distance)\n tab_write(file, \"hollow\\n\")\n tab_write(file, \"material{\\n\")\n tab_write(file, \"texture{\\n\")\n tab_write(file, \"pigment{rgbf<1,1,1,%.4f>}\\n\" % (lamp.pov.halo_intensity * 5.0))\n tab_write(file, \"}\\n\")\n tab_write(file, \"interior{\\n\")\n tab_write(file, \"media{\\n\")\n tab_write(file, \"emission 1\\n\")\n tab_write(file, \"scattering {1, 0.5}\\n\")\n tab_write(file, \"density{\\n\")\n tab_write(file, \"spherical\\n\")\n tab_write(file, \"color_map{\\n\")\n tab_write(file, \"[0.0 rgb <0,0,0>]\\n\")\n tab_write(file, \"[0.5 rgb <1,1,1>]\\n\")\n tab_write(file, \"[1.0 rgb <1,1,1>]\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n elif lamp.type == \"SUN\":\n tab_write(file, \"parallel\\n\")\n tab_write(file, \"point_at <0, 0, -1>\\n\") # *must* be after 'parallel'\n\n elif lamp.type == \"AREA\":\n tab_write(file, \"fade_distance %.6f\\n\" % (lamp.distance / 2.0))\n # Area lights have no falloff type, so always use blenders lamp quad equivalent\n # for those?\n tab_write(file, \"fade_power %d\\n\" % 2)\n size_x = lamp.size\n samples_x = lamp.pov.shadow_ray_samples_x\n if lamp.shape == \"SQUARE\":\n size_y = size_x\n samples_y = samples_x\n else:\n size_y = lamp.size_y\n samples_y = lamp.pov.shadow_ray_samples_y\n\n tab_write(\n file,\n \"area_light <%.6f,0,0>,<0,%.6f,0> %d, %d\\n\"\n % (size_x, size_y, samples_x, samples_y),\n )\n tab_write(file, \"area_illumination\\n\")\n if lamp.pov.shadow_ray_sample_method == \"CONSTANT_JITTERED\":\n if lamp.pov.use_jitter:\n tab_write(file, \"jitter\\n\")\n else:\n tab_write(file, \"adaptive 1\\n\")\n tab_write(file, \"jitter\\n\")\n\n # No shadow checked either at global or light level:\n if not scene.pov.use_shadows or (lamp.pov.shadow_method == \"NOSHADOW\"):\n tab_write(file, \"shadowless\\n\")\n\n # Sun shouldn't be attenuated. Area lights have no falloff attribute so they\n # are put to type 2 attenuation a little higher above.\n if lamp.type not in {\"SUN\", \"AREA\"}:\n if lamp.falloff_type == \"INVERSE_SQUARE\":\n tab_write(file, \"fade_distance %.6f\\n\" % (sqrt(lamp.distance / 2.0)))\n tab_write(file, \"fade_power %d\\n\" % 2) # Use blenders lamp quad equivalent\n elif lamp.falloff_type == \"INVERSE_LINEAR\":\n tab_write(file, \"fade_distance %.6f\\n\" % (lamp.distance / 2.0))\n tab_write(file, \"fade_power %d\\n\" % 1) # Use blenders lamp linear\n elif lamp.falloff_type == \"CONSTANT\":\n tab_write(file, \"fade_distance %.6f\\n\" % (lamp.distance / 2.0))\n tab_write(file, \"fade_power %d\\n\" % 3)\n # Use blenders lamp constant equivalent no attenuation.\n # Using Custom curve for fade power 3 for now.\n elif lamp.falloff_type == \"CUSTOM_CURVE\":\n tab_write(file, \"fade_power %d\\n\" % 4)\n\n write_matrix(file, matrix)\n\n tab_write(file, \"}\\n\")\n\n # v(A,B) rotates vector A about origin by vector B.\n file.write(\n \"#declare lampTarget%s= vrotate(<%.4g,%.4g,%.4g>,<%.4g,%.4g,%.4g>);\\n\"\n % (\n exported_lights_count,\n -ob.location.x,\n -ob.location.y,\n -ob.location.z,\n ob.rotation_euler.x,\n ob.rotation_euler.y,\n ob.rotation_euler.z,\n )\n )","def run_all_steps(self, *args, **kwargs):\n\n # the following configopts are common to all builds\n if self.toolchain.options['pic']:\n self.cfg.update('configopts', '--with-pic')\n\n if self.cfg['with_shared']:\n self.cfg.update('configopts', '--enable-shared')\n\n if self.cfg['with_generic_kernel']:\n self.cfg.update('configopts', '--enable-generic')\n\n if self.cfg['with_single']:\n self.cfg.update('configopts', '--enable-single-precision')\n\n for flag in ELPA_CPU_FEATURE_FLAGS:\n # many ELPA kernels are enabled by default, even when the\n # CPU does not support them, so we disable them all, except\n # when the appropriate CPU flag is found\n # sse kernels require sse4_2\n if flag == 'sse4_2':\n if getattr(self, flag):\n self.cfg.update('configopts','--enable-sse')\n self.cfg.update('configopts', '--enable-sse-assembly')\n else:\n self.cfg.update('configopts', '--disable-sse')\n self.cfg.update('configopts', '--disable-sse-assembly')\n elif flag == 'avx512f':\n if getattr(self, 'avx512f'):\n self.cfg.update('configopts', '--enable-avx512')\n else:\n self.cfg.update('configopts', '--disable-avx512')\n else:\n if getattr(self, flag):\n self.cfg.update('configopts', '--enable-%s' % flag)\n else:\n self.cfg.update('configopts', '--disable-%s' % flag)\n\n # By default ELPA tries to use MPI and configure fails if it's not available\n # so we turn off MPI support unless MPI support is requested via the usempi toolchain option.\n # We also set the LIBS environmet variable to detect the correct linalg library\n # depending on the MPI availability.\n if self.toolchain.options.get('usempi', None):\n self.cfg.update('configopts', '--with-mpi=yes')\n self.cfg.update('configopts', 'LIBS=\"$LIBSCALAPACK\"')\n else:\n self.cfg.update('configopts', '--with-mpi=no')\n self.cfg.update('configopts', 'LIBS=\"$LIBLAPACK\"')\n\n self.cfg.update('configopts', 'LDFLAGS=\"-L${EBROOTZLIB}/lib -L${EBROOTLIBXML2}/lib -lxml2 -lz\"')\n\n # make all builds verbose\n self.cfg.update('buildopts', 'V=1')\n\n # keep track of common configopts specified in easyconfig file,\n # so we can include them in each iteration later\n common_config_opts = self.cfg['configopts']\n\n self.cfg['configopts'] = []\n\n self.cfg.update('configopts', ['--disable-openmp ' + common_config_opts])\n if self.toolchain.options.get('openmp', False):\n self.cfg.update('configopts', ['--enable-openmp ' + common_config_opts])\n\n self.log.debug(\"List of configure options to iterate over: %s\", self.cfg['configopts'])\n\n return super(EB_ELPA, self).run_all_steps(*args, **kwargs)","def run_lap():\n pass","def turn_on(self, **kwargs):\n self.smartplug.turn_on()","async def disable_platforms(hass: HomeAssistant) -> None:\n with patch(\n \"homeassistant.components.demo.COMPONENTS_WITH_CONFIG_ENTRY_DEMO_PLATFORM\",\n [],\n ):\n yield","def set_pulse_on_hit_and_release_and_disable_rule(self, enable_switch: SwitchSettings,\n eos_switch: SwitchSettings, coil: DriverSettings,\n repulse_settings: Optional[RepulseSettings]):\n raise NotImplementedError","def set_com_pins_config(set_sequential, enable_remap):\n if set_sequential:\n a4bit = 0x00\n else:\n a4bit = 0x10\n\n if enable_remap:\n a5bit = 0x20\n else:\n a5bit = 0x00\n\n send_command(0xDA)\n send_command(0x02 | a4bit | a5bit)","def wayland_environment(outputs):\n env = wlr_env.copy()\n env[\"WLR_HEADLESS_OUTPUTS\"] = str(outputs)\n yield env","def _setup_output_hook_and_backward_opt_barrier_lists(self) -> None:\n assert self._is_root, \"This should only be called on the root\"\n self._output_pre_backward_hook_registered = set()\n self._backward_opt_barrier_tensors = []\n self._backward_opt_barrier_tensor_ids = set()\n for n, m in self.named_modules():\n if n != \"\" and isinstance(m, XlaFullyShardedDataParallel):\n m._output_pre_backward_hook_registered = self._output_pre_backward_hook_registered\n m._backward_opt_barrier_tensors = self._backward_opt_barrier_tensors\n m._backward_opt_barrier_tensor_ids = self._backward_opt_barrier_tensor_ids","def main():\n namelst = open('cor_lamp.lst').readlines()\n namelst = ['awftbo'+i.strip() for i in namelst]\n for name in namelst:\n cor_keyword(name)\n func.set_airmass(name)","def EnableOAM(self, *args, **kwargs):\n # type: (*Any, **Any) -> None\n payload = { \"Arg1\": self }\n for i in range(len(args)): payload['Arg%s' % (i + 2)] = args[i]\n for item in kwargs.items(): payload[item[0]] = item[1]\n return self._execute('enableOAM', payload=payload, response_object=None)","def getTools(self):\n return [self.toggleEditMode]","def toggle_lights(bridge):\n if check_any_light_on(bridge):\n turn_off_lights(bridge)\n else:\n turn_on_lights(bridge)","def set_pulse_on_hit_and_enable_and_release_and_disable_rule(self, enable_switch: SwitchSettings,\n eos_switch: SwitchSettings, coil: DriverSettings,\n repulse_settings: Optional[RepulseSettings]):\n raise NotImplementedError","def off(self):\n self.state = \"OFF\"\n logger.info(\"Turning off %s lamp at %s port %s plug %s\" % (self.name,\n self.host,\n self.port,\n self.plug))\n return self.send_cmd(\"pset %s 0\" % self.plug)","def setup_platform(hass, config, add_entities, discovery_info=None):\n locks = []\n if int(hub.config.get(CONF_LOCKS, 1)):\n hub.update_overview()\n locks.extend(\n [\n VerisureDoorlock(device_label)\n for device_label in hub.get(\"$.doorLockStatusList[*].deviceLabel\")\n ]\n )\n\n add_entities(locks)","def arm_and_takeoff():\n\n print \"Basic pre-arm checks\"\n # Don't let the user try to arm until autopilot is ready\n while not vehicle.is_armable:\n print \" Waiting for vehicle to initialise...\"\n time.sleep(1)\n\n print \"Arming motors\"\n # Copter should arm in GUIDED mode\n vehicle.mode = VehicleMode(\"GUIDED\")\n vehicle.armed = True\n\n while not vehicle.armed:\n print \" Waiting for arming...\"\n time.sleep(1)","def stopAllMotors():\n return RoboCaller().call(\"stopAllMotors\", \"void\")","def rules():\n head()\n print(\"\\33[1m*--- How to play ---*\\033[0m\\n\")\n print(\"The following command allows to control the direction of the \"\n \"robot.\\n\")\n for i in LIST_DIRECTION[:4]:\n print(\"To the {}\".format(i))\n print(\"\\nYou can also move add the number of move to do in the same \"\n \"direction by adding a number from 0 to 9 after the direction:\\n\")\n print(\"Examples: S9 - N2 - E0 (Useless but you are a free robot)\\n\\n\")\n input(\"Press ENTER to continue ...\")","def setup_fourCtrl(lf_lidrails, rt_lidrails):\n # Declare control variables\n lf_up = ['L_upperLid1_ctrl', 'L_upperLid2_ctrl', 'L_upperLid3_ctrl', 'L_upperLid4_ctrl']\n lf_dn = ['L_lowerLid1_ctrl', 'L_lowerLid2_ctrl', 'L_lowerLid3_ctrl', 'L_lowerLid4_ctrl']\n rt_up = ['R_upperLid1_ctrl', 'R_upperLid2_ctrl', 'R_upperLid3_ctrl', 'R_upperLid4_ctrl']\n rt_dn = ['R_lowerLid1_ctrl', 'R_lowerLid2_ctrl', 'R_lowerLid3_ctrl', 'R_lowerLid4_ctrl']\n\n # Connect lidRails ramps to lid profile controls\n\n # lf_up =========\n\n # inner\n cmds.connectAttr(lf_up[0] + '.tx', lf_lidrails + '.offsettop[0].offsettop_Position', f=True)\n cmds.connectAttr(lf_up[0] + '.ty', lf_lidrails + '.offsettop[0].offsettop_FloatValue', f=True)\n # mid - inner\n lf_lid01_um01_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_um01_addDoubleLinear')\n cmds.connectAttr(lf_up[1] + '.tx', lf_lid01_um01_adn + '.input1', f=True)\n cmds.setAttr(lf_lid01_um01_adn + '.input2', 0.333)\n cmds.connectAttr(lf_lid01_um01_adn + '.output', lf_lidrails + '.offsettop[1].offsettop_Position', f=True)\n cmds.connectAttr(lf_up[1] + '.ty', lf_lidrails + '.offsettop[1].offsettop_FloatValue', f=True)\n # mid - outer\n lf_lid01_um02_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_um02_addDoubleLinear')\n cmds.connectAttr(lf_up[2] + '.tx', lf_lid01_um02_adn + '.input1', f=True)\n cmds.setAttr(lf_lid01_um02_adn + '.input2', 0.666)\n cmds.connectAttr(lf_lid01_um02_adn + '.output', lf_lidrails + '.offsettop[2].offsettop_Position', f=True)\n cmds.connectAttr(lf_up[2] + '.ty', lf_lidrails + '.offsettop[2].offsettop_FloatValue', f=True)\n # outer\n lf_lid01_uo01_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_uo01_addDoubleLinear')\n cmds.connectAttr(lf_up[3] + '.tx', lf_lid01_uo01_adn + '.input1', f=True)\n cmds.setAttr(lf_lid01_uo01_adn + '.input2', 1.0)\n cmds.connectAttr(lf_lid01_uo01_adn + '.output', lf_lidrails + '.offsettop[3].offsettop_Position', f=True)\n cmds.connectAttr(lf_up[3] + '.ty', lf_lidrails + '.offsettop[3].offsettop_FloatValue', f=True)\n\n # lf_dn =========\n\n lf_dn_rvn = cmds.createNode('reverse', n='lf_lid01_dn01_reverse')\n lf_dn02_rvn = cmds.createNode('reverse', n='lf_lid01_dn02_reverse')\n # inner\n cmds.connectAttr(lf_dn[0] + '.tx', lf_lidrails + '.offsetbottom[0].offsetbottom_Position', f=True)\n cmds.connectAttr(lf_dn[0] + '.ty', lf_dn_rvn + '.inputX', f=True)\n cmds.connectAttr(lf_dn_rvn + '.outputX', lf_lidrails + '.offsetbottom[0].offsetbottom_FloatValue', f=True)\n # mid - inner\n lf_lid01_dm01_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_dm01_addDoubleLinear')\n cmds.connectAttr(lf_dn[1] + '.tx', lf_lid01_dm01_adn + '.input1', f=True)\n cmds.setAttr(lf_lid01_dm01_adn + '.input2', 0.333)\n cmds.connectAttr(lf_lid01_dm01_adn + '.output', lf_lidrails + '.offsetbottom[1].offsetbottom_Position', f=True)\n cmds.connectAttr(lf_dn[1] + '.ty', lf_dn_rvn + '.inputY', f=True)\n cmds.connectAttr(lf_dn_rvn + '.outputY', lf_lidrails + '.offsetbottom[1].offsetbottom_FloatValue', f=True)\n # mid - outer\n lf_lid01_dm02_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_dm02_addDoubleLinear')\n cmds.connectAttr(lf_dn[2] + '.tx', lf_lid01_dm02_adn + '.input1', f=True)\n cmds.setAttr(lf_lid01_dm02_adn + '.input2', 0.666)\n cmds.connectAttr(lf_lid01_dm02_adn + '.output', lf_lidrails + '.offsetbottom[2].offsetbottom_Position', f=True)\n cmds.connectAttr(lf_dn[2] + '.ty', lf_dn02_rvn + '.inputX', f=True)\n cmds.connectAttr(lf_dn02_rvn + '.outputX', lf_lidrails + '.offsetbottom[2].offsetbottom_FloatValue', f=True)\n # outer\n lf_lid01_do01_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_do01_addDoubleLinear')\n cmds.connectAttr(lf_dn[3] + '.tx', lf_lid01_do01_adn + '.input1', f=True)\n cmds.setAttr(lf_lid01_do01_adn + '.input2', 1.0)\n cmds.connectAttr(lf_lid01_do01_adn + '.output', lf_lidrails + '.offsetbottom[3].offsetbottom_Position', f=True)\n cmds.connectAttr(lf_dn[3] + '.ty', lf_dn02_rvn + '.inputY')\n cmds.connectAttr(lf_dn02_rvn + '.outputY', lf_lidrails + '.offsetbottom[3].offsetbottom_FloatValue', f=True)\n\n # rt_up =========\n\n # inner\n rt_lid01_ui01_asn = cmds.createNode('plusMinusAverage', n='rt_lid01_ui01_plusMinusAverage')\n cmds.setAttr(rt_lid01_ui01_asn + '.input1D[0]', 1.0)\n cmds.connectAttr(rt_up[0] + '.tx', rt_lid01_ui01_asn + '.input1D[1]', f=True)\n cmds.connectAttr(rt_lid01_ui01_asn + '.output1D', rt_lidrails + '.offsettop[3].offsettop_Position', f=True)\n cmds.connectAttr(rt_up[0] + '.ty', rt_lidrails + '.offsettop[3].offsettop_FloatValue', f=True)\n # mid -inner\n rt_lid01_um01_mdn = cmds.createNode('multDoubleLinear', n='rt_lid01_um01_multDoubleLinear')\n rt_lid01_um01_adn = cmds.createNode('addDoubleLinear', n='rt_lid01_um01_addDoubleLinear')\n cmds.connectAttr(rt_up[2] + '.tx', rt_lid01_um01_mdn + '.input1', f=True)\n cmds.setAttr(rt_lid01_um01_mdn + '.input2', -1.0)\n cmds.connectAttr(rt_lid01_um01_mdn + '.output', rt_lid01_um01_adn + '.input1', f=True)\n cmds.setAttr(rt_lid01_um01_adn + '.input2', 0.333)\n cmds.connectAttr(rt_lid01_um01_adn + '.output', rt_lidrails + '.offsettop[2].offsettop_Position', f=True)\n cmds.connectAttr(rt_up[2] + '.ty', rt_lidrails + '.offsettop[2].offsettop_FloatValue', f=True)\n\n # mid - outer\n rt_lid01_um02_mdn = cmds.createNode('multDoubleLinear', n='rt_lid01_um02_multDoubleLinear')\n rt_lid01_um02_adn = cmds.createNode('addDoubleLinear', n='rt_lid01_um02_addDoubleLinear')\n cmds.connectAttr(rt_up[1] + '.tx', rt_lid01_um02_mdn + '.input1', f=True)\n cmds.setAttr(rt_lid01_um02_mdn + '.input2', -1.0)\n cmds.connectAttr(rt_lid01_um02_mdn + '.output', rt_lid01_um02_adn + '.input1', f=True)\n cmds.setAttr(rt_lid01_um02_adn + '.input2', 0.666)\n cmds.connectAttr(rt_lid01_um02_adn + '.output', rt_lidrails + '.offsettop[1].offsettop_Position', f=True)\n cmds.connectAttr(rt_up[1] + '.ty', rt_lidrails + '.offsettop[1].offsettop_FloatValue', f=True)\n\n # outer\n rt_lid01_uo_mdn = cmds.createNode('multDoubleLinear', n='rt_lid01_uo_multDoubleLinear')\n cmds.connectAttr(rt_up[3] + '.tx', rt_lid01_uo_mdn + '.input1', f=True)\n cmds.setAttr(rt_lid01_uo_mdn + '.input2', -1.0)\n cmds.connectAttr(rt_lid01_uo_mdn + '.output', rt_lidrails + '.offsettop[0].offsettop_Position', f=True)\n cmds.connectAttr(rt_up[3] + '.ty', rt_lidrails + '.offsettop[0].offsettop_FloatValue', f=True)\n\n # rt_dn =========\n\n rt_dn_rvn = cmds.createNode('reverse', n='rt_lid01_dn01_reverse')\n rt_dn02_rvn = cmds.createNode('reverse', n='rt_lid01_dn02_reverse')\n # inner\n rt_lid01_di01_asn = cmds.createNode('plusMinusAverage', n='rt_lid01_di01_plusMinusAverage')\n cmds.setAttr(rt_lid01_di01_asn + '.operation', 2)\n cmds.setAttr(rt_lid01_di01_asn + '.input1D[0]', 1.0)\n cmds.connectAttr(rt_dn[0] + '.tx', rt_lid01_di01_asn + '.input1D[1]', f=True)\n cmds.connectAttr(rt_lid01_di01_asn + '.output1D', rt_lidrails + '.offsetbottom[0].offsetbottom_Position', f=True)\n cmds.connectAttr(rt_dn[0] + '.ty', rt_dn_rvn + '.inputX', f=True)\n cmds.connectAttr(rt_dn_rvn + '.outputX', rt_lidrails + '.offsetbottom[0].offsetbottom_FloatValue', f=True)\n # mid - inner\n rt_lid01_dm01_asn = cmds.createNode('plusMinusAverage', n='rt_lid01_dm01_plusMinusAverage')\n cmds.setAttr(rt_lid01_dm01_asn + '.operation', 2)\n cmds.setAttr(rt_lid01_dm01_asn + '.input1D[0]', 0.333)\n cmds.connectAttr(rt_dn[2] + '.tx', rt_lid01_dm01_asn + '.input1D[1]', f=True)\n cmds.connectAttr(rt_lid01_dm01_asn + '.output1D', rt_lidrails + '.offsetbottom[1].offsetbottom_Position', f=True)\n cmds.connectAttr(rt_dn[2] + '.ty', rt_dn_rvn + '.inputY', f=True)\n cmds.connectAttr(rt_dn_rvn + '.outputY', rt_lidrails + '.offsetbottom[1].offsetbottom_FloatValue', f=True)\n # mid - outer\n rt_lid01_dm02_asn = cmds.createNode('plusMinusAverage', n='rt_lid01_dm02_plusMinusAverage')\n cmds.setAttr(rt_lid01_dm02_asn + '.operation', 2)\n cmds.setAttr(rt_lid01_dm02_asn + '.input1D[0]', 0.666)\n cmds.connectAttr(rt_dn[1] + '.tx', rt_lid01_dm02_asn + '.input1D[1]', f=True)\n cmds.connectAttr(rt_lid01_dm02_asn + '.output1D', rt_lidrails + '.offsetbottom[2].offsetbottom_Position', f=True)\n cmds.connectAttr(rt_dn[1] + '.ty', rt_dn02_rvn + '.inputX', f=True)\n cmds.connectAttr(rt_dn02_rvn + '.outputX', rt_lidrails + '.offsetbottom[2].offsetbottom_FloatValue', f=True)\n # outer\n rt_lid01_do01_mdn = cmds.createNode('multDoubleLinear', n='rt_lid01_do01_multDoubleLinear')\n cmds.connectAttr(rt_dn[3] + '.tx', rt_lid01_do01_mdn + '.input1', f=True)\n cmds.setAttr(rt_lid01_do01_mdn + '.input2', -1.0)\n cmds.connectAttr(rt_lid01_do01_mdn + '.output', rt_lidrails + '.offsetbottom[3].offsetbottom_Position', f=True)\n cmds.connectAttr(rt_dn[3] + '.ty', rt_dn02_rvn + '.inputY', f=True)\n cmds.connectAttr(rt_dn02_rvn + '.outputY', rt_lidrails + '.offsetbottom[3].offsetbottom_FloatValue')","def _activate_IR(self):\n self.IR_threshold = 2000\n\n self.IR_sensors = [self.getLightSensor('ls' + str(i)) for i in range(self.num_light_sensors)]\n map((lambda s: s.enable(self.timestep)), self.IR_sensors) # Enable all distance sensors","def run(self, outlets):\n self.logger.info(\"Turning on Power Outlet(s): {0}\".format(outlets))\n outlets = self._clean_outlets(outlets)\n try:\n self.naxxx.turn_on_switches(outlets, turn_others_off=True)\n except (TypeError, timeout) as error:\n self.logger.error(error)\n raise NaxxxError(\"Unable to connect to the Naxxx - check your LAN connection.\")\n return","def __init__(self):\n self.label = \"Data Assistant\"\n self.alias = \"dla\"\n\n # List of tool classes associated with this toolbox\n self.tools = [Append, Stage, NewFile, Preview, Replace]","def set_switches_from_rule_nbr(self):\n for rule_switch, enabled in zip(CA_World.bin_0_to_7, self.int_to_8_bit_binary(self.rule_nbr)):\n SimEngine.gui_set(rule_switch, value=(True if enabled=='1' else False))","def add_automl_args(argparser, arch_choices=None, enable_pretrained=False):\n argparser.add_argument('--amc', dest='AMC', action='store_true', help='AutoML Compression')\n group = argparser.add_argument_group('AutoML Compression Arguments')\n group.add_argument('--amc-protocol', choices=[\"mac-constrained\",\n \"param-constrained\",\n \"accuracy-guaranteed\",\n \"mac-constrained-experimental\"],\n default=\"mac-constrained\", help='Compression-policy search protocol')\n group.add_argument('--amc-ft-epochs', type=int, default=1,\n help='The number of epochs to fine-tune each discovered network')\n group.add_argument('--amc-save-chkpts', action='store_true', default=False,\n help='Save checkpoints of all discovered networks')\n group.add_argument('--amc-action-range', type=float, nargs=2, default=[0.0, 0.80],\n help='Density action range (a_min, a_max)')\n group.add_argument('--amc-heatup-epochs', type=int, default=100,\n help='The number of epochs for heatup/exploration')\n group.add_argument('--amc-training-epochs', type=int, default=300,\n help='The number of epochs for training/exploitation')\n group.add_argument('--amc-reward-frequency', type=int, default=None,\n help='Reward computation frequency (measured in agent steps)')\n group.add_argument('--amc-target-density', type=float,\n help='Target density of the network we are seeking')\n group.add_argument('--amc-agent-algo', choices=[\"ClippedPPO-continuous\",\n \"ClippedPPO-discrete\",\n \"DDPG\",\n \"Random-policy\"],\n default=\"ClippedPPO-continuous\",\n help=\"The agent algorithm to use\")\n # group.add_argument('--amc-thinning', action='store_true', default=False,\n # help='Perform netowrk thinning after altering each layer')\n group.add_argument('--amc-ft-frequency', type=int, default=None,\n help='How many action-steps between fine-tuning.\\n'\n 'By default there is no fine-tuning between steps.')","def __init__(self):\n \n self.label = \"ArcSDM Tools\"\n self.alias = \"ArcSDM\" \n\n # List of tool classes associated with this toolbox\n self.tools = [PartitionNNInputFiles, CombineNNOutputFiles, NeuralNetworkOutputFiles, NeuralNetworkInputFiles, \n CalculateWeightsTool,SiteReductionTool,CategoricalMembershipToool,\n CategoricalAndReclassTool, TOCFuzzificationTool, CalculateResponse, LogisticRegressionTool, Symbolize, \n ROCTool, AgterbergChengCITest, AreaFrequencyTable, GetSDMValues, GrandWofe]","def enable():\n if not _status_apf():\n return __apf_cmd(\"-s\")","def manipulator(self):\n manipulator = ConfigurationManipulator()\n for flag in OPT_FLAGS:\n manipulator.add_parameter(\n EnumParameter(flag,\n ['on', 'off', 'default']))\n return manipulator","def main():\n parser = OptionParser()\n parser.add_option('-v', \"--verbose\", action=\"store_true\", dest=\"verbose\", default=False,\n help=\"Print more debug info\")\n parser.add_option(\"--list\", action=\"store_true\", dest=\"list\", default=False,\n help=\"List the available drivers\")\n\n opgroup = OptionGroup(parser, \"Operational options\")\n opgroup.add_option('-d', '--driver', action=\"store\", type=\"choice\", dest=\"driver\", default=\"sabertooth\", choices=drivers.driverlist.keys(),\n help=\"Drive using this driver [Default: sabertooth]\")\n opgroup.add_option('-s', '--arduino', action=\"store\", type=\"string\", dest=\"arduino_serial\", default=None,\n help=\"Serial number of the on-board arduino [Default: Pick a random one]\")\n parser.add_option_group(opgroup)\n\n netgroup = OptionGroup(parser, \"Network options\")\n netgroup.add_option('-a', '--host', action=\"store\", type=\"string\", dest=\"host\", default=\"\",\n help=\"Host/address to listen on [Default: all (empty string)]\")\n netgroup.add_option('-p', '--port', action=\"store\", type=\"int\", dest=\"port\", default=9999,\n help=\"Port to listen on [Default: 9999]\")\n parser.add_option_group(netgroup)\n\n smcgroup = OptionGroup(parser, \"SMC-based driver options\",\n \"Needed when the driver is oriented around a pair of Pololu Simple Motor Controllers\")\n smcgroup.add_option(\"-l\", \"--left\", type=\"string\", dest=\"left\", default='3000-6A06-3142-3732-7346-2543',\n help=\"The serial number of the left controller [3000-6A06-3142-3732-7346-2543]\")\n smcgroup.add_option(\"-r\", \"--right\", type=\"string\", dest=\"right\", default=\"3000-6F06-3142-3732-4454-2543\",\n help=\"The serial number of the right controller [3000-6F06-3142-3732-4454-2543]\")\n smcgroup.add_option(\"-c\", \"--smccmd\", type=\"string\", dest=\"smccmd\", default=\"/root/pololu/smc_linux/SmcCmd\",\n help=\"The path to the SmcCmd utility [/root/pololu/smc_linux/SmcCmd]\")\n parser.add_option_group(smcgroup)\n\n # parse the arguments\n options, args = parser.parse_args()\n\n list_and_exit = False\n if options.list:\n list_and_exit = True\n else:\n # make sure we specified a valid driver\n if not options.driver:\n print \"You must specify a driver!\"\n list_and_exit = True\n elif options.driver not in drivers.driverlist:\n print \"Invalid driver specified: %s\" % options.driver\n list_and_exit = True\n\n # if we requested a driver list, list drivers and then exit\n if list_and_exit:\n print \"Available drivers:\"\n for name, info in drivers.driverlist.items():\n print \"%s %s\" % (name.ljust(30), info[0])\n\n return 0\n\n # otherwise, try to create the robot and then start the servers\n robot = Robot(**vars(options))\n robot.reset()\n print \"Robot initialized successfully...\"\n\n # create the robot\n server = TCPServer((options.host, options.port), ConnectionHandler)\n server.last_request = 0\n server.robot = robot\n\n # used to limit control of the robot to a single connection\n server.control_lock = threading.RLock()\n\n # create the monitor\n server_monitor = monitor.ServerMonitor(server, robot)\n server.monitor = server_monitor\n server_monitor.start()\n\n # start the robot and begin accepting requests\n print \"Starting server...\"\n try:\n server.serve_forever()\n except KeyboardInterrupt:\n server.is_shutting_down.set()\n return 0\n finally:\n print \"Shutting down...\"\n server_monitor.stop()\n server.shutdown()\n robot.shutdown()","def processCommandList():\n\n try:\n # Assume that maya.cmds.about and maya.cmds.internalVar are already registered\n #\n commandListPath = os.path.realpath( os.environ[ 'MAYA_LOCATION' ] )\n platform = maya.cmds.about( os=True )\n commandListPath = os.path.join( commandListPath, commandListLocations[platform], 'commandList' )\n\n file = open( commandListPath, 'r' )\n for line in file:\n commandName, library = line.split()\n if not commandName in maya.cmds.__dict__:\n maya.cmds.__dict__[commandName] = __makeStubFunc( commandName, library )\n except:\n sys.stderr.write(\"Unable to process commandList %s\" % commandListPath)\n raise","def setup_platform(hass, config, add_devices, discovery_info=None):\n switches = []\n for coil in config.get(\"coils\"):\n switches.append(ModbusCoilSwitch(\n coil.get(CONF_NAME),\n coil.get(CONF_SLAVE),\n coil.get(CONF_COIL)))\n add_devices(switches)","def all_off():\n print(\"Climate is within set parameters; toggling systems off if any are on\")\n GPIO.output(HEATPIN, RELAYOFF)\n GPIO.output(COOLPIN, RELAYOFF)\n GPIO.output(FANPIN, RELAYOFF)\n time.sleep(30)","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def setEnableCondition(*args):","def enable_amplitude_modulation(self):\n self.write(\":SOUR:AM:STAT ON\")"],"string":"[\n \"def lamps(self, **lamp_parameters):\\n self._set_state(lamp_parameters.items())\",\n \"def all_lamps_slow():\\n HOUSE = pre_process.get_house()\\n\\n for id_num, lamp in HOUSE.lamps.items():\\n lamp.turn_on()\\n lamp.set_transition_time(500)\\n lamp.set_brigthness(254)\\n lamp.send_command()\",\n \"def run_lammps(lammps_executable, input_file, output_file):\\n # run lammps\\n lammps_command = f\\\"{lammps_executable} -in {input_file} \\\"\\n print(\\\"run command:\\\", lammps_command)\\n with open(\\\"tmp2False.out\\\", \\\"w+\\\") as fout:\\n subprocess.call(lammps_command.split(), stdout=fout)\",\n \"def silkscreen_commands(self, commands):\\n self.pcb_layers[\\\"silkscreen\\\"].commands = commands\",\n \"def get_all_switches(name):\\n return [False,False,False,False] #TODO Implement\",\n \"def list_litnacionals_cmd():\\n return ListLitnacionalCommand()\",\n \"def init_switches(inds):\\n for i in inds:\\n GPIO.setup(i, GPIO.OUT, initial=0)\",\n \"def _arm_and_offboard(self):\\n arming_client = rospy.ServiceProxy('/mavros/cmd/arming', CommandBool)\\n set_mode_client = rospy.ServiceProxy('/mavros/set_mode', SetMode)\\n\\n offb_set_mode = SetMode()\\n offb_set_mode.custom_mode = \\\"OFFBOARD\\\"\\n\\n arm_cmd = CommandBool()\\n arm_cmd.value = True\\n\\n wait_time = rospy.Duration(1)\\n\\n last_request = rospy.Time.now()\\n while not rospy.is_shutdown() and (self.mavros_state.mode != \\\"OFFBOARD\\\" or not self.mavros_state.armed):\\n if self.mavros_state.mode != \\\"OFFBOARD\\\" and (rospy.Time.now() - last_request > wait_time):\\n res = set_mode_client(0, offb_set_mode.custom_mode)\\n if res and res.mode_sent:\\n rospy.loginfo(self.name + \\\": Offboard enabled\\\")\\n last_request = rospy.Time.now()\\n else:\\n if not self.mavros_state.armed and (rospy.Time.now() - last_request > wait_time):\\n res = arming_client(True)\\n if res and res.success:\\n rospy.loginfo(self.name + \\\": Vehicle armed\\\")\\n last_request = rospy.Time.now()\\n return\",\n \"def initiate_lmp(self, cs_springs):\\n lmp = lammps()\\n \\n lmp.command('units metal')\\n lmp.command('atom_style full')\\n \\n large_tilt = self._check_large_tilt()\\n if large_tilt:\\n lmp.command('box tilt large')\\n\\n lmp.command('read_data {}'.format(self.file_name))\\n \\n lmp.command('group cores type {}'.format(self.type_core()))\\n if len(self.bond_types) != 0:\\n lmp.command('group shells type {}'.format(self.type_shell()))\\n\\n if cs_springs:\\n lmp.command('pair_style buck/coul/long/cs 10.0')\\n lmp.command('pair_coeff * * 0 1 0')\\n\\n lmp.command('bond_style harmonic') \\n for bond in self.bond_types:\\n lmp.command(bond.bond_string())\\n else:\\n lmp.command('pair_style buck/coul/long 10.0')\\n lmp.command('pair_coeff * * 0 1 0')\\n\\n lmp.command('kspace_style ewald 1e-6')\\n\\n #setup for minimization\\n lmp.command('min_style cg')\\n return lmp\",\n \"def set_pulse_on_hit_and_enable_and_release_and_disable_rule(self, enable_switch, disable_switch, coil):\\n raise NotImplementedError\",\n \"def setLightingOptions(lightID, val, otype):\\n odict = {'ambient':'AMBIENT','diffuse':'DIFFUSE','specular':'SPECULAR',\\n 'constant':'CONSTANT','linear':'LINEAR','quadratic':'QUADRATIC'}\\n dislin.litopt(lightID, val, odict[otype])\",\n \"def do_attribute_switches(self):\\n event = None\\n if self.rhs:\\n event = self.get_event_from_args(self.rhs, check_host=True)\\n else:\\n proj = self.project\\n if not proj:\\n raise self.CalCmdError(\\n \\\"You must use /create first or specify an event.\\\"\\n )\\n if \\\"largesse\\\" in self.switches:\\n return self.set_largesse(event)\\n if \\\"date\\\" in self.switches or \\\"reschedule\\\" in self.switches:\\n return self.set_date(event)\\n if \\\"location\\\" in self.switches:\\n return self.set_location(event)\\n if \\\"desc\\\" in self.switches:\\n return self.set_event_desc(event)\\n if \\\"roomdesc\\\" in self.switches:\\n return self.set_room_desc(event)\\n if \\\"plotroom\\\" in self.switches:\\n return self.set_plotroom(event)\\n if \\\"private\\\" in self.switches:\\n return self.set_private(event)\\n if \\\"host\\\" in self.switches:\\n return self.add_or_remove_host(event)\\n if \\\"gm\\\" in self.switches:\\n return self.add_or_remove_gm(event)\\n if \\\"invite\\\" in self.switches:\\n return self.invite_org_or_player(event)\\n if \\\"uninvite\\\" in self.switches:\\n return self.uninvite_org_or_player(event)\\n if \\\"action\\\" in self.switches:\\n return self.set_crisis_action(event)\\n if \\\"risk\\\" in self.switches:\\n return self.set_risk(event)\",\n \"def magic_lsmagic(self, parameter_s = ''):\\n print 'Available magic functions:\\\\n@'+' @'.join(self.lsmagic())\\n print '\\\\n' + Magic.auto_status[self.rc.automagic]\\n return None\",\n \"def __init__(self):\\r\\n self.label = \\\"OVL Tools\\\"\\r\\n self.alias = \\\"\\\"\\r\\n\\r\\n # List of tool classes associated with this toolbox\\r\\n self.tools = [OVLtoFeature, BatchOVLtoFeature]\",\n \"def set_lo1ab_off(self):\\n self.seq.add_param(self.mng_name, \\\"testTonePowerLevel\\\", \\\"-110\\\", 4)\\n self.seq.add_param(self.mng_name, \\\"loPowerLevel\\\", \\\"-110\\\", 1)\\n self.seq.add_param(self.mng_name, \\\"autoSetLOPowerLevel\\\", \\\"0\\\", 3)\\n self.seq.add_param(self.mng_name, \\\"S4\\\", \\\"4\\\")\\n self.seq.add_param(self.mng_name, \\\"S8\\\", \\\"5\\\")\\n self.seq.add_param(self.mng_name, \\\"S12\\\", \\\"1\\\")\",\n \"def _setup_loom_ops(self, named_ops):\\n # Make a PassThroughOp for each TypeShape. Then set up mappings between\\n # names, op indices and ops with the PassThrough ops having the same\\n # indices as their type_shapes and no names.\\n pass_through_ops = [PassThroughLoomOp(ts) for ts in self._type_shapes]\\n\\n non_passthrough_op_names = sorted(six.iterkeys(named_ops))\\n\\n # _loom_op_names: a list of names for all the ops (including autogenerated\\n # names for the PassThroughLoomOps for debugging purposes.)\\n #\\n # The first len(self._type_shapes) ops are forced to be the passthrough ops\\n # for the corresponding TypeShape. This is enforced in VerifyLoomMetadata.\\n self._loom_op_names = (\\n [self._pass_through_name(ts) for ts in self._type_shapes] +\\n non_passthrough_op_names)\\n\\n # _loom_ops: a list of the supported LoomOps (including autogenerated\\n # PassThroughOps)\\n self._loom_ops = (\\n pass_through_ops + [named_ops[k] for k in non_passthrough_op_names])\\n\\n # _loom_total_args: The sum of the number of arguments across all loom ops.\\n self._loom_total_args = sum(\\n len(op.input_type_shapes) for op in self._loom_ops)\\n\\n # _loom_op_name_to_idx: a dict mapping the names in '_op_names' back to into\\n # indices usable with '_ops' and '_op_names'.\\n self._loom_op_name_to_idx = {\\n name: idx for idx, name in enumerate(self._loom_op_names)}\",\n \"def get_lamp_specs(self):\\n return {lamp: self._LAMP_SPECS[lamp] for lamp in self._available_lamps}\",\n \"def turn_on(self, **kwargs: Any) -> None:\\n commands = []\\n _LOGGER.debug(\\\"light kwargs-> %s\\\", kwargs)\\n\\n if (\\n DPCODE_LIGHT in self.tuya_device.status\\n and DPCODE_SWITCH not in self.tuya_device.status\\n ):\\n commands += [{\\\"code\\\": DPCODE_LIGHT, \\\"value\\\": True}]\\n else:\\n commands += [{\\\"code\\\": DPCODE_SWITCH, \\\"value\\\": True}]\\n\\n if ATTR_BRIGHTNESS in kwargs:\\n if self._work_mode().startswith(WORK_MODE_COLOUR):\\n colour_data = self._get_hsv()\\n v_range = self._tuya_hsv_v_range()\\n colour_data[\\\"v\\\"] = int(\\n self.remap(kwargs[ATTR_BRIGHTNESS], 0, 255, v_range[0], v_range[1])\\n )\\n commands += [\\n {\\\"code\\\": self.dp_code_colour, \\\"value\\\": json.dumps(colour_data)}\\n ]\\n else:\\n new_range = self._tuya_brightness_range()\\n tuya_brightness = int(\\n self.remap(\\n kwargs[ATTR_BRIGHTNESS], 0, 255, new_range[0], new_range[1]\\n )\\n )\\n commands += [{\\\"code\\\": self.dp_code_bright, \\\"value\\\": tuya_brightness}]\\n\\n if ATTR_HS_COLOR in kwargs:\\n colour_data = self._get_hsv()\\n # hsv h\\n colour_data[\\\"h\\\"] = int(kwargs[ATTR_HS_COLOR][0])\\n # hsv s\\n ha_s = kwargs[ATTR_HS_COLOR][1]\\n s_range = self._tuya_hsv_s_range()\\n colour_data[\\\"s\\\"] = int(\\n self.remap(\\n ha_s,\\n HSV_HA_SATURATION_MIN,\\n HSV_HA_SATURATION_MAX,\\n s_range[0],\\n s_range[1],\\n )\\n )\\n # hsv v\\n ha_v = self.brightness\\n v_range = self._tuya_hsv_v_range()\\n colour_data[\\\"v\\\"] = int(self.remap(ha_v, 0, 255, v_range[0], v_range[1]))\\n\\n commands += [\\n {\\\"code\\\": self.dp_code_colour, \\\"value\\\": json.dumps(colour_data)}\\n ]\\n if self.tuya_device.status[DPCODE_WORK_MODE] != \\\"colour\\\":\\n commands += [{\\\"code\\\": DPCODE_WORK_MODE, \\\"value\\\": \\\"colour\\\"}]\\n\\n if ATTR_COLOR_TEMP in kwargs:\\n # temp color\\n new_range = self._tuya_temp_range()\\n color_temp = self.remap(\\n self.max_mireds - kwargs[ATTR_COLOR_TEMP] + self.min_mireds,\\n self.min_mireds,\\n self.max_mireds,\\n new_range[0],\\n new_range[1],\\n )\\n commands += [{\\\"code\\\": self.dp_code_temp, \\\"value\\\": int(color_temp)}]\\n\\n # brightness\\n ha_brightness = self.brightness\\n new_range = self._tuya_brightness_range()\\n tuya_brightness = self.remap(\\n ha_brightness, 0, 255, new_range[0], new_range[1]\\n )\\n commands += [{\\\"code\\\": self.dp_code_bright, \\\"value\\\": int(tuya_brightness)}]\\n\\n if self.tuya_device.status[DPCODE_WORK_MODE] != \\\"white\\\":\\n commands += [{\\\"code\\\": DPCODE_WORK_MODE, \\\"value\\\": \\\"white\\\"}]\\n\\n self._send_command(commands)\",\n \"def SetStandbyLPMode(self):\\n handler = self.get_command_object(\\\"SetStandbyLPMode\\\")\\n handler()\",\n \"def process_cl_args():\\n\\n parser = argparse.ArgumentParser(add_help=False)\\n parser.add_argument('commands', nargs='*')\\n parser.add_argument('--help', '-h', action='store_true')\\n parser.add_argument('--version', '-v', action='store_true')\\n parser.add_argument('--debug', '-d', action='store_true')\\n parser.add_argument('--logging', '-l', action='store_true')\\n parser.add_argument('--no-autosize', action='store_true')\\n parser.add_argument('--no-preload', action='store_true')\\n args = parser.parse_args()\\n\\n if args.version:\\n xprint(get_version_info())\\n xprint(\\\"\\\")\\n sys.exit()\\n\\n elif args.help:\\n for x in helptext():\\n xprint(x[2])\\n sys.exit()\\n\\n if args.debug or os.environ.get(\\\"mpsytdebug\\\") == \\\"1\\\":\\n xprint(get_version_info())\\n g.debug_mode = True\\n g.no_clear_screen = True\\n logfile = os.path.join(tempfile.gettempdir(), \\\"mpsyt.log\\\")\\n logging.basicConfig(level=logging.DEBUG, filename=logfile)\\n logging.getLogger(\\\"pafy\\\").setLevel(logging.DEBUG)\\n\\n elif args.logging or os.environ.get(\\\"mpsytlog\\\") == \\\"1\\\":\\n logfile = os.path.join(tempfile.gettempdir(), \\\"mpsyt.log\\\")\\n logging.basicConfig(level=logging.DEBUG, filename=logfile)\\n logging.getLogger(\\\"pafy\\\").setLevel(logging.DEBUG)\\n\\n if args.no_autosize:\\n g.detectable_size = False\\n\\n g.command_line = \\\"playurl\\\" in args.commands or \\\"dlurl\\\" in args.commands\\n if g.command_line:\\n g.no_clear_screen = True\\n\\n if args.no_preload:\\n g.preload_disabled = True\\n\\n g.argument_commands = args.commands\",\n \"async def power_on(self) -> str:\\n return f\\\"d2 lamp is {await self.hw_device.lamp('d2')}; halogen lamp is {await self.hw_device.lamp('hal')}\\\"\",\n \"def Lvl1SimulationSequence( flags = None ):\\n # for the New JO migration\\n # from AthenaCommon.ComponentAccumulator import ComponentAccumulator\\n # acc = ComponentAccumulator()\\n # all tools then should be added to the acc, cond folders as well.\\n # L1ConfigSvc CA has to be imported and merged\\n # at the end the sequence added to the CA\\n #\\n from AthenaCommon.Logging import logging\\n log = logging.getLogger('TriggerJobOpts.Lvl1Simulation')\\n from AthenaConfiguration.ComponentAccumulator import conf2toConfigurable\\n from AthenaCommon.CFElements import seqAND\\n from AthenaCommon.AppMgr import ServiceMgr as svcMgr\\n from AthenaCommon.AlgSequence import AthSequencer\\n from TriggerJobOpts.TriggerFlags import TriggerFlags\\n\\n # this configuration of the LVL1ConfigSvc is only temporary\\n TriggerFlags.readLVL1configFromXML = True\\n TriggerFlags.outputLVL1configFile = None\\n log.info(\\\"setting up LVL1ConfigSvc, including the menu generation\\\")\\n from TrigConfigSvc.TrigConfigSvcCfg import getL1ConfigSvc\\n svcMgr += conf2toConfigurable(getL1ConfigSvc(flags))\\n\\n ##################################################\\n # Calo\\n ##################################################\\n\\n if flags.Trigger.enableL1CaloLegacy:\\n\\n from TrigT1CaloSim.TrigT1CaloSimRun2Config import Run2TriggerTowerMaker\\n caloTowerMaker = Run2TriggerTowerMaker(\\\"Run2TriggerTowerMaker25ns\\\")\\n caloTowerMaker.ExtraInputs = [\\\"LArTTL1Container#LArTTL1EM\\\", \\\"LArTTL1Container#LArTTL1HAD\\\", \\\"TileTTL1Container#TileTTL1Cnt\\\" ]\\n caloTowerMaker.ZeroSuppress = True\\n caloTowerMaker.CellType = 3\\n\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__Run2CPMTowerMaker\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__Run2JetElementMaker\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__CPMSim\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JEMJetSim\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JEMEnergySim\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__CPCMX\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__JetCMX\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__EnergyCMX\\n from TrigT1CaloSim.TrigT1CaloSimConf import LVL1__RoIROD\\n\\n from TrigT1MBTS.TrigT1MBTSConf import LVL1__TrigT1MBTS\\n from TrigT1ZDC.TrigT1ZDCConf import LVL1__TrigT1ZDC\\n\\n l1CaloSim = seqAND('l1CaloSim',[\\n caloTowerMaker,\\n #LVL1__Run2CPMTowerMaker( 'CPMTowerMaker', ExtraInputs=[\\\"XYZ#1\\\"], ExtraOutputs=[\\\"XYZ#2\\\"]) ,\\n LVL1__Run2CPMTowerMaker( 'CPMTowerMaker') ,\\n LVL1__Run2JetElementMaker( 'JetElementMaker'),\\n LVL1__CPMSim( 'CPMSim' ) ,\\n LVL1__JEMJetSim( 'JEMJetSim' ) ,\\n LVL1__JEMEnergySim( 'JEMEnergySim' ) ,\\n LVL1__CPCMX( 'CPCMX' ) ,\\n LVL1__JetCMX( 'JetCMX' ) ,\\n LVL1__EnergyCMX( 'EnergyCMX' ) ,\\n LVL1__RoIROD( 'RoIROD' ),\\n LVL1__TrigT1MBTS(),\\n LVL1__TrigT1ZDC()\\n ])\\n\\n from IOVDbSvc.CondDB import conddb\\n L1CaloFolderList = []\\n #L1CaloFolderList += [\\\"/TRIGGER/L1Calo/V1/Calibration/Physics/PprChanCalib\\\"]\\n L1CaloFolderList += [\\\"/TRIGGER/L1Calo/V2/Calibration/Physics/PprChanCalib\\\"]\\n #L1CaloFolderList += [\\\"/TRIGGER/L1Calo/V1/Conditions/RunParameters\\\"]\\n #L1CaloFolderList += [\\\"/TRIGGER/L1Calo/V1/Conditions/DerivedRunPars\\\"]\\n #L1CaloFolderList += [\\\"/TRIGGER/Receivers/Conditions/VgaDac\\\"]\\n #L1CaloFolderList += [\\\"/TRIGGER/Receivers/Conditions/Strategy\\\"]\\n L1CaloFolderList += [\\\"/TRIGGER/L1Calo/V2/Conditions/DisabledTowers\\\"]\\n L1CaloFolderList += [\\\"/TRIGGER/L1Calo/V2/Calibration/PpmDeadChannels\\\"]\\n L1CaloFolderList += [\\\"/TRIGGER/L1Calo/V2/Configuration/PprChanDefaults\\\"]\\n\\n for l1calofolder in L1CaloFolderList:\\n #conddb.addFolderWithTag(\\\"TRIGGER_OFL\\\", l1calofolder, \\\"HEAD\\\")\\n conddb.addFolder( \\\"TRIGGER_OFL\\\", l1calofolder )\\n\\n ##################################################\\n # Muons\\n ##################################################\\n \\n from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigitTool\\n MuonRdoToMuonDigitTool = MuonRdoToMuonDigitTool (DecodeMdtRDO = False,\\n DecodeRpcRDO = True,\\n DecodeTgcRDO = True,\\n DecodeCscRDO = False,\\n DecodeSTGC_RDO = False,\\n DecodeMM_RDO = False,\\n # for those subdetectors where the decoding is turned off, no need to create a RDO_Decoder ToolHandle\\n mdtRdoDecoderTool=\\\"\\\",\\n cscRdoDecoderTool=\\\"\\\",\\n stgcRdoDecoderTool=\\\"\\\",\\n mmRdoDecoderTool=\\\"\\\",\\n RpcDigitContainer = \\\"RPC_DIGITS_L1\\\",\\n TgcDigitContainer = \\\"TGC_DIGITS_L1\\\")\\n \\n MuonRdoToMuonDigitTool.cscCalibTool = \\\"CscCalibTool\\\"\\n from AthenaCommon.AppMgr import ToolSvc\\n ToolSvc += MuonRdoToMuonDigitTool\\n\\n from MuonByteStreamCnvTest.MuonByteStreamCnvTestConf import MuonRdoToMuonDigit\\n from TrigT1RPCsteering.TrigT1RPCsteeringConf import TrigT1RPC \\n from TrigT1TGC.TrigT1TGCConf import LVL1TGCTrigger__LVL1TGCTrigger\\n\\n TrigT1RPC.useRun3Config = flags.Trigger.enableL1Phase1\\n LVL1TGCTrigger__LVL1TGCTrigger.useRun3Config = flags.Trigger.enableL1Phase1\\n\\n if flags.Trigger.enableL1Phase1:\\n # Placeholder for phase-I MUCTPI simulation\\n log.info(\\\"Configuring Phase-I MUCTPI simulation\\\")\\n from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1\\n from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import L1MuctpiPhase1Tool\\n\\n ToolSvc += L1MuctpiPhase1Tool(\\\"MUCTPI_AthTool\\\")\\n ToolSvc.MUCTPI_AthTool.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc\\n\\n muctpi = L1MuctpiPhase1()\\n muctpi.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc\\n\\n else:\\n log.info(\\\"Configuring legacy (Run 2) MUCTPI simulation\\\")\\n from TrigT1Muctpi.TrigT1MuctpiConfig import L1Muctpi\\n from TrigT1Muctpi.TrigT1MuctpiConfig import L1MuctpiTool\\n\\n ToolSvc += L1MuctpiTool(\\\"L1MuctpiTool\\\")\\n ToolSvc.L1MuctpiTool.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc\\n\\n muctpi = L1Muctpi()\\n muctpi.LVL1ConfigSvc = svcMgr.LVL1ConfigSvc\\n\\n # Sets up and configures the muon alignment and detector manager\\n from MuonRecExample import MuonAlignConfig # noqa: F401\\n\\n l1MuonSim = seqAND(\\\"l1MuonSim\\\", [\\n \\n MuonRdoToMuonDigit( \\\"MuonRdoToMuonDigit\\\",\\n MuonRdoToMuonDigitTool = ToolSvc.MuonRdoToMuonDigitTool),\\n\\n TrigT1RPC(\\\"TrigT1RPC\\\",\\n Hardware = True, # not sure if needed, not there in old config, present in JO\\n DataDetail = False,\\n RPCbytestream = False,\\n RPCbytestreamFile = \\\"\\\",\\n RPCDigitContainer = \\\"RPC_DIGITS_L1\\\"),\\n \\n # based on Trigger/TrigT1/TrigT1TGC/python/TrigT1TGCConfig.py\\n # interesting is that this JO sets inexisting properties, commented out below\\n LVL1TGCTrigger__LVL1TGCTrigger(\\\"LVL1TGCTrigger\\\",\\n InputData_perEvent = \\\"TGC_DIGITS_L1\\\", \\n MuCTPIInput_TGC = \\\"L1MuctpiStoreTGC\\\",\\n MaskFileName12 = \\\"TrigT1TGCMaskedChannel._12.db\\\"),\\n muctpi\\n ])\\n \\n # only needed for MC\\n conddb.addFolder(\\\"TGC_OFL\\\", \\\"/TGC/TRIGGER/CW_EIFI\\\", className=\\\"CondAttrListCollection\\\")\\n conddb.addFolder(\\\"TGC_OFL\\\", \\\"/TGC/TRIGGER/CW_BW\\\", className=\\\"CondAttrListCollection\\\")\\n conddb.addFolder(\\\"TGC_OFL\\\", \\\"/TGC/TRIGGER/CW_TILE\\\", className=\\\"CondAttrListCollection\\\")\\n condSeq = AthSequencer(\\\"AthCondSeq\\\")\\n from MuonCondSvc.MuonCondSvcConf import TGCTriggerDbAlg\\n condSeq += TGCTriggerDbAlg()\\n\\n ##################################################\\n # Topo\\n ##################################################\\n\\n l1TopoSim = None\\n if flags.Trigger.enableL1Phase1:\\n log.info(\\\"No phase1 configuration for L1Topo simulation is available\\\")\\n else:\\n from L1TopoSimulation.L1TopoSimulationConfig import L1TopoSimulation\\n l1TopoSim = L1TopoSimulation()\\n\\n l1TopoSim.MuonInputProvider.ROIBResultLocation = \\\"\\\" #disable input from RoIBResult\\n l1TopoSim.MuonInputProvider.MuctpiSimTool = ToolSvc.L1MuctpiTool\\n\\n # enable the reduced (coarse) granularity topo simulation\\n # currently only for MC\\n from AthenaCommon.GlobalFlags import globalflags\\n if globalflags.DataSource()!='data':\\n l1TopoSim.MuonInputProvider.MuonEncoding = 1\\n else:\\n l1TopoSim.MuonInputProvider.MuonEncoding = 0\\n\\n ##################################################\\n # CTP\\n ##################################################\\n\\n from TrigT1CTP.TrigT1CTPConfig import CTPSimulationInReco\\n ctp = CTPSimulationInReco(\\\"CTPSimulation\\\")\\n ctp.DoLUCID = False\\n ctp.DoBCM = False\\n ctp.DoL1Topo = not flags.Trigger.enableL1Phase1\\n ctp.UseCondL1Menu = False\\n ctp.TrigConfigSvc = svcMgr.LVL1ConfigSvc\\n ctpSim = seqAND(\\\"ctpSim\\\", [ctp])\\n\\n if flags.Trigger.enableL1CaloLegacy or not flags.Trigger.enableL1Phase1:\\n from TrigT1RoIB.TrigT1RoIBConfig import RoIBuilder\\n roib = RoIBuilder(\\\"RoIBuilder\\\")\\n roib.DoCalo = flags.Trigger.enableL1CaloLegacy\\n roib.DoMuon = not flags.Trigger.enableL1Phase1\\n ctpSim += [roib]\\n\\n #l1Sim = seqAND(\\\"l1Sim\\\", [caloTowerMaker] )\\n if l1TopoSim:\\n l1Sim = seqAND(\\\"l1Sim\\\", [l1CaloSim, l1MuonSim, l1TopoSim, ctpSim] )\\n else:\\n l1Sim = seqAND(\\\"l1Sim\\\", [l1CaloSim, l1MuonSim, ctpSim] )\\n\\n return l1Sim\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def setEnabled(*args):\",\n \"def turnLightingSystemOn():\\n dislin.light('ON')\",\n \"def set_opt_fuctions(self) -> None:\\n self._ordered_opt_functions = self.get_rights()[1]\",\n \"def arm_and_takeoff(aTargetAltitude):\\n cmds = vehicle1.commands\\n\\n print(\\\" Clear any existing commands\\\")\\n cmds.clear() \\n\\n # create command using mavlink mission command message \\n # http://ardupilot.org/plane/docs/common-mavlink-mission-command-messages-mav_cmd.html#mav-cmd-nav-takeoff\\n # param1=pitch angle at takeoff, param7=desired altitude\\n cmds.add(Command(0,0,0, mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT, mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,\\n 0, 0, 0, 0, 0, 0,\\n home_lat, home_lon, aTargetAltitude)) # first command in the mission is ignored for some reason, see https://github.com/dronekit/dronekit-python/blob/source-system-filtering/examples/avoidance/avoidance-manytests-plane.py#L376\\n \\n cmds.add(Command( 0, 0, 0, \\n mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT, \\n mavutil.mavlink.MAV_CMD_NAV_TAKEOFF,\\n 0, 0, 0, 0, 0, 0, 0, 0, aTargetAltitude))\\n\\n cmds.add(Command(0,0,0, mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT, mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,\\n 0, 0, 0, 0, 0, 0,\\n home_lat, home_lon, aTargetAltitude))\\n\\n print(\\\" Upload new commands to vehicle\\\")\\n cmds.upload()\\n\\n print (\\\"Param: %s\\\" % vehicle1.parameters['ARMING_CHECK'])\\n # Disable all arming checks since we are flying in sitl\\n # vehicle1.parameters['ARMING_CHECK']=1\\n \\n\\n print(\\\"Basic pre-arm checks\\\")\\n # Don't let the user try to arm until autopilot is ready\\n # If you need to disable the arming check,\\n # just comment it with your own responsibility.\\n while not vehicle1.is_armable:\\n print(\\\" Waiting for vehicle to initialise...\\\")\\n time.sleep(1)\\n\\n # Plane can only take of in auto-mode and with a mission loaded\\n # while not vehicle1.mode == VehicleMode('AUTO'):\\n # Set the vehicle into auto mode\\n vehicle1.mode = VehicleMode(\\\"AUTO\\\")\\n\\n while not vehicle1.armed:\\n print(\\\" Waiting for arming...\\\")\\n vehicle1.armed = True\\n time.sleep(1)\\n print('Motor armed')\\n\\n print('System status: %s' % (vehicle1.system_status))\\n \\n print(\\\"Taking off!\\\")\\n # vehicle1.groundspeed=200.0\\n while True:\\n print (\\\" Altitude: \\\", vehicle1.location.global_relative_frame.alt)\\n print('System status: %s' % (vehicle1.system_status))\\n #Break and return from function just below target altitude.\\n if vehicle1.location.global_relative_frame.alt>=aTargetAltitude*0.95:\\n print (\\\"Reached target altitude\\\")\\n break\\n time.sleep(1)\",\n \"def definearguments(self, customparser):\\n if not customparser:\\n return\\n\\n self.cmdbase.add_login_arguments_group(customparser)\\n self.options_argument_group(customparser)\\n subcommand_parser = customparser.add_subparsers(dest=\\\"command\\\")\\n default_parser = subcommand_parser.add_parser(\\n \\\"default\\\",\\n help=\\\"Obtain iLO management networking interface details and configure basic \\\"\\n \\\"properties such as enablement/disablement, domain name servers, ipv4 and ipv6 \\\"\\n \\\"networking configuration.\\\",\\n formatter_class=RawDescriptionHelpFormatter,\\n )\\n default_parser.add_argument(\\n \\\"--enable_nic\\\",\\n dest=\\\"enable_nic\\\",\\n help=\\\"Enable network interfaces. List each interface to be enabled by ID: \\\"\\n \\\"Ex: ethernet --enable_nic 1,2,3. **Note**: Non-existent interfaces will be omitted from \\\"\\n \\\"configuration.\\\",\\n type=str,\\n default=None,\\n )\\n default_parser.add_argument(\\n \\\"--disable_nic\\\",\\n dest=\\\"disable_nic\\\",\\n help=\\\"Disable network interfaces. List each interface to be disabled by ID: \\\"\\n \\\"Ex: ethernet --disable_nic 1,2,3. **Note**: Non-existent interfaces will be omitted from \\\"\\n \\\"configuration.\\\",\\n type=str,\\n default=None,\\n )\\n default_parser.add_argument(\\n \\\"--enable_vnic\\\",\\n dest=\\\"enable_vnic\\\",\\n help=\\\"\\\"\\\"Enable virtual network interfaces of management network.\\n Ex: ethernet --enable_vnic\\\"\\\"\\\",\\n action=\\\"store_true\\\",\\n default=False,\\n )\\n default_parser.add_argument(\\n \\\"--disable_vnic\\\",\\n dest=\\\"disable_vnic\\\",\\n help=\\\"\\\"\\\"Disable virtual network interfaces of management network.\\n Ex: ethernet --disable_vnic\\\"\\\"\\\",\\n action=\\\"store_true\\\",\\n default=False,\\n )\\n default_parser.add_argument(\\n \\\"--disable_enhanced_downloads\\\",\\n dest=\\\"disable_enhanced_downloads\\\",\\n help=\\\"\\\"\\\"Disable enhanced download for virtual media and firmware update.\\n Ex: ethernet --disable_enhanced_downloads\\\"\\\"\\\",\\n action=\\\"store_true\\\",\\n default=False,\\n )\\n default_parser.add_argument(\\n \\\"--enable_enhanced_downloads\\\",\\n dest=\\\"enable_enhanced_downloads\\\",\\n help=\\\"\\\"\\\"Enable enhanced download for virtual media and firmware update.\\n Ex: ethernet --enable_enhanced_downloads\\\"\\\"\\\",\\n action=\\\"store_true\\\",\\n default=False,\\n )\\n default_parser.add_argument(\\n \\\"--nameservers\\\",\\n dest=\\\"nameservers\\\",\\n help=\\\"Configure physical and shared management network interface domain name \\\"\\n \\\"servers (DNS) in a list as follows: <DNS1> <DNS2> \\\"\\n \\\"Ex: ethernet --nameservers 8.8.8.8,1.1.1.1, ethernet --nameservers dns_resolver1.aws.com, \\\"\\n \\\"dns_resolver2.aws.com\\\",\\n default=None,\\n )\\n default_parser.add_argument(\\n \\\"--proxy\\\",\\n dest=\\\"proxy\\\",\\n type=str,\\n help=\\\"Configure or clear proxy server for the network \\\"\\n \\\"Ex:\\\\nTo set proxy\\\\nethernet --proxy http://proxy.abc.net:8080 or \\\\n\\\"\\n \\\"To clear proxy settings\\\\n\\\"\\n \\\"ethernet --proxy None\\\",\\n default=None,\\n )\\n default_parser.add_argument(\\n \\\"--network_ipv4\\\",\\n dest=\\\"network_ipv4\\\",\\n help=\\\"Configure physical and shared management network interface static IPv4 \\\"\\n \\\"settings. Settings provided in a list as follows: \\\"\\n \\\"<ipv4 address>, <ipv4 gateway>, <ipv4 network mask>. Ex: ethernet --network_ipv4 \\\"\\n \\\"192.168.1.10, 192.168.1.1, 255.255.0.0\\\",\\n default=None,\\n )\\n default_parser.add_argument(\\n \\\"--network_ipv6\\\",\\n dest=\\\"network_ipv6\\\",\\n help=\\\"Configure physical and shared management network interface static IPv6 \\\"\\n \\\"settings. Settings provided in a list as follows: \\\"\\n \\\"<ipv6 address>, <ipv6 gateway>, <ipv6 network mask>. Ex: ethernet --network_ipv6 \\\"\\n \\\"0:0:0:0:ffff:c0a8:10e, 0:0:0:0:0:ffff:c0a8:101, 64. **Note**: IPv6 network mask\\\"\\n \\\"is restricted to '64' bits.\\\",\\n default=None,\\n )\\n default_parser.add_argument(\\n \\\"-j\\\",\\n \\\"--json\\\",\\n dest=\\\"json\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Optionally include this flag if you wish to change the \\\"\\n \\\"displayed output to JSON format.\\\",\\n default=False,\\n )\\n self.cmdbase.add_login_arguments_group(default_parser)\\n save_help = \\\"Save a Network Configuration.\\\"\\n save_parser = subcommand_parser.add_parser(\\n __subparsers__[0],\\n help=save_help,\\n description=\\\"{0}\\\\n\\\\texample: ethernet save\\\\n\\\\n\\\\tSave iLO ethernet network management interface \\\"\\n \\\"settings to a non-default file name.\\\\n\\\\tEx: ethernet save -f networking.json\\\\n\\\\n\\\\tSave \\\"\\n \\\"an encrypted iLO networking configuration file\\\\n\\\\texample: ethernet save --encryption \\\"\\n \\\"<ENCRYPTION_KEY>\\\".format(save_help),\\n formatter_class=RawDescriptionHelpFormatter,\\n )\\n self.cmdbase.add_login_arguments_group(save_parser)\\n self.options_argument_group(save_parser)\\n load_help = \\\"Load a Network Configuration.\\\"\\n load_parser = subcommand_parser.add_parser(\\n __subparsers__[1],\\n help=load_help,\\n description=\\\"{0}\\\\n\\\\texample: ethernet load\\\\n\\\\n\\\\tLoad iLO ethernet networking management interface \\\"\\n \\\"settings from a non-default file name.\\\\n\\\\tEx: ethernet load -f \\\"\\n \\\"networking.json\\\\n\\\\n\\\\tLoad an encrypted iLO networking configuration file\\\\n\\\\texample: \\\"\\n \\\"ethernet load --encryption <ENCRYPTION KEY>\\\".format(load_help),\\n formatter_class=RawDescriptionHelpFormatter,\\n )\\n self.cmdbase.add_login_arguments_group(load_parser)\\n self.options_argument_group(load_parser)\",\n \"def select_layers(m, enable, disable):\\n for l in m.layers:\\n if l.name in enable:\\n l.active = True\\n if l.name in disable:\\n l.active = False\",\n \"def disable_lldp_on_device_ports(self, ports=None):\\n pass\",\n \"def set_up_all_ao(self):\\n self.set_as_active()\\n \\n # sets up ambient occlusion lighting\\n self.set_up_world_ao()\\n self.comp_add_ao()\",\n \"def enable_cl1_pll1(self):\\n self.write_versa5(0x17,0x02) ## Change top multiplier to 0x22\\n self.write_versa5(0x18,0x20)\\n self.write_versa5(0x10,0xc0) ## Enable xtal and clock\\n self.write_versa5(0x13,0x03) ## Switch to clock\\n self.write_versa5(0x10,0x40) ## Enable clock input only, won't lock to master\",\n \"def on_off_action(speaker, action, args, soco_function, use_local_speaker_list):\\n if action == \\\"group_mute\\\":\\n speaker = speaker.group\\n soco_function = \\\"mute\\\"\\n np = len(args)\\n if np == 0:\\n state = \\\"on\\\" if getattr(speaker, soco_function) else \\\"off\\\"\\n print(state)\\n elif np == 1:\\n arg = args[0].lower()\\n if arg == \\\"on\\\":\\n setattr(speaker, soco_function, True)\\n elif arg == \\\"off\\\":\\n setattr(speaker, soco_function, False)\\n else:\\n parameter_type_error(action, \\\"on|off\\\")\\n return False\\n return True\",\n \"def setLaserPower(self,wavelength, power, job, seq=1):\\n self.emptyCMDlist()\\n\\n c = \\\"/cli:python /app:matrix /sys:1 /cmd:adjustls /seq:\\\" + str(seq) + \\\" /exp:\\\" + job\\n if int(wavelength) == 405:\\n c += \\\" /lsq:uv /lid:405\\\"\\n else:\\n c += \\\" /lsq:vis /lid:\\\" + str(wavelength)\\n c+= \\\" /tar:laser /value:\\\" + str(float(power))\\n self.addtoCMDlist(c)\\n self.sendCMDlist()\",\n \"def list_rulesets(command):\\n namespace = app.main(command)\\n assert namespace.command == 'lr' or namespace.command == \\\"listrulesets\\\"\",\n \"def l_action(option,opt_str,value,parser):\\n boolean_option_action(option,opt_str,value,parser)\\n from topo.misc.legacy import install_legacy_support\\n print \\\"Enabling legacy support.\\\"\\n install_legacy_support()\",\n \"def connect_hooks():\\n\\n mc.refresh()\\n\\n if not mc.objExists('world_CTL'):\\n return\\n\\n # Constrain ll hooks\\n hook_node_attrs = mc.ls('*_'+utils.get_suffix('hook')+'.hookDriver')\\n att_node_attrs = mc.ls('*_'+utils.get_suffix('attrDriver')+'.attrDriver')\\n world_hook = mc.ls('*_worldRoot_*.allCtrlsVis')[0].split('.')[0]\\n\\n for attr in hook_node_attrs:\\n print 'Connecting: '+attr\\n\\n driver = mc.ls(mc.getAttr(attr) or '')\\n hook = attr.split('.')[0]\\n\\n if mc.getAttr(attr) and not driver:\\n print ' \\\\t***Cannot find driver for : '+attr\\n\\n if not driver:\\n continue\\n\\n # remove any contraints\\n utils.set_attrs(hook, 't r s', k=1, l=0)\\n cons = utils.get_constraints(hook)\\n if cons:\\n mc.delete(cons)\\n\\n # create new contraints on HOOK\\n if mc.objExists(hook+'.connectXforms'):\\n mc.connectAttr(driver[0]+'.t', hook+'.t')\\n mc.connectAttr(driver[0]+'.r', hook+'.r')\\n mc.connectAttr(driver[0]+'.s', hook+'.s')\\n\\n else:\\n constraint.constraint_mtx(driver[0], hook)\\n #mc.parentConstraint(driver[0], hook, mo=1)\\n #mc.scaleConstraint(driver[0], hook, mo=1)\\n\\n # connect vis attrs to world nod\\n hook_parents = utils.get_children('parts_'+utils.get_suffix('transform'))\\n world_node = mc.ls('world_CTL')\\n vis_node = mc.ls('visibility_CTL')\\n\\n utils.set_attrs(world_node[0], 'worldScale', l=1, k=0)\\n\\n attrs = ['allCtrlsVis', 'offsetCtrlsVis', 'jointsVis', 'jointsSelectable']\\n\\n if hook_parents and world_node:\\n for hook_parent in hook_parents:\\n for attr in attrs:\\n mc.connectAttr(vis_node[0]+'.'+attr, hook_parent+'.'+attr)\\n\\n # recreate any attrs from hook nodes onto driver nodes\\n driven_hooks = [a.split('.')[0] for a in hook_node_attrs+att_node_attrs]\\n hook_drivers = [mc.getAttr(a) or '' for a in hook_node_attrs+att_node_attrs]\\n ignore = ['isRequired', 'hookDriver', 'worldScale']\\n\\n for i, hook in enumerate(driven_hooks):\\n driver = hook_drivers[i]\\n\\n if mc.objExists(hook):\\n\\n # copy attrs from original leg ctrl to new foot ctrl\\n data = udAttributes.get_data(hook)\\n if not data:\\n continue\\n\\n if 'worldScale' in data[hook]['data'].keys():\\n del data[hook]['data']['worldScale']\\n\\n if 'worldScale' in data[hook]['attr_order']:\\n data[hook]['attr_order'].remove('worldScale')\\n\\n data[driver] = data[hook]\\n if hook != driver:\\n del data[hook]\\n\\n udAttributes.set_data(data, verbose=False)\\n\\n #drive ik leg ctrl attrs with foot ctrl\\n attrs = data[driver]['attr_order']\\n for attr in attrs:\\n if attr not in ignore:\\n try:\\n mc.connectAttr(driver+'.'+attr, hook+'.'+attr)\\n except:\\n pass\\n\\n utils.break_connections('C_worldRoot_GRP', 'allCtrlsVis')\\n utils.set_attrs(hook_parents, l=1, k=1)\\n\\n #hide no transforms\\n mc.hide(mc.ls('noXform_'+utils.get_suffix('transform')))\",\n \"def _add_lamp_outlets(self):\\r\\n lst = self.model.get_all_lamp_outlets()\\r\\n\\r\\n for itm in lst:\\r\\n self._add_lamp_outlet(itm)\",\n \"def command(command_list):\\n def add_attribute(func):\\n if not hasattr(func, \\\"command\\\"):\\n func.command = []\\n func.command.append(command_list)\\n return func\\n return add_attribute\",\n \"def modsToggle(self, connect=False, verbose=True):\\n try:\\n if self._mods_available:\\n if connect: \\n if verbose: self.logger.info('Enabling mods...')\\n self.syslogger.info('Enabling mods...')\\n self.sh('echo {} > {}'.format(CONFIG.DEVICE.MODS_ON_OFF['on'], CONFIG.DEVICE.MODS_PATH))\\n self._mods_enabled = False\\n else:\\n if verbose: self.logger.info('Disabling mods...')\\n self.syslogger.info('Disabling mods...')\\n self.sh('echo {} > {}'.format(CONFIG.DEVICE.MODS_ON_OFF['off'], CONFIG.DEVICE.MODS_PATH))\\n self._mods_enabled = False\\n except Exception as e:\\n self.logger.error('Mods connot be enabled/disabled: {}'.format(e), self.syslogger)\",\n \"def lsextpool(self, args: str = \\\"\\\") -> List[str]:\\n\\n lsextpool_cmd = f\\\"{self.base_cmd} lsextpool {args}\\\"\\n lsextpool_out = runsub.cmd(lsextpool_cmd)\\n\\n return lsextpool_out\",\n \"def manipulator(self):\\n manipulator = ConfigurationManipulator()\\n \\n num_options = len(self.passes)-1\\n \\n # choose for a sequence of at most `max_passes` passes\\n for i in range(self.max_passes):\\n passNum = 'pass_' + str(i)\\n # some pass\\n manipulator.add_parameter(IntegerParameter(passNum, 0, num_options))\\n # and whether to turn it on or off\\n manipulator.add_parameter(EnumParameter('enable_' + passNum, [True, False]))\\n \\n # choose from a set of knobs\\n for knob, minInt, maxInt in self.knobs:\\n manipulator.add_parameter(IntegerParameter(knob, minInt, maxInt))\\n manipulator.add_parameter(EnumParameter('enable_' + knob, [True, False]))\\n \\n return manipulator\",\n \"def set_light_mode(self, is_lid):\\n raise NotImplementedError()\",\n \"def enable_automations(self):\\n for sound in self.sounds_and_channels:\\n for auto in self.sounds_and_channels[sound].automation_blocks:\\n logging.debug(\\\"Attaching automation %s to sound %s\\\" % (auto, sound))\\n # give each automation a known unique name\\n self.attach_automation(sound, auto, \\\"%s_%s\\\" % (auto, self.unique_name()))\",\n \"def before_unlock_actions(self):\\n for command in self.before_unlock_commands:\\n addr = command[\\\"address\\\"]\\n prop = command[\\\"property\\\"]\\n if len(command[\\\"argument\\\"]) == 0:\\n arg = [0]\\n else:\\n try:\\n arg = [eval(command[\\\"argument\\\"])]\\n except:\\n arg = [command[\\\"argument\\\"]]\\n if command[\\\"type\\\"] == \\\"set\\\":\\n tine.set(addr, prop, arg)\\n elif command[\\\"type\\\"] == \\\"query\\\":\\n tine.query(addr, prop, arg[0])\",\n \"def intial_configuration():\\n print(('You will be asked a few questions to configure latools\\\\n'\\n 'for your specific laboratory needs.'))\\n lab_name = input('What is the name of your lab? : ')\\n\\n params = {}\\n OK = False\\n while ~OK:\\n srmfile = input('Where is your SRM.csv file? [blank = default] : ')\\n if srmfile != '':\\n if os.path.exists(srmfile):\\n params['srmfile'] = srmfile\\n OK = True\\n else:\\n print((\\\"You told us the SRM data file was at: \\\" + semfile +\\n \\\"\\\\nlatools can't find that file. Please check it \\\"\\n \\\"exists, and \\\\ncheck that the path was correct. \\\"\\n \\\"The file path must be complete, not relative.\\\"))\\n else:\\n print((\\\"No path provided. Using default GeoRem values for \\\"\\n \\\"NIST610, NIST612 and NIST614.\\\"))\\n OK = True\\n\\n OK = False\\n\\n while ~OK:\\n dataformatfile = input(('Where is your dataformat.dict file? '\\n '[blank = default] : '))\\n if dataformatfile != '':\\n if os.path.exists(dataformatfile):\\n params['srmfile'] = dataformatfile\\n OK = True\\n else:\\n print((\\\"You told us the dataformat file was at: \\\" +\\n dataformatfile + \\\"\\\\nlatools can't find that file. \\\"\\n \\\"Please check it exists, and \\\\ncheck that the path \\\"\\n \\\"was correct. The file path must be complete, not \\\"\\n \\\"relative.\\\"))\\n else:\\n print((\\\"No path provided. Using default dataformat \\\"\\n \\\"for the UC Davis Agilent 7700.\\\"))\\n OK = True\\n\\n make_default = input(('Do you want to use these files as your '\\n 'default? [Y/n] : ')).lower() != 'n'\\n\\n add_config(lab_name, params, make_default=make_default)\\n\\n print(\\\"\\\\nConfiguration set. You're good to go!\\\")\\n\\n return\",\n \"def CommandLineMode(self):\\n for var in COMMAND_CONFIG:\\n self.Cover(var, COMMAND_CONFIG[var], layer = COMMAND_LINE_LAYER)\",\n \"def export_lights(lamps, file, scene, global_matrix, tab_write):\\n\\n from .render import write_matrix, tab_write\\n\\n # Incremented after each lamp export to declare its target\\n # currently used for Fresnel diffuse shader as their slope vector:\\n global exported_lights_count\\n # Get all lamps and keep their count in a global variable\\n for exported_lights_count, ob in enumerate(lamps, start=1):\\n lamp = ob.data\\n\\n matrix = global_matrix @ ob.matrix_world\\n\\n # Color is no longer modified by energy\\n # any way to directly get bpy_prop_array as tuple?\\n color = tuple(lamp.color)\\n\\n tab_write(file, \\\"light_source {\\\\n\\\")\\n tab_write(file, \\\"< 0,0,0 >\\\\n\\\")\\n tab_write(file, \\\"color srgb<%.3g, %.3g, %.3g>\\\\n\\\" % color)\\n\\n if lamp.type == \\\"POINT\\\":\\n pass\\n elif lamp.type == \\\"SPOT\\\":\\n tab_write(file, \\\"spotlight\\\\n\\\")\\n\\n # Falloff is the main radius from the centre line\\n tab_write(file, \\\"falloff %.2f\\\\n\\\" % (degrees(lamp.spot_size) / 2.0)) # 1 TO 179 FOR BOTH\\n tab_write(\\n file, \\\"radius %.6f\\\\n\\\" % ((degrees(lamp.spot_size) / 2.0) * (1.0 - lamp.spot_blend))\\n )\\n\\n # Blender does not have a tightness equivalent, 0 is most like blender default.\\n tab_write(file, \\\"tightness 0\\\\n\\\") # 0:10f\\n\\n tab_write(file, \\\"point_at <0, 0, -1>\\\\n\\\")\\n if lamp.pov.use_halo:\\n tab_write(file, \\\"looks_like{\\\\n\\\")\\n tab_write(file, \\\"sphere{<0,0,0>,%.6f\\\\n\\\" % lamp.distance)\\n tab_write(file, \\\"hollow\\\\n\\\")\\n tab_write(file, \\\"material{\\\\n\\\")\\n tab_write(file, \\\"texture{\\\\n\\\")\\n tab_write(file, \\\"pigment{rgbf<1,1,1,%.4f>}\\\\n\\\" % (lamp.pov.halo_intensity * 5.0))\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"interior{\\\\n\\\")\\n tab_write(file, \\\"media{\\\\n\\\")\\n tab_write(file, \\\"emission 1\\\\n\\\")\\n tab_write(file, \\\"scattering {1, 0.5}\\\\n\\\")\\n tab_write(file, \\\"density{\\\\n\\\")\\n tab_write(file, \\\"spherical\\\\n\\\")\\n tab_write(file, \\\"color_map{\\\\n\\\")\\n tab_write(file, \\\"[0.0 rgb <0,0,0>]\\\\n\\\")\\n tab_write(file, \\\"[0.5 rgb <1,1,1>]\\\\n\\\")\\n tab_write(file, \\\"[1.0 rgb <1,1,1>]\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n elif lamp.type == \\\"SUN\\\":\\n tab_write(file, \\\"parallel\\\\n\\\")\\n tab_write(file, \\\"point_at <0, 0, -1>\\\\n\\\") # *must* be after 'parallel'\\n\\n elif lamp.type == \\\"AREA\\\":\\n tab_write(file, \\\"fade_distance %.6f\\\\n\\\" % (lamp.distance / 2.0))\\n # Area lights have no falloff type, so always use blenders lamp quad equivalent\\n # for those?\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 2)\\n size_x = lamp.size\\n samples_x = lamp.pov.shadow_ray_samples_x\\n if lamp.shape == \\\"SQUARE\\\":\\n size_y = size_x\\n samples_y = samples_x\\n else:\\n size_y = lamp.size_y\\n samples_y = lamp.pov.shadow_ray_samples_y\\n\\n tab_write(\\n file,\\n \\\"area_light <%.6f,0,0>,<0,%.6f,0> %d, %d\\\\n\\\"\\n % (size_x, size_y, samples_x, samples_y),\\n )\\n tab_write(file, \\\"area_illumination\\\\n\\\")\\n if lamp.pov.shadow_ray_sample_method == \\\"CONSTANT_JITTERED\\\":\\n if lamp.pov.use_jitter:\\n tab_write(file, \\\"jitter\\\\n\\\")\\n else:\\n tab_write(file, \\\"adaptive 1\\\\n\\\")\\n tab_write(file, \\\"jitter\\\\n\\\")\\n\\n # No shadow checked either at global or light level:\\n if not scene.pov.use_shadows or (lamp.pov.shadow_method == \\\"NOSHADOW\\\"):\\n tab_write(file, \\\"shadowless\\\\n\\\")\\n\\n # Sun shouldn't be attenuated. Area lights have no falloff attribute so they\\n # are put to type 2 attenuation a little higher above.\\n if lamp.type not in {\\\"SUN\\\", \\\"AREA\\\"}:\\n if lamp.falloff_type == \\\"INVERSE_SQUARE\\\":\\n tab_write(file, \\\"fade_distance %.6f\\\\n\\\" % (sqrt(lamp.distance / 2.0)))\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 2) # Use blenders lamp quad equivalent\\n elif lamp.falloff_type == \\\"INVERSE_LINEAR\\\":\\n tab_write(file, \\\"fade_distance %.6f\\\\n\\\" % (lamp.distance / 2.0))\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 1) # Use blenders lamp linear\\n elif lamp.falloff_type == \\\"CONSTANT\\\":\\n tab_write(file, \\\"fade_distance %.6f\\\\n\\\" % (lamp.distance / 2.0))\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 3)\\n # Use blenders lamp constant equivalent no attenuation.\\n # Using Custom curve for fade power 3 for now.\\n elif lamp.falloff_type == \\\"CUSTOM_CURVE\\\":\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 4)\\n\\n write_matrix(file, matrix)\\n\\n tab_write(file, \\\"}\\\\n\\\")\\n\\n # v(A,B) rotates vector A about origin by vector B.\\n file.write(\\n \\\"#declare lampTarget%s= vrotate(<%.4g,%.4g,%.4g>,<%.4g,%.4g,%.4g>);\\\\n\\\"\\n % (\\n exported_lights_count,\\n -ob.location.x,\\n -ob.location.y,\\n -ob.location.z,\\n ob.rotation_euler.x,\\n ob.rotation_euler.y,\\n ob.rotation_euler.z,\\n )\\n )\",\n \"def run_all_steps(self, *args, **kwargs):\\n\\n # the following configopts are common to all builds\\n if self.toolchain.options['pic']:\\n self.cfg.update('configopts', '--with-pic')\\n\\n if self.cfg['with_shared']:\\n self.cfg.update('configopts', '--enable-shared')\\n\\n if self.cfg['with_generic_kernel']:\\n self.cfg.update('configopts', '--enable-generic')\\n\\n if self.cfg['with_single']:\\n self.cfg.update('configopts', '--enable-single-precision')\\n\\n for flag in ELPA_CPU_FEATURE_FLAGS:\\n # many ELPA kernels are enabled by default, even when the\\n # CPU does not support them, so we disable them all, except\\n # when the appropriate CPU flag is found\\n # sse kernels require sse4_2\\n if flag == 'sse4_2':\\n if getattr(self, flag):\\n self.cfg.update('configopts','--enable-sse')\\n self.cfg.update('configopts', '--enable-sse-assembly')\\n else:\\n self.cfg.update('configopts', '--disable-sse')\\n self.cfg.update('configopts', '--disable-sse-assembly')\\n elif flag == 'avx512f':\\n if getattr(self, 'avx512f'):\\n self.cfg.update('configopts', '--enable-avx512')\\n else:\\n self.cfg.update('configopts', '--disable-avx512')\\n else:\\n if getattr(self, flag):\\n self.cfg.update('configopts', '--enable-%s' % flag)\\n else:\\n self.cfg.update('configopts', '--disable-%s' % flag)\\n\\n # By default ELPA tries to use MPI and configure fails if it's not available\\n # so we turn off MPI support unless MPI support is requested via the usempi toolchain option.\\n # We also set the LIBS environmet variable to detect the correct linalg library\\n # depending on the MPI availability.\\n if self.toolchain.options.get('usempi', None):\\n self.cfg.update('configopts', '--with-mpi=yes')\\n self.cfg.update('configopts', 'LIBS=\\\"$LIBSCALAPACK\\\"')\\n else:\\n self.cfg.update('configopts', '--with-mpi=no')\\n self.cfg.update('configopts', 'LIBS=\\\"$LIBLAPACK\\\"')\\n\\n self.cfg.update('configopts', 'LDFLAGS=\\\"-L${EBROOTZLIB}/lib -L${EBROOTLIBXML2}/lib -lxml2 -lz\\\"')\\n\\n # make all builds verbose\\n self.cfg.update('buildopts', 'V=1')\\n\\n # keep track of common configopts specified in easyconfig file,\\n # so we can include them in each iteration later\\n common_config_opts = self.cfg['configopts']\\n\\n self.cfg['configopts'] = []\\n\\n self.cfg.update('configopts', ['--disable-openmp ' + common_config_opts])\\n if self.toolchain.options.get('openmp', False):\\n self.cfg.update('configopts', ['--enable-openmp ' + common_config_opts])\\n\\n self.log.debug(\\\"List of configure options to iterate over: %s\\\", self.cfg['configopts'])\\n\\n return super(EB_ELPA, self).run_all_steps(*args, **kwargs)\",\n \"def run_lap():\\n pass\",\n \"def turn_on(self, **kwargs):\\n self.smartplug.turn_on()\",\n \"async def disable_platforms(hass: HomeAssistant) -> None:\\n with patch(\\n \\\"homeassistant.components.demo.COMPONENTS_WITH_CONFIG_ENTRY_DEMO_PLATFORM\\\",\\n [],\\n ):\\n yield\",\n \"def set_pulse_on_hit_and_release_and_disable_rule(self, enable_switch: SwitchSettings,\\n eos_switch: SwitchSettings, coil: DriverSettings,\\n repulse_settings: Optional[RepulseSettings]):\\n raise NotImplementedError\",\n \"def set_com_pins_config(set_sequential, enable_remap):\\n if set_sequential:\\n a4bit = 0x00\\n else:\\n a4bit = 0x10\\n\\n if enable_remap:\\n a5bit = 0x20\\n else:\\n a5bit = 0x00\\n\\n send_command(0xDA)\\n send_command(0x02 | a4bit | a5bit)\",\n \"def wayland_environment(outputs):\\n env = wlr_env.copy()\\n env[\\\"WLR_HEADLESS_OUTPUTS\\\"] = str(outputs)\\n yield env\",\n \"def _setup_output_hook_and_backward_opt_barrier_lists(self) -> None:\\n assert self._is_root, \\\"This should only be called on the root\\\"\\n self._output_pre_backward_hook_registered = set()\\n self._backward_opt_barrier_tensors = []\\n self._backward_opt_barrier_tensor_ids = set()\\n for n, m in self.named_modules():\\n if n != \\\"\\\" and isinstance(m, XlaFullyShardedDataParallel):\\n m._output_pre_backward_hook_registered = self._output_pre_backward_hook_registered\\n m._backward_opt_barrier_tensors = self._backward_opt_barrier_tensors\\n m._backward_opt_barrier_tensor_ids = self._backward_opt_barrier_tensor_ids\",\n \"def main():\\n namelst = open('cor_lamp.lst').readlines()\\n namelst = ['awftbo'+i.strip() for i in namelst]\\n for name in namelst:\\n cor_keyword(name)\\n func.set_airmass(name)\",\n \"def EnableOAM(self, *args, **kwargs):\\n # type: (*Any, **Any) -> None\\n payload = { \\\"Arg1\\\": self }\\n for i in range(len(args)): payload['Arg%s' % (i + 2)] = args[i]\\n for item in kwargs.items(): payload[item[0]] = item[1]\\n return self._execute('enableOAM', payload=payload, response_object=None)\",\n \"def getTools(self):\\n return [self.toggleEditMode]\",\n \"def toggle_lights(bridge):\\n if check_any_light_on(bridge):\\n turn_off_lights(bridge)\\n else:\\n turn_on_lights(bridge)\",\n \"def set_pulse_on_hit_and_enable_and_release_and_disable_rule(self, enable_switch: SwitchSettings,\\n eos_switch: SwitchSettings, coil: DriverSettings,\\n repulse_settings: Optional[RepulseSettings]):\\n raise NotImplementedError\",\n \"def off(self):\\n self.state = \\\"OFF\\\"\\n logger.info(\\\"Turning off %s lamp at %s port %s plug %s\\\" % (self.name,\\n self.host,\\n self.port,\\n self.plug))\\n return self.send_cmd(\\\"pset %s 0\\\" % self.plug)\",\n \"def setup_platform(hass, config, add_entities, discovery_info=None):\\n locks = []\\n if int(hub.config.get(CONF_LOCKS, 1)):\\n hub.update_overview()\\n locks.extend(\\n [\\n VerisureDoorlock(device_label)\\n for device_label in hub.get(\\\"$.doorLockStatusList[*].deviceLabel\\\")\\n ]\\n )\\n\\n add_entities(locks)\",\n \"def arm_and_takeoff():\\n\\n print \\\"Basic pre-arm checks\\\"\\n # Don't let the user try to arm until autopilot is ready\\n while not vehicle.is_armable:\\n print \\\" Waiting for vehicle to initialise...\\\"\\n time.sleep(1)\\n\\n print \\\"Arming motors\\\"\\n # Copter should arm in GUIDED mode\\n vehicle.mode = VehicleMode(\\\"GUIDED\\\")\\n vehicle.armed = True\\n\\n while not vehicle.armed:\\n print \\\" Waiting for arming...\\\"\\n time.sleep(1)\",\n \"def stopAllMotors():\\n return RoboCaller().call(\\\"stopAllMotors\\\", \\\"void\\\")\",\n \"def rules():\\n head()\\n print(\\\"\\\\33[1m*--- How to play ---*\\\\033[0m\\\\n\\\")\\n print(\\\"The following command allows to control the direction of the \\\"\\n \\\"robot.\\\\n\\\")\\n for i in LIST_DIRECTION[:4]:\\n print(\\\"To the {}\\\".format(i))\\n print(\\\"\\\\nYou can also move add the number of move to do in the same \\\"\\n \\\"direction by adding a number from 0 to 9 after the direction:\\\\n\\\")\\n print(\\\"Examples: S9 - N2 - E0 (Useless but you are a free robot)\\\\n\\\\n\\\")\\n input(\\\"Press ENTER to continue ...\\\")\",\n \"def setup_fourCtrl(lf_lidrails, rt_lidrails):\\n # Declare control variables\\n lf_up = ['L_upperLid1_ctrl', 'L_upperLid2_ctrl', 'L_upperLid3_ctrl', 'L_upperLid4_ctrl']\\n lf_dn = ['L_lowerLid1_ctrl', 'L_lowerLid2_ctrl', 'L_lowerLid3_ctrl', 'L_lowerLid4_ctrl']\\n rt_up = ['R_upperLid1_ctrl', 'R_upperLid2_ctrl', 'R_upperLid3_ctrl', 'R_upperLid4_ctrl']\\n rt_dn = ['R_lowerLid1_ctrl', 'R_lowerLid2_ctrl', 'R_lowerLid3_ctrl', 'R_lowerLid4_ctrl']\\n\\n # Connect lidRails ramps to lid profile controls\\n\\n # lf_up =========\\n\\n # inner\\n cmds.connectAttr(lf_up[0] + '.tx', lf_lidrails + '.offsettop[0].offsettop_Position', f=True)\\n cmds.connectAttr(lf_up[0] + '.ty', lf_lidrails + '.offsettop[0].offsettop_FloatValue', f=True)\\n # mid - inner\\n lf_lid01_um01_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_um01_addDoubleLinear')\\n cmds.connectAttr(lf_up[1] + '.tx', lf_lid01_um01_adn + '.input1', f=True)\\n cmds.setAttr(lf_lid01_um01_adn + '.input2', 0.333)\\n cmds.connectAttr(lf_lid01_um01_adn + '.output', lf_lidrails + '.offsettop[1].offsettop_Position', f=True)\\n cmds.connectAttr(lf_up[1] + '.ty', lf_lidrails + '.offsettop[1].offsettop_FloatValue', f=True)\\n # mid - outer\\n lf_lid01_um02_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_um02_addDoubleLinear')\\n cmds.connectAttr(lf_up[2] + '.tx', lf_lid01_um02_adn + '.input1', f=True)\\n cmds.setAttr(lf_lid01_um02_adn + '.input2', 0.666)\\n cmds.connectAttr(lf_lid01_um02_adn + '.output', lf_lidrails + '.offsettop[2].offsettop_Position', f=True)\\n cmds.connectAttr(lf_up[2] + '.ty', lf_lidrails + '.offsettop[2].offsettop_FloatValue', f=True)\\n # outer\\n lf_lid01_uo01_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_uo01_addDoubleLinear')\\n cmds.connectAttr(lf_up[3] + '.tx', lf_lid01_uo01_adn + '.input1', f=True)\\n cmds.setAttr(lf_lid01_uo01_adn + '.input2', 1.0)\\n cmds.connectAttr(lf_lid01_uo01_adn + '.output', lf_lidrails + '.offsettop[3].offsettop_Position', f=True)\\n cmds.connectAttr(lf_up[3] + '.ty', lf_lidrails + '.offsettop[3].offsettop_FloatValue', f=True)\\n\\n # lf_dn =========\\n\\n lf_dn_rvn = cmds.createNode('reverse', n='lf_lid01_dn01_reverse')\\n lf_dn02_rvn = cmds.createNode('reverse', n='lf_lid01_dn02_reverse')\\n # inner\\n cmds.connectAttr(lf_dn[0] + '.tx', lf_lidrails + '.offsetbottom[0].offsetbottom_Position', f=True)\\n cmds.connectAttr(lf_dn[0] + '.ty', lf_dn_rvn + '.inputX', f=True)\\n cmds.connectAttr(lf_dn_rvn + '.outputX', lf_lidrails + '.offsetbottom[0].offsetbottom_FloatValue', f=True)\\n # mid - inner\\n lf_lid01_dm01_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_dm01_addDoubleLinear')\\n cmds.connectAttr(lf_dn[1] + '.tx', lf_lid01_dm01_adn + '.input1', f=True)\\n cmds.setAttr(lf_lid01_dm01_adn + '.input2', 0.333)\\n cmds.connectAttr(lf_lid01_dm01_adn + '.output', lf_lidrails + '.offsetbottom[1].offsetbottom_Position', f=True)\\n cmds.connectAttr(lf_dn[1] + '.ty', lf_dn_rvn + '.inputY', f=True)\\n cmds.connectAttr(lf_dn_rvn + '.outputY', lf_lidrails + '.offsetbottom[1].offsetbottom_FloatValue', f=True)\\n # mid - outer\\n lf_lid01_dm02_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_dm02_addDoubleLinear')\\n cmds.connectAttr(lf_dn[2] + '.tx', lf_lid01_dm02_adn + '.input1', f=True)\\n cmds.setAttr(lf_lid01_dm02_adn + '.input2', 0.666)\\n cmds.connectAttr(lf_lid01_dm02_adn + '.output', lf_lidrails + '.offsetbottom[2].offsetbottom_Position', f=True)\\n cmds.connectAttr(lf_dn[2] + '.ty', lf_dn02_rvn + '.inputX', f=True)\\n cmds.connectAttr(lf_dn02_rvn + '.outputX', lf_lidrails + '.offsetbottom[2].offsetbottom_FloatValue', f=True)\\n # outer\\n lf_lid01_do01_adn = cmds.createNode('addDoubleLinear', n='lf_lid01_do01_addDoubleLinear')\\n cmds.connectAttr(lf_dn[3] + '.tx', lf_lid01_do01_adn + '.input1', f=True)\\n cmds.setAttr(lf_lid01_do01_adn + '.input2', 1.0)\\n cmds.connectAttr(lf_lid01_do01_adn + '.output', lf_lidrails + '.offsetbottom[3].offsetbottom_Position', f=True)\\n cmds.connectAttr(lf_dn[3] + '.ty', lf_dn02_rvn + '.inputY')\\n cmds.connectAttr(lf_dn02_rvn + '.outputY', lf_lidrails + '.offsetbottom[3].offsetbottom_FloatValue', f=True)\\n\\n # rt_up =========\\n\\n # inner\\n rt_lid01_ui01_asn = cmds.createNode('plusMinusAverage', n='rt_lid01_ui01_plusMinusAverage')\\n cmds.setAttr(rt_lid01_ui01_asn + '.input1D[0]', 1.0)\\n cmds.connectAttr(rt_up[0] + '.tx', rt_lid01_ui01_asn + '.input1D[1]', f=True)\\n cmds.connectAttr(rt_lid01_ui01_asn + '.output1D', rt_lidrails + '.offsettop[3].offsettop_Position', f=True)\\n cmds.connectAttr(rt_up[0] + '.ty', rt_lidrails + '.offsettop[3].offsettop_FloatValue', f=True)\\n # mid -inner\\n rt_lid01_um01_mdn = cmds.createNode('multDoubleLinear', n='rt_lid01_um01_multDoubleLinear')\\n rt_lid01_um01_adn = cmds.createNode('addDoubleLinear', n='rt_lid01_um01_addDoubleLinear')\\n cmds.connectAttr(rt_up[2] + '.tx', rt_lid01_um01_mdn + '.input1', f=True)\\n cmds.setAttr(rt_lid01_um01_mdn + '.input2', -1.0)\\n cmds.connectAttr(rt_lid01_um01_mdn + '.output', rt_lid01_um01_adn + '.input1', f=True)\\n cmds.setAttr(rt_lid01_um01_adn + '.input2', 0.333)\\n cmds.connectAttr(rt_lid01_um01_adn + '.output', rt_lidrails + '.offsettop[2].offsettop_Position', f=True)\\n cmds.connectAttr(rt_up[2] + '.ty', rt_lidrails + '.offsettop[2].offsettop_FloatValue', f=True)\\n\\n # mid - outer\\n rt_lid01_um02_mdn = cmds.createNode('multDoubleLinear', n='rt_lid01_um02_multDoubleLinear')\\n rt_lid01_um02_adn = cmds.createNode('addDoubleLinear', n='rt_lid01_um02_addDoubleLinear')\\n cmds.connectAttr(rt_up[1] + '.tx', rt_lid01_um02_mdn + '.input1', f=True)\\n cmds.setAttr(rt_lid01_um02_mdn + '.input2', -1.0)\\n cmds.connectAttr(rt_lid01_um02_mdn + '.output', rt_lid01_um02_adn + '.input1', f=True)\\n cmds.setAttr(rt_lid01_um02_adn + '.input2', 0.666)\\n cmds.connectAttr(rt_lid01_um02_adn + '.output', rt_lidrails + '.offsettop[1].offsettop_Position', f=True)\\n cmds.connectAttr(rt_up[1] + '.ty', rt_lidrails + '.offsettop[1].offsettop_FloatValue', f=True)\\n\\n # outer\\n rt_lid01_uo_mdn = cmds.createNode('multDoubleLinear', n='rt_lid01_uo_multDoubleLinear')\\n cmds.connectAttr(rt_up[3] + '.tx', rt_lid01_uo_mdn + '.input1', f=True)\\n cmds.setAttr(rt_lid01_uo_mdn + '.input2', -1.0)\\n cmds.connectAttr(rt_lid01_uo_mdn + '.output', rt_lidrails + '.offsettop[0].offsettop_Position', f=True)\\n cmds.connectAttr(rt_up[3] + '.ty', rt_lidrails + '.offsettop[0].offsettop_FloatValue', f=True)\\n\\n # rt_dn =========\\n\\n rt_dn_rvn = cmds.createNode('reverse', n='rt_lid01_dn01_reverse')\\n rt_dn02_rvn = cmds.createNode('reverse', n='rt_lid01_dn02_reverse')\\n # inner\\n rt_lid01_di01_asn = cmds.createNode('plusMinusAverage', n='rt_lid01_di01_plusMinusAverage')\\n cmds.setAttr(rt_lid01_di01_asn + '.operation', 2)\\n cmds.setAttr(rt_lid01_di01_asn + '.input1D[0]', 1.0)\\n cmds.connectAttr(rt_dn[0] + '.tx', rt_lid01_di01_asn + '.input1D[1]', f=True)\\n cmds.connectAttr(rt_lid01_di01_asn + '.output1D', rt_lidrails + '.offsetbottom[0].offsetbottom_Position', f=True)\\n cmds.connectAttr(rt_dn[0] + '.ty', rt_dn_rvn + '.inputX', f=True)\\n cmds.connectAttr(rt_dn_rvn + '.outputX', rt_lidrails + '.offsetbottom[0].offsetbottom_FloatValue', f=True)\\n # mid - inner\\n rt_lid01_dm01_asn = cmds.createNode('plusMinusAverage', n='rt_lid01_dm01_plusMinusAverage')\\n cmds.setAttr(rt_lid01_dm01_asn + '.operation', 2)\\n cmds.setAttr(rt_lid01_dm01_asn + '.input1D[0]', 0.333)\\n cmds.connectAttr(rt_dn[2] + '.tx', rt_lid01_dm01_asn + '.input1D[1]', f=True)\\n cmds.connectAttr(rt_lid01_dm01_asn + '.output1D', rt_lidrails + '.offsetbottom[1].offsetbottom_Position', f=True)\\n cmds.connectAttr(rt_dn[2] + '.ty', rt_dn_rvn + '.inputY', f=True)\\n cmds.connectAttr(rt_dn_rvn + '.outputY', rt_lidrails + '.offsetbottom[1].offsetbottom_FloatValue', f=True)\\n # mid - outer\\n rt_lid01_dm02_asn = cmds.createNode('plusMinusAverage', n='rt_lid01_dm02_plusMinusAverage')\\n cmds.setAttr(rt_lid01_dm02_asn + '.operation', 2)\\n cmds.setAttr(rt_lid01_dm02_asn + '.input1D[0]', 0.666)\\n cmds.connectAttr(rt_dn[1] + '.tx', rt_lid01_dm02_asn + '.input1D[1]', f=True)\\n cmds.connectAttr(rt_lid01_dm02_asn + '.output1D', rt_lidrails + '.offsetbottom[2].offsetbottom_Position', f=True)\\n cmds.connectAttr(rt_dn[1] + '.ty', rt_dn02_rvn + '.inputX', f=True)\\n cmds.connectAttr(rt_dn02_rvn + '.outputX', rt_lidrails + '.offsetbottom[2].offsetbottom_FloatValue', f=True)\\n # outer\\n rt_lid01_do01_mdn = cmds.createNode('multDoubleLinear', n='rt_lid01_do01_multDoubleLinear')\\n cmds.connectAttr(rt_dn[3] + '.tx', rt_lid01_do01_mdn + '.input1', f=True)\\n cmds.setAttr(rt_lid01_do01_mdn + '.input2', -1.0)\\n cmds.connectAttr(rt_lid01_do01_mdn + '.output', rt_lidrails + '.offsetbottom[3].offsetbottom_Position', f=True)\\n cmds.connectAttr(rt_dn[3] + '.ty', rt_dn02_rvn + '.inputY', f=True)\\n cmds.connectAttr(rt_dn02_rvn + '.outputY', rt_lidrails + '.offsetbottom[3].offsetbottom_FloatValue')\",\n \"def _activate_IR(self):\\n self.IR_threshold = 2000\\n\\n self.IR_sensors = [self.getLightSensor('ls' + str(i)) for i in range(self.num_light_sensors)]\\n map((lambda s: s.enable(self.timestep)), self.IR_sensors) # Enable all distance sensors\",\n \"def run(self, outlets):\\n self.logger.info(\\\"Turning on Power Outlet(s): {0}\\\".format(outlets))\\n outlets = self._clean_outlets(outlets)\\n try:\\n self.naxxx.turn_on_switches(outlets, turn_others_off=True)\\n except (TypeError, timeout) as error:\\n self.logger.error(error)\\n raise NaxxxError(\\\"Unable to connect to the Naxxx - check your LAN connection.\\\")\\n return\",\n \"def __init__(self):\\n self.label = \\\"Data Assistant\\\"\\n self.alias = \\\"dla\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [Append, Stage, NewFile, Preview, Replace]\",\n \"def set_switches_from_rule_nbr(self):\\n for rule_switch, enabled in zip(CA_World.bin_0_to_7, self.int_to_8_bit_binary(self.rule_nbr)):\\n SimEngine.gui_set(rule_switch, value=(True if enabled=='1' else False))\",\n \"def add_automl_args(argparser, arch_choices=None, enable_pretrained=False):\\n argparser.add_argument('--amc', dest='AMC', action='store_true', help='AutoML Compression')\\n group = argparser.add_argument_group('AutoML Compression Arguments')\\n group.add_argument('--amc-protocol', choices=[\\\"mac-constrained\\\",\\n \\\"param-constrained\\\",\\n \\\"accuracy-guaranteed\\\",\\n \\\"mac-constrained-experimental\\\"],\\n default=\\\"mac-constrained\\\", help='Compression-policy search protocol')\\n group.add_argument('--amc-ft-epochs', type=int, default=1,\\n help='The number of epochs to fine-tune each discovered network')\\n group.add_argument('--amc-save-chkpts', action='store_true', default=False,\\n help='Save checkpoints of all discovered networks')\\n group.add_argument('--amc-action-range', type=float, nargs=2, default=[0.0, 0.80],\\n help='Density action range (a_min, a_max)')\\n group.add_argument('--amc-heatup-epochs', type=int, default=100,\\n help='The number of epochs for heatup/exploration')\\n group.add_argument('--amc-training-epochs', type=int, default=300,\\n help='The number of epochs for training/exploitation')\\n group.add_argument('--amc-reward-frequency', type=int, default=None,\\n help='Reward computation frequency (measured in agent steps)')\\n group.add_argument('--amc-target-density', type=float,\\n help='Target density of the network we are seeking')\\n group.add_argument('--amc-agent-algo', choices=[\\\"ClippedPPO-continuous\\\",\\n \\\"ClippedPPO-discrete\\\",\\n \\\"DDPG\\\",\\n \\\"Random-policy\\\"],\\n default=\\\"ClippedPPO-continuous\\\",\\n help=\\\"The agent algorithm to use\\\")\\n # group.add_argument('--amc-thinning', action='store_true', default=False,\\n # help='Perform netowrk thinning after altering each layer')\\n group.add_argument('--amc-ft-frequency', type=int, default=None,\\n help='How many action-steps between fine-tuning.\\\\n'\\n 'By default there is no fine-tuning between steps.')\",\n \"def __init__(self):\\n \\n self.label = \\\"ArcSDM Tools\\\"\\n self.alias = \\\"ArcSDM\\\" \\n\\n # List of tool classes associated with this toolbox\\n self.tools = [PartitionNNInputFiles, CombineNNOutputFiles, NeuralNetworkOutputFiles, NeuralNetworkInputFiles, \\n CalculateWeightsTool,SiteReductionTool,CategoricalMembershipToool,\\n CategoricalAndReclassTool, TOCFuzzificationTool, CalculateResponse, LogisticRegressionTool, Symbolize, \\n ROCTool, AgterbergChengCITest, AreaFrequencyTable, GetSDMValues, GrandWofe]\",\n \"def enable():\\n if not _status_apf():\\n return __apf_cmd(\\\"-s\\\")\",\n \"def manipulator(self):\\n manipulator = ConfigurationManipulator()\\n for flag in OPT_FLAGS:\\n manipulator.add_parameter(\\n EnumParameter(flag,\\n ['on', 'off', 'default']))\\n return manipulator\",\n \"def main():\\n parser = OptionParser()\\n parser.add_option('-v', \\\"--verbose\\\", action=\\\"store_true\\\", dest=\\\"verbose\\\", default=False,\\n help=\\\"Print more debug info\\\")\\n parser.add_option(\\\"--list\\\", action=\\\"store_true\\\", dest=\\\"list\\\", default=False,\\n help=\\\"List the available drivers\\\")\\n\\n opgroup = OptionGroup(parser, \\\"Operational options\\\")\\n opgroup.add_option('-d', '--driver', action=\\\"store\\\", type=\\\"choice\\\", dest=\\\"driver\\\", default=\\\"sabertooth\\\", choices=drivers.driverlist.keys(),\\n help=\\\"Drive using this driver [Default: sabertooth]\\\")\\n opgroup.add_option('-s', '--arduino', action=\\\"store\\\", type=\\\"string\\\", dest=\\\"arduino_serial\\\", default=None,\\n help=\\\"Serial number of the on-board arduino [Default: Pick a random one]\\\")\\n parser.add_option_group(opgroup)\\n\\n netgroup = OptionGroup(parser, \\\"Network options\\\")\\n netgroup.add_option('-a', '--host', action=\\\"store\\\", type=\\\"string\\\", dest=\\\"host\\\", default=\\\"\\\",\\n help=\\\"Host/address to listen on [Default: all (empty string)]\\\")\\n netgroup.add_option('-p', '--port', action=\\\"store\\\", type=\\\"int\\\", dest=\\\"port\\\", default=9999,\\n help=\\\"Port to listen on [Default: 9999]\\\")\\n parser.add_option_group(netgroup)\\n\\n smcgroup = OptionGroup(parser, \\\"SMC-based driver options\\\",\\n \\\"Needed when the driver is oriented around a pair of Pololu Simple Motor Controllers\\\")\\n smcgroup.add_option(\\\"-l\\\", \\\"--left\\\", type=\\\"string\\\", dest=\\\"left\\\", default='3000-6A06-3142-3732-7346-2543',\\n help=\\\"The serial number of the left controller [3000-6A06-3142-3732-7346-2543]\\\")\\n smcgroup.add_option(\\\"-r\\\", \\\"--right\\\", type=\\\"string\\\", dest=\\\"right\\\", default=\\\"3000-6F06-3142-3732-4454-2543\\\",\\n help=\\\"The serial number of the right controller [3000-6F06-3142-3732-4454-2543]\\\")\\n smcgroup.add_option(\\\"-c\\\", \\\"--smccmd\\\", type=\\\"string\\\", dest=\\\"smccmd\\\", default=\\\"/root/pololu/smc_linux/SmcCmd\\\",\\n help=\\\"The path to the SmcCmd utility [/root/pololu/smc_linux/SmcCmd]\\\")\\n parser.add_option_group(smcgroup)\\n\\n # parse the arguments\\n options, args = parser.parse_args()\\n\\n list_and_exit = False\\n if options.list:\\n list_and_exit = True\\n else:\\n # make sure we specified a valid driver\\n if not options.driver:\\n print \\\"You must specify a driver!\\\"\\n list_and_exit = True\\n elif options.driver not in drivers.driverlist:\\n print \\\"Invalid driver specified: %s\\\" % options.driver\\n list_and_exit = True\\n\\n # if we requested a driver list, list drivers and then exit\\n if list_and_exit:\\n print \\\"Available drivers:\\\"\\n for name, info in drivers.driverlist.items():\\n print \\\"%s %s\\\" % (name.ljust(30), info[0])\\n\\n return 0\\n\\n # otherwise, try to create the robot and then start the servers\\n robot = Robot(**vars(options))\\n robot.reset()\\n print \\\"Robot initialized successfully...\\\"\\n\\n # create the robot\\n server = TCPServer((options.host, options.port), ConnectionHandler)\\n server.last_request = 0\\n server.robot = robot\\n\\n # used to limit control of the robot to a single connection\\n server.control_lock = threading.RLock()\\n\\n # create the monitor\\n server_monitor = monitor.ServerMonitor(server, robot)\\n server.monitor = server_monitor\\n server_monitor.start()\\n\\n # start the robot and begin accepting requests\\n print \\\"Starting server...\\\"\\n try:\\n server.serve_forever()\\n except KeyboardInterrupt:\\n server.is_shutting_down.set()\\n return 0\\n finally:\\n print \\\"Shutting down...\\\"\\n server_monitor.stop()\\n server.shutdown()\\n robot.shutdown()\",\n \"def processCommandList():\\n\\n try:\\n # Assume that maya.cmds.about and maya.cmds.internalVar are already registered\\n #\\n commandListPath = os.path.realpath( os.environ[ 'MAYA_LOCATION' ] )\\n platform = maya.cmds.about( os=True )\\n commandListPath = os.path.join( commandListPath, commandListLocations[platform], 'commandList' )\\n\\n file = open( commandListPath, 'r' )\\n for line in file:\\n commandName, library = line.split()\\n if not commandName in maya.cmds.__dict__:\\n maya.cmds.__dict__[commandName] = __makeStubFunc( commandName, library )\\n except:\\n sys.stderr.write(\\\"Unable to process commandList %s\\\" % commandListPath)\\n raise\",\n \"def setup_platform(hass, config, add_devices, discovery_info=None):\\n switches = []\\n for coil in config.get(\\\"coils\\\"):\\n switches.append(ModbusCoilSwitch(\\n coil.get(CONF_NAME),\\n coil.get(CONF_SLAVE),\\n coil.get(CONF_COIL)))\\n add_devices(switches)\",\n \"def all_off():\\n print(\\\"Climate is within set parameters; toggling systems off if any are on\\\")\\n GPIO.output(HEATPIN, RELAYOFF)\\n GPIO.output(COOLPIN, RELAYOFF)\\n GPIO.output(FANPIN, RELAYOFF)\\n time.sleep(30)\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def setEnableCondition(*args):\",\n \"def enable_amplitude_modulation(self):\\n self.write(\\\":SOUR:AM:STAT ON\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5408981","0.5334635","0.4870005","0.48662877","0.48420778","0.48191276","0.48072937","0.47955528","0.47886992","0.4721579","0.46996623","0.46858644","0.46583447","0.46001318","0.46000558","0.45971966","0.45952561","0.45923606","0.45860842","0.4581945","0.4569265","0.4560867","0.45539838","0.45539838","0.45539838","0.45539838","0.45539838","0.45539838","0.45539838","0.45539838","0.45539838","0.45539838","0.45539838","0.4543517","0.45288238","0.45162514","0.45041105","0.44851783","0.4484335","0.44670928","0.44612542","0.44547588","0.44475576","0.44448507","0.4441777","0.44364095","0.44286567","0.4424038","0.4419744","0.4413379","0.4400196","0.43963817","0.43914363","0.43895745","0.43889365","0.43873715","0.4384038","0.4378099","0.43757486","0.4374828","0.4366817","0.43637282","0.4362169","0.43571594","0.43559936","0.4355484","0.43517998","0.4351445","0.43493477","0.43461505","0.4344757","0.43376175","0.43301374","0.43275473","0.43235284","0.43228373","0.432003","0.43148223","0.4313999","0.43123552","0.43105492","0.43066293","0.430413","0.42950013","0.4294756","0.42895803","0.4275367","0.4274593","0.42726704","0.42726704","0.42726704","0.42726704","0.42726704","0.42726704","0.42726704","0.42726704","0.42726704","0.42726704","0.42726704","0.42657256"],"string":"[\n \"0.5408981\",\n \"0.5334635\",\n \"0.4870005\",\n \"0.48662877\",\n \"0.48420778\",\n \"0.48191276\",\n \"0.48072937\",\n \"0.47955528\",\n \"0.47886992\",\n \"0.4721579\",\n \"0.46996623\",\n \"0.46858644\",\n \"0.46583447\",\n \"0.46001318\",\n \"0.46000558\",\n \"0.45971966\",\n \"0.45952561\",\n \"0.45923606\",\n \"0.45860842\",\n \"0.4581945\",\n \"0.4569265\",\n \"0.4560867\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.45539838\",\n \"0.4543517\",\n \"0.45288238\",\n \"0.45162514\",\n \"0.45041105\",\n \"0.44851783\",\n \"0.4484335\",\n \"0.44670928\",\n \"0.44612542\",\n \"0.44547588\",\n \"0.44475576\",\n \"0.44448507\",\n \"0.4441777\",\n \"0.44364095\",\n \"0.44286567\",\n \"0.4424038\",\n \"0.4419744\",\n \"0.4413379\",\n \"0.4400196\",\n \"0.43963817\",\n \"0.43914363\",\n \"0.43895745\",\n \"0.43889365\",\n \"0.43873715\",\n \"0.4384038\",\n \"0.4378099\",\n \"0.43757486\",\n \"0.4374828\",\n \"0.4366817\",\n \"0.43637282\",\n \"0.4362169\",\n \"0.43571594\",\n \"0.43559936\",\n \"0.4355484\",\n \"0.43517998\",\n \"0.4351445\",\n \"0.43493477\",\n \"0.43461505\",\n \"0.4344757\",\n \"0.43376175\",\n \"0.43301374\",\n \"0.43275473\",\n \"0.43235284\",\n \"0.43228373\",\n \"0.432003\",\n \"0.43148223\",\n \"0.4313999\",\n \"0.43123552\",\n \"0.43105492\",\n \"0.43066293\",\n \"0.430413\",\n \"0.42950013\",\n \"0.4294756\",\n \"0.42895803\",\n \"0.4275367\",\n \"0.4274593\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42726704\",\n \"0.42657256\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7597153"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81598,"cells":{"query":{"kind":"string","value":"Return a dict mapping lamp names to tuples of (peak_wavelength, bandwidth), in nm, where bandwidth is the minimum width required to contain 75% of the spectral intensity of the lamp output."},"document":{"kind":"string","value":"def get_lamp_specs(self):\n return {lamp: self._LAMP_SPECS[lamp] for lamp in self._available_lamps}"},"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 stubb_fitlers(wave_min=350., wave_max=1050):\n throughPath = os.path.join(getPackageDir('throughputs'), 'baseline')\n bps = {}\n lsstKeys = ['u', 'y']\n bps = {}\n for key in lsstKeys:\n bp = np.loadtxt(os.path.join(throughPath, 'total_'+key+'.dat'),\n dtype=zip(['wave', 'trans'], [float]*2))\n bpTemp = Bandpass()\n good = np.where((bp['trans'] > 0.) & (bp['wave'] > wave_min) & (bp['wave'] < wave_max))\n bpTemp.setBandpass(bp['wave'], bp['trans'], wavelen_min=bp['wave'][good].min(),\n wavelen_max=bp['wave'][good].max())\n bps[key+'_truncated'] = bpTemp\n return bps","def lamg(freq, w):\n la = lam(freq)\n return la / _np.sqrt(1.0 - (la / (2 * w)) ** 2) # wavelength in WG-62 waveguide","def _decode_35698(data):\n start_byte = 0\n n_bytes = 2\n var_id = struct.unpack('<H', data[start_byte:start_byte + n_bytes])[0]\n if var_id == 29981:\n start_byte += n_bytes\n n_bytes = 16\n min_wavelength, max_wavelength = struct.unpack(\n '<dd', data[start_byte:start_byte + n_bytes])\n return {'min_wavelength': min_wavelength,\n 'max_wavelength': max_wavelength}","def make_Bandwidth(typicalBandwidth=2500, maximumBandwidth=10000):\n\n return {'maximumBandwidth': maximumBandwidth,\n 'typicalBandwidth': typicalBandwidth\n }","def get_line_wavelengths():\n line_wavelengths = OrderedDict() ; line_ratios = OrderedDict()\n \n line_wavelengths['PaB'] = [12821]\n line_ratios['PaB'] = [1.]\n line_wavelengths['Ha'] = [6564.61]\n line_ratios['Ha'] = [1.]\n line_wavelengths['Hb'] = [4862.68]\n line_ratios['Hb'] = [1.]\n line_wavelengths['Hg'] = [4341.68]\n line_ratios['Hg'] = [1.]\n line_wavelengths['Hd'] = [4102.892]\n line_ratios['Hd'] = [1.]\n \n line_wavelengths['OIII-4363'] = [4364.436]\n line_ratios['OIII-4363'] = [1.]\n line_wavelengths['OIII'] = [5008.240, 4960.295]\n line_ratios['OIII'] = [2.98, 1]\n \n # Split doublet, if needed\n line_wavelengths['OIII4959'] = [4960.295]\n line_ratios['OIII4959'] = [1]\n line_wavelengths['OIII5007'] = [5008.240]\n line_ratios['OIII5007'] = [1]\n \n line_wavelengths['OII'] = [3727.092, 3729.875]\n line_ratios['OII'] = [1, 1.] \n \n line_wavelengths['OI-6302'] = [6302.046, 6363.67]\n line_ratios['OI-6302'] = [1, 0.33]\n\n line_wavelengths['NeIII'] = [3869]\n line_ratios['NeIII'] = [1.]\n line_wavelengths['NeV'] = [3346.8]\n line_ratios['NeV'] = [1.]\n line_wavelengths['NeVI'] = [3426.85]\n line_ratios['NeVI'] = [1.]\n \n line_wavelengths['SIII'] = [9068.6, 9530.6][::-1]\n line_ratios['SIII'] = [1, 2.44][::-1]\n \n # Split doublet, if needed\n line_wavelengths['SIII9068'] = [9068.6]\n line_ratios['SIII9068'] = [1]\n line_wavelengths['SIII9531'] = [9530.6]\n line_ratios['SIII9531'] = [1]\n \n line_wavelengths['SII'] = [6718.29, 6732.67]\n line_ratios['SII'] = [1., 1.] \n \n line_wavelengths['HeII'] = [4687.5]\n line_ratios['HeII'] = [1.]\n line_wavelengths['HeI-5877'] = [5877.2]\n line_ratios['HeI-5877'] = [1.]\n line_wavelengths['HeI-3889'] = [3889.5]\n line_ratios['HeI-3889'] = [1.]\n line_wavelengths['HeI-1083'] = [10830.]\n line_ratios['HeI-1083'] = [1.]\n \n line_wavelengths['MgII'] = [2799.117]\n line_ratios['MgII'] = [1.]\n \n line_wavelengths['CIV-1549'] = [1549.480]\n line_ratios['CIV-1549'] = [1.]\n line_wavelengths['CIII-1908'] = [1908.734]\n line_ratios['CIII-1908'] = [1.]\n line_wavelengths['OIII-1663'] = [1665.85]\n line_ratios['OIII-1663'] = [1.]\n line_wavelengths['HeII-1640'] = [1640.4]\n line_ratios['HeII-1640'] = [1.]\n \n line_wavelengths['NII'] = [6549.86, 6585.27]\n line_ratios['NII'] = [1., 3]\n line_wavelengths['NIII-1750'] = [1750.]\n line_ratios['NIII-1750'] = [1.]\n line_wavelengths['NIV-1487'] = [1487.]\n line_ratios['NIV-1487'] = [1.]\n line_wavelengths['NV-1240'] = [1240.81]\n line_ratios['NV-1240'] = [1.]\n\n line_wavelengths['Lya'] = [1215.4]\n line_ratios['Lya'] = [1.]\n \n line_wavelengths['Lya+CIV'] = [1215.4, 1549.49]\n line_ratios['Lya+CIV'] = [1., 0.1]\n \n line_wavelengths['Ha+SII'] = [6564.61, 6718.29, 6732.67]\n line_ratios['Ha+SII'] = [1., 1./10, 1./10]\n line_wavelengths['Ha+SII+SIII+He'] = [6564.61, 6718.29, 6732.67, 9068.6, 9530.6, 10830.]\n line_ratios['Ha+SII+SIII+He'] = [1., 1./10, 1./10, 1./20, 2.44/20, 1./25.]\n\n line_wavelengths['Ha+NII+SII+SIII+He'] = [6564.61, 6549.86, 6585.27, 6718.29, 6732.67, 9068.6, 9530.6, 10830.]\n line_ratios['Ha+NII+SII+SIII+He'] = [1., 1./(4.*4), 3./(4*4), 1./10, 1./10, 1./20, 2.44/20, 1./25.]\n \n line_wavelengths['OIII+Hb'] = [5008.240, 4960.295, 4862.68]\n line_ratios['OIII+Hb'] = [2.98, 1, 3.98/6.]\n \n line_wavelengths['OIII+Hb+Ha'] = [5008.240, 4960.295, 4862.68, 6564.61]\n line_ratios['OIII+Hb+Ha'] = [2.98, 1, 3.98/10., 3.98/10.*2.86]\n\n line_wavelengths['OIII+Hb+Ha+SII'] = [5008.240, 4960.295, 4862.68, 6564.61, 6718.29, 6732.67]\n line_ratios['OIII+Hb+Ha+SII'] = [2.98, 1, 3.98/10., 3.98/10.*2.86*4, 3.98/10.*2.86/10.*4, 3.98/10.*2.86/10.*4]\n\n line_wavelengths['OIII+OII'] = [5008.240, 4960.295, 3729.875]\n line_ratios['OIII+OII'] = [2.98, 1, 3.98/4.]\n \n line_wavelengths['OII+Ne'] = [3729.875, 3869]\n line_ratios['OII+Ne'] = [1, 1./5]\n \n return line_wavelengths, line_ratios","def mel_frequencies(n_mels=128, fmin=0.0, fmax=11025.0, htk=False):\n\n # 'Center freqs' of mel bands - uniformly spaced between limits\n min_mel = hz_to_mel(fmin, htk=htk)\n max_mel = hz_to_mel(fmax, htk=htk)\n\n mels = np.linspace(min_mel, max_mel, n_mels)\n\n return mel_to_hz(mels, htk=htk)","def mel_frequencies(n_mels=128, fmin=0.0, fmax=11025.0, htk=False):\n\n # 'Center freqs' of mel bands - uniformly spaced between limits\n min_mel = hz_to_mel(fmin, htk=htk)\n max_mel = hz_to_mel(fmax, htk=htk)\n\n mels = np.linspace(min_mel, max_mel, n_mels)\n\n return mel_to_hz(mels, htk=htk)","def calculate_wavelength_metric(wavelength_min, wavelength_max):\n length_max = np.log(550) * 2\n wavelength = np.abs(wavelength_max + wavelength_min) / 2\n log_wl = np.log(wavelength)\n default_met = np.array(log_wl / length_max)\n scaled_met = 1.75 * (default_met - 0.5) + 0.5\n if wavelength == 0:\n return 0\n else:\n return scaled_met.clip(min=10e-11, max=1)","def _get_lsp_config_frr_bandwidth(self):\n return self.__lsp_config_frr_bandwidth","def wavelength_solution(file_name):\n file_data = read_file(file_name)\n header_data = file_data[0]\n image_data = file_data[1]\n\n range_begin = header_data['CRVAL3']\n pixel_begin = header_data['CRPIX3']\n step_size = header_data['CD3_3']\n steps = len(image_data)\n range_end = range_begin + steps * step_size\n return {'begin': range_begin, 'end': range_end, 'steps': steps}","def get_nlth_dict(rms_uKarcmin_T,type,lmax,spectra=None,rms_uKarcmin_pol=None,beamfile=None):\n\n if beamfile is not None:\n l,bl=np.loadtxt(beamfile,unpack=True)\n else:\n bl=np.ones(lmax+2)\n\n lth=np.arange(2,lmax+2)\n nl_th={}\n if spectra is None:\n nl_th['TT']=np.ones(lmax)*(rms_uKarcmin_T*np.pi/(60*180))**2/bl[2:lmax+2]**2\n if type=='Dl':\n nl_th['TT']*=lth*(lth+1)/(2*np.pi)\n return nl_th\n else:\n if rms_uKarcmin_pol is None:\n rms_uKarcmin_pol=rms_uKarcmin_T*np.sqrt(2)\n for spec in spectra:\n nl_th[spec]=np.zeros(lmax)\n nl_th['TT']=np.ones(lmax)*(rms_uKarcmin_T*np.pi/(60*180))**2/bl[:lmax]**2\n nl_th['EE']=np.ones(lmax)*(rms_uKarcmin_pol*np.pi/(60*180))**2/bl[:lmax]**2\n nl_th['BB']=np.ones(lmax)*(rms_uKarcmin_pol*np.pi/(60*180))**2/bl[:lmax]**2\n if type=='Dl':\n for spec in spectra:\n nl_th[spec]*=lth*(lth+1)/(2*np.pi)\n return(nl_th)","def storeWavelengths(self, nm):\n pre = \"w,0\"\n d = {\"wavelength_nm\": list(nm)}\n self._writeline(pre, str(d))","def sans_monitor() -> dict:\n return {**beamline.beamline(scatter=False), **tof.elastic_wavelength('tof')}","def _lookup_bands(platform, wavelengths):\r\n wave_bands = {\r\n Platform.Landsat5: {\r\n \"blue\": \"1\",\r\n \"green\": \"2\",\r\n \"red\": \"3\",\r\n \"nir\": \"4\",\r\n \"swir1\": \"5\",\r\n \"tirs\": \"6\",\r\n \"swir2\": \"7\",\r\n },\r\n Platform.Landsat7: {\r\n \"blue\": \"1\",\r\n \"green\": \"2\",\r\n \"red\": \"3\",\r\n \"nir\": \"4\",\r\n \"swir1\": \"5\",\r\n \"tirs1\": \"6_VCID_1\",\r\n \"tirs2\": \"6_VCID_2\",\r\n \"swir2\": \"7\",\r\n \"pan\": \"8\",\r\n },\r\n Platform.Landsat8: {\r\n \"aerosol\": \"1\",\r\n \"blue\": \"2\",\r\n \"green\": \"3\",\r\n \"red\": \"4\",\r\n \"nir\": \"5\",\r\n \"swir1\": \"6\",\r\n \"swir2\": \"7\",\r\n \"pan\": \"8\",\r\n \"cirrus\": \"9\",\r\n \"tirs1\": \"10\",\r\n \"tirs2\": \"11\",\r\n },\r\n Platform.Sentinel2: {\r\n \"aerosol\": \"0\",\r\n \"blue\": \"1\",\r\n \"green\": \"2\",\r\n \"red\": \"3\",\r\n \"rededge1\": \"4\",\r\n \"rededge2\": \"5\",\r\n \"rededge3\": \"6\",\r\n \"nir\": \"7\",\r\n \"rededge4\": \"8\",\r\n \"watervapor\": \"9\",\r\n \"cirrus\": \"10\",\r\n \"swir1\": \"11\",\r\n \"swir2\": \"12\",\r\n },\r\n }\r\n\r\n return [wave_bands[platform][wavelength.lower()] for wavelength in wavelengths]","def preprocessing(self, spectra, windownum, peaknum):\n sampleDict = {}\n for spectrum in spectra:\n assert spectrum.getAnnotation() is None\n parentMass = spectrum.getParentMass()\n winSize = parentMass / windownum\n winList = [0]\n mass = 0\n for k in range(windownum+1):\n mass = mass + winSize\n winList.append(mass)\n \n i = 1 \n selecpeaks = []\n peaks = []\n for peak in spectrum.getPeaks():\n mz = peak.getMz()\n while i < len(winList)-1: \n if mz > winList[i]: \n i += 1\n if peaks != []:\n temppeaks = self.sortedPeak(peaks,peaknum)\n selecpeaks.extend(temppeaks)\n peaks = []\n else: \n peaks.append(peak)\n break\n if i >= len(winList) : break \n title = spectrum.getTitle() \n sampleDict[title] = selecpeaks\n# print spectrum.getParentMass()\n# print spectrum.getTitle()\n# break\n return sampleDict","def getPeakProperties(self):\n peaks = {}\n for pname in self.properties:\n peaks[pname] = self.peak_fitter.getPeakProperty(pname)\n\n # x,y,z corrections.\n if (pname == \"x\"):\n peaks[pname] -= float(self.peak_finder.margin)\n\n elif (pname == \"y\"):\n peaks[pname] -= float(self.peak_finder.margin)\n \n elif (pname == \"z\"):\n peaks[pname] = self.peak_fitter.rescaleZ(peaks[pname])\n\n return peaks","def wavelength(self):\n return self.get(self._names[\"wavelength\"])","def _init_meg_map_dict(bands, length=0):\n\n # Initialize dictionary\n meg_map = dict()\n\n # Add oscillation bands\n for band in bands:\n meg_map[band] = np.zeros(length)\n\n return meg_map","def get_log_melspectrogram(audio, sr = 22050, hop_length = 220, n_fft = 1024, n_mels = 80, fmin = 64, fmax = 8000):\n bands = librosa.feature.melspectrogram(\n y=audio, sr=sr, hop_length=hop_length, n_fft=n_fft, n_mels=n_mels, fmin=fmin, fmax=fmax, dtype=np.float32)\n return librosa.core.power_to_db(bands, amin=1e-7)","def getBandwidth(self):\n # Use mean of the magnitudes as threshold\n threshold = np.mean([x[1] for x in self.fDomain])\n \n # Find freqencies which have magnitude greater than threshold\n nonZero = [f for f,x in self.fDomain if x > threshold]\n\n bandwidth = max(nonZero) - min(nonZero)\n return bandwidth","def bls_peakfinder(results):\n maxima = find_peaks(results.power, distance=100)[0]\n\n top_power_inds = maxima[np.argsort(results.power[maxima])[::-1]]\n\n highest_peak = results.power[top_power_inds[0]]\n next_highest_peak = results.power[top_power_inds[1]]\n\n significance = highest_peak / next_highest_peak\n\n return top_power_inds, significance","def GetWavelengths (self) :\n\t\treturn self.run(\"GetWavelengths\")","def _decode_35700(data):\n start_byte = 0\n n_bytes = 2\n var_id = struct.unpack('<H', data[start_byte:start_byte + n_bytes])[0]\n if var_id == 29979:\n start_byte += n_bytes\n n_bytes = 8\n wavelength_step = struct.unpack(\n '<d', data[start_byte:start_byte + n_bytes])[0]\n return {'wavelength_step': wavelength_step}","def compute_melspecs(audio):\n return librosa.feature.melspectrogram(y=audio,\n sr=SR,\n n_mels=N_MELS,\n n_fft=N_FFT,\n hop_length=HOP_LENGTH,\n fmin=MEL_FMIN,\n fmax=MEL_FMAX)","def melfrequencies_mel_filterbank(self, num_bands, freq_min, freq_max, num_fft_bands):\n\n mel_max = self.hertz_to_mel(freq_max)\n mel_min = self.hertz_to_mel(freq_min)\n delta_mel = abs(mel_max - mel_min) / (num_bands + 1.0)\n frequencies_mel = mel_min + delta_mel * arange(0, num_bands + 2)\n lower_edges_mel = frequencies_mel[:-2]\n upper_edges_mel = frequencies_mel[2:]\n center_frequencies_mel = frequencies_mel[1:-1]\n return center_frequencies_mel, lower_edges_mel, upper_edges_mel","def wavelength(self):\n return self.getparam(\"WAVELENGTH\")","def wavelength(self):\n return self.getparam(\"WAVELENGTH\")","def mel(sr, n_fft, n_mels=128, fmin=0.0, fmax=None, htk=False):\n\n if fmax is None:\n fmax = float(sr) / 2\n\n # Initialize the weights\n n_mels = int(n_mels)\n weights = np.zeros((n_mels, int(1 + n_fft / 2)))\n\n # Center freqs of each FFT bin\n fftfreqs = librosa.fft_frequencies(sr=sr, n_fft=n_fft)\n\n # 'Center freqs' of mel bands - uniformly spaced between limits\n freqs = librosa.mel_frequencies(n_mels,\n fmin=fmin,\n fmax=fmax,\n htk=htk,\n extra=True)\n\n # Slaney-style mel is scaled to be approx constant energy per channel\n enorm = 2.0 / (freqs[2:n_mels+2] - freqs[:n_mels])\n\n for i in range(n_mels):\n # lower and upper slopes for all bins\n lower = (fftfreqs - freqs[i]) / (freqs[i+1] - freqs[i])\n upper = (freqs[i+2] - fftfreqs) / (freqs[i+2] - freqs[i+1])\n\n # .. then intersect them with each other and zero\n weights[i] = np.maximum(0, np.minimum(lower, upper)) * enorm[i]\n\n return weights","def bandwidth(configuration):\n bandwidth_dict_all = {\n \"HL\" : {'H1' : 117.4, 'L1' : 117.4},\n \"HLV\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9},\n \"HLVK\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, 'K1' : 148.9},\n \"HLVKI\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, 'K1' : 148.9, 'I1' : 117.4},\n \"GW170817\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9},\n \"GW170817_without_Virgo\" : {'H1' : 117.4, 'L1' : 117.4},\n \"GW170814\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9},\n \"design\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9 },\n \"early\" : {'H1' : 123.7, 'L1' : 123.7 },\n \"half_virgo\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9 },\n \"half_ligo\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9 },\n \"nosrm\" : {'H1' : 43, 'L1' : 43, 'V1': 58 },\n \"india\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, \"I1\" : 117.4 },\n \"kagra\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, \"I1\" : 117.4, \\\n \"K1\" : 89.0 },\n \"bala\" : {'H1' : 117.4, 'H2' : 117.4, 'L1' : 117.4, 'V1': 148.9, \\\n \"I1\" : 117.4, \"K1\" : 89.0 },\n \"sa\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, \"I1\" : 117.4, \\\n \"K1\" : 89.0 , \"S1\": 117.4},\n \"sa2\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, \"I1\" : 117.4, \\\n \"K1\" : 89.0 , \"S1\": 117.4},\n \"steve\" : {'H1' : 100.0, 'L1' : 100.0, 'V1': 100.0, \"I1\" : 100.0 },\n \"s6vsr2\" : {'H1' : 100., 'L1' : 100., 'V1': 120. }\n }\n return(bandwidth_dict_all[configuration])","def wavelength_ex(hdulist):\n wave = hdulist[1].data['loglam']\n wave = 10**wave\n\n return wave","def getBandwidths( astrobands ):\n\n slPrefix = \"Control.SpectralLineCorrelator.Slcband\"\n wbPrefix = \"Control.WidebandCorrelator.Wbcband\"\n bwSuffix = \".ControlBandPoints.bandwidth\"\n spmMpPrefix = \"SignalPath.Mapping.Astroband%d.Input1\" \n corrBandMpName = spmMpPrefix + \".corrBandNo\"\n bwMpNames = []\n for astroband in astrobands: \n corrDesStr = commands.astrobandCorrelator( astroband )\n corrBandNo = commands.queryInt( corrBandMpName%astroband )\n if corrDesStr == 'SPECTRAL':\n bwMpNames.append( \"%s%d%s\"%(slPrefix,corrBandNo,bwSuffix) )\n elif corrDesStr == 'WIDEBAND':\n bwMpNames.append( \"%s%d%s\"%(wbPrefix,corrBandNo,bwSuffix) )\n else:\n raise Exception, 'Invalid corrDesStr: '+ corrDesStr\n \n bwMpValues = commands.queryMpValues( bwMpNames )\n return bwMpValues[:]","def repackageSamples(pinsToMeasure, pinMap, nMilliBlocks, samples):\n\n channels = [None, None, None, None]\n for pinName in pinsToMeasure:\n channels[pinMap[pinName]] = ( { \"pinName\": pinName, \"isAudio\": isAudio(pinName), \"min\": [], \"max\": [] } )\n\n i = 0\n for blk in range(0, nMilliBlocks):\n for channel in channels:\n if channel != None:\n channel[\"max\"].append(ord(samples[i]))\n i += 1\n channel[\"min\"].append(ord(samples[i]))\n i += 1\n\n return channels","def waveparameterh(L):\r\n return 8.13 - ((250 - 0.7 * L) / 125) ** 3","def measure_program(self, channels: Iterable[str]) -> Dict[str, numpy.ndarray]:","def wavelength(energy):\r\n return 2 * np.pi * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy","def FindNormalizationWeights(wavelength,\n wave_resol,\n alpha_resol,\n beta_resol):\n alpha_weight = 1.0\n beta_weight = 1.0\n lambda_weight = 1.0\n\n # alpha psf weighting\n alpha_wave_cutoff = alpha_resol[0]\n alpha_a_short = alpha_resol[1]\n alpha_b_short = alpha_resol[2]\n alpha_a_long = alpha_resol[3]\n alpha_b_long = alpha_resol[4]\n if wavelength < alpha_wave_cutoff:\n alpha_weight = alpha_a_short + alpha_b_short * wavelength\n else:\n alpha_weight = alpha_a_long + alpha_b_long * wavelength\n\n # beta psf weighting\n beta_wave_cutoff = beta_resol[0]\n beta_a_short = beta_resol[1]\n beta_b_short = beta_resol[2]\n beta_a_long = beta_resol[3]\n beta_b_long = beta_resol[4]\n if wavelength < beta_wave_cutoff:\n beta_weight = beta_a_short + beta_b_short * wavelength\n else:\n beta_weight = beta_a_long + beta_b_long * wavelength\n\n # wavelength weighting\n wavecenter = wave_resol[0]\n a_ave = wave_resol[1]\n b_ave = wave_resol[2]\n c_ave = wave_resol[3]\n wave_diff = wavelength - wavecenter\n resolution = a_ave + b_ave * wave_diff + c_ave * wave_diff * wave_diff\n lambda_weight = wavelength / resolution\n weight = [alpha_weight, beta_weight, lambda_weight]\n return weight","def load_clip_times_FPTL_format(clip_list_file, \n path_to_data, \n start_times_file, \n output_dir,\n clip_window=None, \n clip_window_origin=None,\n plot_fluor_around_peaks=False,\n delay = 0.0933492779732,\n print_peak_vals=True,\n print_peak_times = True ):\n\n print \"clip_list_file\", clip_list_file\n pkl_file = open(clip_list_file, 'rb')\n data = pickle.load(pkl_file)\n print 'data', data\n\n movie_info_dict = dict()\n all_start_times_dict = load_start_times(start_times_file)\n\n all_peak_vals = dict()\n\n for key in data:\n if key != 'labels':\n movie_info = dict()\n trial = data[key]\n print 'data[labels]', data['labels']\n print 'key', key\n label = data['labels'][key]\n print label.split('_', 3)\n animal_id, date, exp_type, mouse_type = label.split('_', 3)\n name = animal_id + '_' + date + '_' + exp_type\n print name\n print mouse_type\n\n movie_info['movie_file'] = get_movie_file(name, path_to_data)\n movie_info['output_file'] = get_output_file(name, output_dir)\n peak_inds = data[key]['peak_indices']\n if 'fluor_data' in trial:\n time_stamps = trial['time_stamps']\n fluor_data = trial['fluor_data']\n else:\n print \"using decimated time series\"\n time_stamps = trial['time_stamps_decimated']\n fluor_data = trial['fluor_data_decimated']\n time_stamps = time_stamps - delay\n print \"INCLUDING DELAY from filter: \", delay\n\n\n movie_info['peak_times'] = time_stamps[peak_inds]\n movie_info['peak_vals'] = fluor_data[peak_inds]\n movie_info['name'] = name\n movie_info['start_time'] = all_start_times_dict[name]\n movie_info['mouse_type'] = mouse_type\n movie_info['interaction_start'] = None\n movie_info['interaction_end'] = None\n movie_info['mouse_type'] = mouse_type\n\n movie_info_dict[name] = movie_info\n\n all_peak_vals[name] = movie_info['peak_vals']\n\n if plot_fluor_around_peaks:\n if clip_window is not None and clip_window_origin is not None:\n plotFluorAroundPeaks(fluor_data, time_stamps, peak_inds,\n clip_window, clip_window_origin,\n output_dir, name, movie_info['start_time'])\n\n if print_peak_vals:\n output_folder = output_dir + '/peak_vals/'\n if not os.path.exists(output_folder):\n os.makedirs(output_folder)\n w = csv.writer(open(output_folder+'peak_vals.csv', \"w\"), delimiter=',')\n for key, val in all_peak_vals.items():\n w.writerow([key] + [', '.join([str(x) for x in val])])\n\n pickle.dump( all_peak_vals, open( output_folder + 'peak_vals.pkl', \"wb\" ) )\n\n\n if print_peak_times:\n output_folder = output_dir + '/peak_times/'\n if not os.path.exists(output_folder):\n os.makedirs(output_folder)\n filename = output_folder+'peak_times.txt'\n f = open(filename, 'w')\n for trial in movie_info_dict.keys():\n movie_info = movie_info_dict[trial]\n peak_times = movie_info['peak_times']\n name = movie_info['name']\n f.write(\"%s\\n\" % name)\n for val in peak_times:\n f.write(\"%f\\n\" %val)\n f.close()\n print filename\n\n\n ## Print for debugging, and to check that labels match up with blind data\n # print 'peak_inds', peak_inds, np.max(peak_inds)\n # print \"movie_info['peak_times'] \", movie_info['peak_times'] \n # print \"movie_info['peak_vals']\", movie_info['peak_vals']\n # pp = pprint.PrettyPrinter(indent=4)\n # pp.pprint( trial['labels'])\n\n return movie_info_dict","def wavelength(energy):\n return 2 * PI * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy","def fetchChannelMapping(verbose=False):\n\n # Check (from pbworks):\n #High freq. 305 473 360 170.312 \n #Medium freq. 154 424 209 140.820 \n #Low freq. 079 400 134 126.172 \n\n calibrator_chans=[55, 57, 63, 66, 68, 69, 71, 72, 73, 76, 77, 79, 83, 84, 85, 86, 90, 92, 99, 100, 101, 103, 104, 107, 108, 110, 117, 119, 121, 122, 123, 126, 130, 131, 134, 136, 137, 140, 141, 145, 147, 150, 151, 156, 157, 161, 162, 168, 170, 175, 176, 178, 185, 188, 196, 197, 201, 202, 209, 213, 217, 221, 224, 230, 235, 238, 242, 246, 254, 255, 258, 259, 260, 264, 268, 269, 271, 274, 278, 279, 280, 283, 286, 291, 295, 297, 301, 306, 307, 312, 313, 314, 317, 319, 322, 323, 325, 328, 329, 332, 341, 343, 344, 346, 347, 352, 356, 360, 361, 364, 369, 371, 382, 383, 390, 398, 401, 404, 411, 412, 414, 419]\n\n lofar2beams={}; cal2field={}; field2cal={}; cal2lofar={}; field2lofar={}\n\n zero_chan=55\n num_field_chans=366\n num_total_chans=488\n for nf in range(zero_chan,zero_chan+num_total_chans):\n lofar_chan=nf\n field_chan=lofar_chan-zero_chan\n field2lofar[field_chan]=lofar_chan\n if lofar_chan in calibrator_chans:\n cal_chan=num_field_chans+calibrator_chans.index(lofar_chan)\n if verbose:\n print lofar_chan, field_chan, ' C ', cal_chan\n lofar2beams[lofar_chan]=(field_chan,cal_chan)\n cal2field[cal_chan]=field_chan\n field2cal[field_chan]=cal_chan\n cal2lofar[cal_chan]=lofar_chan\n else:\n if verbose:\n print lofar_chan, lofar_chan-zero_chan, ' - ', ' - '\n lofar2beams[lofar_chan]=(field_chan,None)\n field2cal[field_chan]=None\n\n return lofar2beams,cal2field,field2cal,cal2lofar,field2lofar","def mel_frequencies(n_mels: int, fmin: float, fmax: float):\n low = hz_to_mel(torch.tensor(float(fmin))).item()\n high = hz_to_mel(torch.tensor(float(fmax))).item()\n mels = torch.linspace(low, high, n_mels)\n return mel_to_hz(mels)","def peaks(n, binCenters, method=\"JI\", window=100, peakAmpThresh=0.00005, valleyThresh=0.00003):\n data = zip(binCenters, n)\n binCenters = np.array(binCenters)\n firstCenter = (min(binCenters)+1.5*window)/window*window\n lastCenter = (max(binCenters)-window)/window*window\n if firstCenter < -1200: firstCenter = -1200\n if lastCenter > 3600: lastCenter = 3600\n\n\n if method == \"slope\" or method == \"hybrid\":\n peaks = {}\n peakInfo = peaksBySlope(n, binCenters, lookahead=20, delta=valleyThresh, averageHist=True)\n\n #find correspondences between peaks and valleys, and set valleys are left and right Indices\n #see the other method(s) for clarity!\n\n peakData = peakInfo[\"peaks\"]\n valleyData = peakInfo[\"valleys\"]\n\n #print len(peakData[0]), len(peakData[1])\n for i in xrange(len(peakData[0])):\n nearestIndex = findNearestIndex(valleyData[0], peakData[0][i])\n if valleyData[0][nearestIndex] < peakData[0][i]:\n leftIndex = findNearestIndex(binCenters, valleyData[0][nearestIndex])\n if (len(valleyData[0][nearestIndex+1:]) == 0):\n rightIndex = findNearestIndex(binCenters, peakData[0][i]+window/2.0)\n else:\n offset = nearestIndex+1\n nearestIndex = offset+findNearestIndex(valleyData[0][offset:], peakData[0][i])\n rightIndex = findNearestIndex(binCenters, valleyData[0][nearestIndex])\n else:\n rightIndex = findNearestIndex(binCenters, valleyData[0][nearestIndex])\n if (len(valleyData[0][:nearestIndex]) == 0):\n leftIndex = findNearestIndex(binCenters, peakData[0][i]-window/2.0)\n else:\n nearestIndex = findNearestIndex(valleyData[0][:nearestIndex], peakData[0][i])\n leftIndex = findNearestIndex(binCenters, valleyData[0][nearestIndex])\n\n pos = findNearestIndex(binCenters, peakData[0][i])\n #print binCenters[pos], peakData[1][i], binCenters[leftIndex], binCenters[rightIndex]\n peaks[pos] = [peakData[1][i], leftIndex, rightIndex]\n\n if method == \"hybrid\": slopePeaks = peaks\n \n if method == \"JI\" or method == \"ET\" or method == \"hybrid\":\n peaks = {}\n #Obtain max value per interval\n if method == \"JI\" or method == \"hybrid\":\n firstCenter = nearestJI(firstCenter)\n lastCenter = nearestJI(lastCenter)\n\n interval = firstCenter\n prevInterval = firstCenter-window\n #NOTE: All *intervals are in cents. *indices are of binCenters/n\n while interval < lastCenter:\n if method == \"ET\":\n leftIndex = findNearestIndex(binCenters, interval-window/2)\n rightIndex = findNearestIndex(binCenters, interval+window/2)\n interval += window\n elif method == \"JI\" or method == \"hybrid\":\n leftIndex = findNearestIndex(binCenters, (interval+prevInterval)/2.0)\n prevInterval = interval\n interval = nextJI(interval)\n rightIndex = findNearestIndex(binCenters, (interval+prevInterval)/2.0)\n peakPos = np.argmax(n[leftIndex:rightIndex])\n peakAmp = n[leftIndex+peakPos]\n peaks[leftIndex+peakPos] = [peakAmp, leftIndex, rightIndex]\n \n #print binCenters[leftIndex], binCenters[rightIndex], binCenters[leftIndex+peakPos], peakAmp\n #NOTE: All the indices (left/rightIndex, peakPos) are to be changed to represent respective cent \n #value corresponding to the bin. Right now, they are indices of respective binCenters in the array.\n \n if method == \"hybrid\":\n #Mix peaks from slope method and JI method.\n p1 = slopePeaks.keys()\n p2 = peaks.keys()\n allPeaks = {} #overwriting peaks dict\n for p in p1:\n nearIndex = findNearestIndex(p2, p)\n if abs(p-p2[nearIndex]) < window/2.0: p2.pop(nearIndex)\n \n for p in p1: allPeaks[p] = slopePeaks[p]\n for p in p2: allPeaks[p] = peaks[p]\n peaks = allPeaks\n\n #Filter the peaks and retain eligible peaks, also get their valley points.\n\n # ----> peakAmpThresh <---- : remove the peaks which are below that\n\n for pos in peaks.keys():\n #pos is an index in binCenters/n. DOES NOT refer to a cent value.\n if peaks[pos][0] < peakAmpThresh:\n #print \"peakAmp: \", binCenters[pos]\n peaks.pop(pos)\n\n #Check if either left or right valley is deeper than ----> valleyThresh <----.\n valleys = {}\n for pos in peaks.keys():\n leftLobe = n[peaks[pos][1]:pos]\n rightLobe = n[pos:peaks[pos][2]]\n #Sanity check: Is it a genuine peak? Size of distributions on either side of the peak should be comparable.\n if len(leftLobe) == 0 or len(rightLobe) == 0:\n continue\n if 1.0*len(leftLobe)/len(rightLobe) < 0.15 or 1.0*len(leftLobe)/len(rightLobe) > 6.67:\n #print \"size: \", binCenters[pos]\n #peaks.pop(pos)\n continue\n\n leftValleyPos = np.argmin(leftLobe)\n rightValleyPos = np.argmin(rightLobe)\n if (abs(leftLobe[leftValleyPos]-n[pos]) < valleyThresh and abs(rightLobe[rightValleyPos]-n[pos]) < valleyThresh):\n #print \"valley: \", binCenters[pos]\n peaks.pop(pos)\n else:\n valleys[peaks[pos][1]+leftValleyPos] = leftLobe[leftValleyPos]\n valleys[pos+rightValleyPos] = rightLobe[rightValleyPos]\n \n if len(peaks) > 0:\n temp1 = np.array(peaks.values())\n temp1 = temp1[:, 0]\n\n return {'peaks':[binCenters[peaks.keys()], temp1], 'valleys':[binCenters[valleys.keys()], valleys.values()]}\n else:\n return {'peaks':[[], []], 'valleys':[[], []]}","def efficiency_vs_w(wmax, wmin=10, Lmax=1000, Lmin=102.4, p=75, fmax=5.7e9,\r\n p1=database['K+'], p2=database['pi+'], p3=database['p+'],\r\n E=1e6, delta_p=1.6e-2, nw=10, nL=10, ng=50, nl=50, nf=20,\r\n resolution=0.01, w_resolution=0.01, plot=True,\r\n set_freq=5.7e9, count_L=False, count_w=True):\r\n if resolution == None:\r\n if set_freq == None:\r\n est = timing(nw*nL*ng*nl*nf*4e-05)\r\n else:\r\n est = timing(nw*nL*ng*nl*4e-05)\r\n print('Estimated total time: {0}'.format(est))\r\n else:\r\n num = int(round(np.log10(Lmax-Lmin))-1)-np.log10(resolution)+1\r\n if set_freq == None:\r\n est = timing(nw*10*num*ng*nl*nf*4e-05)\r\n else:\r\n est = timing(nw*10*num*ng*nl*4e-05)\r\n print('Estimated maximum total time: {0}'.format(est))\r\n start = time.time()\r\n if w_resolution == None:\r\n w_range = np.linspace(wmin, wmax, int(nw))\r\n plot_w, length, intensity = [], [], []\r\n for w in w_range:\r\n if count_w == True:\r\n if count_L == True:\r\n print(f'w = {w} mm')\r\n else:\r\n print(w)\r\n eff = efficiency_vs_length(w, Lmax, Lmin, p, fmax,p1, p2, p3, E,\r\n delta_p, nL, ng, nl, nf, resolution,\r\n False, set_freq, False, count_L)\r\n if eff != None:\r\n plot_w.append(w)\r\n length.append(eff[0])\r\n intensity.append(eff[2])\r\n file = open(f'Save_Data_efficiency_vs_w_{wmin}_{wmax}.txt','a')\r\n file.write(f'{[plot_w[-1], length[-1], intensity[-1]]}\\n')\r\n file.close()\r\n length, intensity = np.array(length), np.array(intensity)\r\n ratio = 1/(length*intensity)\r\n ratio *= (np.max(intensity)-np.min(intensity))/(np.max(ratio)-np.min(ratio))\r\n ratio += ((np.min(intensity))-np.min(ratio))\r\n output = [plot_w[np.argmax(ratio)], plot_w[np.argmin(length)], plot_w[np.argmin(intensity)]]\r\n else:\r\n wmax = 10*(int(wmax/10)+2)\r\n wmin = 10*int(wmin/10)\r\n n = 10\r\n while n >= w_resolution:\r\n if n == 10 and plot == True:\r\n w_range = np.arange(wmin, wmax, n)\r\n graph_w, graph_length, graph_intensity, graph_ratio = [], [], [], []\r\n for w in w_range:\r\n if count_w == True:\r\n if count_L == True:\r\n print(f'w = {w} mm')\r\n else:\r\n print(w)\r\n eff = efficiency_vs_length(w, Lmax, Lmin, p, fmax,p1, p2, p3, E,\r\n delta_p, nL, ng, nl, nf, resolution,\r\n False, set_freq, False, count_L)\r\n if eff != None:\r\n graph_w.append(w)\r\n graph_length.append(eff[0])\r\n graph_intensity.append(eff[2])\r\n graph_ratio.append(1/(eff[0]*eff[2]))\r\n i, d_ratio = 1, 0\r\n while d_ratio >= 0 and i < np.size(graph_ratio):\r\n d_ratio = graph_ratio[i] - graph_ratio[i-1]\r\n i += 1\r\n if i >= np.size(graph_ratio):\r\n output = None\r\n break\r\n graph_ratio = np.array(graph_ratio)\r\n graph_ratio *= (np.max(graph_intensity)-np.min(graph_intensity))/(np.max(graph_ratio)-np.min(graph_ratio))\r\n graph_ratio += ((np.min(graph_intensity))-np.min(graph_ratio))\r\n d = -int(np.log10(n))\r\n output = [round(graph_w[np.argmax(graph_ratio)], d),\r\n graph_length[np.argmax(graph_ratio)],\r\n graph_intensity[np.argmax(graph_ratio)]]\r\n wmax = graph_w[i-1]\r\n wmin = graph_w[i-3]\r\n n /= 10\r\n else:\r\n w_range = np.arange(wmin, wmax+n, n)\r\n plot_w, length, intensity, ratio = [], [], [], []\r\n i, d_ratio = 0, 0\r\n d = -int(np.log10(n))\r\n while d_ratio >= 0 and i < np.size(w_range):\r\n if count_w == True:\r\n if count_L == True:\r\n print(f'w = {round(w_range[i], d)} mm')\r\n else:\r\n print(round(w_range[i], d))\r\n eff = efficiency_vs_length(w_range[i], Lmax, Lmin, p, fmax,p1,\r\n p2, p3, E, delta_p, nL, ng, nl, nf,\r\n resolution, False, set_freq, False,\r\n count_L)\r\n if eff != None:\r\n plot_w.append(w_range[i])\r\n length.append(eff[0])\r\n intensity.append(eff[2])\r\n ratio.append(1/(eff[0]*eff[2]))\r\n if np.size(ratio) == 1:\r\n d_ratio = ratio[-1]\r\n else:\r\n d_ratio = ratio[-1] - ratio[-2]\r\n i += 1\r\n if i >= np.size(w_range):\r\n output = None\r\n break\r\n output = [round(plot_w[np.argmax(ratio)], d),\r\n length[np.argmax(ratio)],\r\n intensity[np.argmax(ratio)]]\r\n wmax = w_range[i-1]\r\n wmin = w_range[i-3]\r\n n /= 10\r\n if plot == True:\r\n if w_resolution != None:\r\n plot_w, length, intensity, ratio = graph_w, graph_length, graph_intensity, graph_ratio\r\n fig = plt.figure(figsize=[12, 4])\r\n ax = fig.add_subplot(1, 1, 1)\r\n line1, = ax.plot(plot_w, length, 'r', lw=2, alpha=0.6, label='Target Distance')\r\n ax2 = ax.twinx()\r\n line2, = ax2.plot(plot_w, intensity, 'g', lw=2, alpha=0.6, label='Intensity Required')\r\n line3, = ax2.plot(plot_w, ratio, 'b', lw=2, alpha=0.6, label='Reciprocal Product')\r\n ax.set_xlabel('Collimator Width / mm', fontsize=20)\r\n ax.set_ylabel('Target Distance / m', fontsize=20, color='r')\r\n ax2.set_ylabel(r'Intensity / I$_0$', fontsize=20, color='g')\r\n ax.set_xlim(np.min(plot_w), np.max(plot_w))\r\n ax.tick_params(axis='y', colors=line1.get_color())\r\n ax2.tick_params(axis='y', colors=line2.get_color())\r\n# ax.set_ylim(0)\r\n lines = [line1, line2, line3]\r\n ax.legend(lines, [l.get_label() for l in lines], loc=[0.70, 0.12], fontsize=15)\r\n ax.minorticks_on()\r\n ax2.minorticks_on()\r\n ax.grid()\r\n ax.set_title(' Minimum required target distance and proton intensity as a function of beam stopper inner radius', fontsize=16)\r\n plt.show()\r\n print(f'Total time: {timing(time.time()-start)}')\r\n return output","def _frequency_to_wavelength(freq):\n return ifc.SPEED_OF_LIGHT_METRES_PER_SECOND / freq","def get_power_spectra(self, n_psbins=50, k_min=None, k_max=None, save=True):\n\n if self.Park19:\n # chunk_z_list_HERA = [27.408, 20.306, 16.0448, 13.204, 11.17485714,\n # 9.653, 8.46933333, 7.5224, 6.74763636, 6.102,\n # 5.55569231, 5.08742857]\n chunk_z_list_HERA = [27.15742, 22.97586, 19.66073, 16.98822, 14.80234,\n 12.99172, 11.4751, 10.19206, 9.09696, 8.15475,\n 7.33818, 6.62582, 6.0006]\n else:\n chunk_z_list_HERA = [27.4, 23.4828, 20.5152, 18.1892, 16.3171, 14.7778, 13.4898, 12.3962,\n 11.4561, 10.6393, 9.92308, 9.28986, 8.72603, 8.22078, 7.76543,\n 7.35294, 6.97753, 6.63441, 6.31959, 6.0297, 5.7619, 5.51376, 5.28319,\n 5.06838]#, 4.86777, 4.68]\n\n if self.lightcones is None:\n self.get_lightcones()\n chunk_indices_HERA = [np.argmin(np.abs(self.lc_redshifts - z_HERA)) for z_HERA in chunk_z_list_HERA][::-1]\n\n if self.vb: print(f' Making powerspectra in {len(chunk_z_list_HERA)} chunks')\n\n self.PS = {}\n use_ETHOS = self.lightcones[0].flag_options.pystruct['USE_ETHOS']\n\n for lc in self.lightcones:\n if use_ETHOS:\n h_PEAK = np.round(lc.astro_params.pystruct['h_PEAK'],1)\n key = f'h_PEAK={h_PEAK:.1f}'\n else:\n key = self.cosmology\n\n theta = lc.astro_params.pystruct[self.param_21cmfast]\n\n if self.param == 'k_PEAK':\n theta = 1./theta**self.k_PEAK_order\n\n if self.param == 'L_X' or 'F' in self.param or self.param == 'M_TURN':\n theta = np.log10(theta) # make L_X, F log10\n\n if key not in self.PS:\n self.PS[key] = {} ##### TODO load PS nicely\n\n if self.vb: print(f' Getting PS for {key}, {self.param}={theta}')\n\n # Make PS\n if k_min is None:\n k_min = self.k_fundamental\n if k_max is None:\n k_max = self.k_max\n\n self.PS_z_HERA, self.PS[key][f'{self.param}={theta}'] = powerspectra_chunks(lc,\n n_psbins=n_psbins,\n chunk_indices=chunk_indices_HERA,\n k_min=k_min,\n k_max=k_max)\n\n del lc\n\n if save:\n np.save(self.PS_file, self.PS, allow_pickle=True)\n if self.vb: print(f' saved PS to {self.PS_file}')\n\n np.save(self.PS_z_HERA_file, self.PS_z_HERA, allow_pickle=True)\n if self.vb: print(f' saved PS_z_HERA to {self.PS_z_HERA_file}')\n\n return","def load_and_get_stats(filename):\n\n import scipy.io.wavfile as siow\n sampling_rate, amplitude_vector = siow.read(filename)\n\n wav_length = amplitude_vector.shape[0] / sampling_rate\n\n return sampling_rate, amplitude_vector, wav_length","def checkfrequency(inputgiven):\n data_size = 40000\n wav_file = wave.open(inputgiven, 'r')\n data = wav_file.readframes(data_size)\n wav_file.close()\n data = struct.unpack('{n}h'.format(n=data_size), data)\n print max(data)","def guess_wavelength(x, aperture, identlist, linelist, param):\n rough_wl = None\n\n # guess wavelength from the identified lines in this order\n if aperture in identlist:\n list1 = identlist[aperture]\n if list1.size >= 2:\n fit_order = min(list1.size-1, 2)\n local_coeff = np.polyfit(list1['pixel'], list1['wavelength'],\n deg=fit_order)\n rough_wl = np.polyval(local_coeff, x)\n\n # guess wavelength from global wavelength solution\n if rough_wl is None and param['coeff'].size > 0:\n npixel = param['npixel']\n order = aperture*param['k'] + param['offset']\n rough_wl = get_wavelength(param['coeff'], param['npixel'], x, order)\n\n if rough_wl is None:\n return None\n else:\n # now find the nearest wavelength in linelist\n wave_list = np.array([line[0] for line in linelist])\n iguess = np.abs(wave_list-rough_wl).argmin()\n guess_wl = wave_list[iguess]\n return guess_wl","def _magsamples(self):\n if self._derived_properties[\"magsamples\"] is None:\n if self.lbda is None:\n raise AttributeError(\"lbda not set.\")\n self.derive_magsamples()\n \n return self._derived_properties[\"magsamples\"]","def lms_freq_hz(self):\n return self._lms_freq_hz","def get_dictionary_of_peptides_and_isomeric_peak_areas(self, fout_peptides_isomeric_peak_areas):\n \n try:\n fin_handle = open(fout_peptides_isomeric_peak_areas)\n\n except IOError:\n raise(\"Provide a file containing percentage peak_area of isomeric peptides\")\n\n # local list; this appends all lines within a block and is emptied at the end of the block\n L_peptide_isomeric_peak_area = []\n\n block_start = False; pep_NC = \"\"\n \n for line in fin_handle:\n \n line = line.strip()\n \n # skipping the blank line\n if not line.strip():\n continue\n \n # skipping the comment line\n if line[0]==\"#\":\n continue\n \n \n if line==\"PEPSTART\": block_start=True\n\n elif line==\"PEPEND\" :\n block_start=False\n \n #end elif\n \n if block_start and line!=\"PEPSTART\":\n L = line.split(\":\")\n if L[0].strip() == \"peptide\":\n pep_NC = L[1].strip() #e.g, '15-25'\n\n elif L[0].strip()==\"IsomericPeptidesPeakArea\":\n right_side = L[1].strip()\n\n L_modtypes_freq_peak_area = [m.strip() for m in right_side.split(\" \")]\n percentage_peak_area = L_modtypes_freq_peak_area[-1] # last column\n D_modtype_freq = {}\n\n # running the loop so as to skip the last element\n for i, m in enumerate(L_modtypes_freq_peak_area[:-1]):\n mtype = (m.split('=')[0]).strip()\n freq = (m.split('=')[1]).strip()\n D_modtype_freq[mtype] = freq\n\n #end for\n\n L_peptide_isomeric_peak_area.append((D_modtype_freq, percentage_peak_area))\n \n # end if block_start and line!=\"PEPSTART\" \n\n # pushing into the dictionary after end of each block\n\n if line==\"PEPEND\":\n\n # sorting the list based on total frequency of isomeric peptides\n L_sorted = sorted(L_peptide_isomeric_peak_area, key=lambda x: sum([int(f) for f in x[0].values()]))\n \n self._D_peptide_isomeric_peak_areas[pep_NC] = L_sorted\n \n #emptying the list for next block\n L_peptide_isomeric_peak_area = []\n \n # emptying the peptide N_loc, C_loc string at the end of the block\n pep_NC = \"\"","def signal_dictionary(music_filename):\n\tx = []\n\ty = []\n\tassign_points = {}\n\n\tsignal = input_waves.WAVtoSignal(music_filename)\n\tfor i in range(len(signal)):\n\t\tx = signal[i][0]\n\t\ty = signal[i][1]\n\t\tassign_points.update({x:y})\n\tprint 'assign dictionary complete'\n\treturn assign_points","def print_leaks(self):\n for key in sorted(self.leaks.keys()):\n print('Failure mode: '+key)\n print('Failure rate: {:.2~}'.format(self.leaks[key][0]))\n print('Flow rate: {:.2~}'.format(\n self.leaks[key][1].to(ureg.ft**3/ureg.min)))\n print('Event duration: {:.2~}'.format(self.leaks[key][2]))\n print()","def narrowIncandPeakInfoLG(self):\r\n\t\tself.narrowIncandBaseline_LG = (np.mean(self.lowGainNarrowBandIncandData[0:10]))\r\n\t\t\t\t\r\n\t\traw_narrowIncand_max_LG = np.amax(self.lowGainNarrowBandIncandData)\r\n\t\tnarrowIncand_max_LG = raw_narrowIncand_max_LG - self.narrowIncandBaseline_LG\t\t\r\n\t\tnarrowIncand_max_index_LG = np.argmax(self.lowGainNarrowBandIncandData)\r\n\t\t\r\n\t\tself.narrowIncandMax_LG =narrowIncand_max_LG\r\n\t\tself.narrowIncandMaxPos_LG = narrowIncand_max_index_LG","def _get_lsp_config_frr_bandwidth_configured(self):\n return self.__lsp_config_frr_bandwidth_configured","def wavelength_range(fits_list):\r\n mins = []\r\n maxes = []\r\n for fname in fits_list:\r\n spec = np.genfromtxt(fname.replace('fits', 'txt'), names='wave, flux', \r\n dtype='f4, f4')\r\n mins.append(spec['wave'].min())\r\n maxes.append(spec['wave'].max())\r\n return [np.array(mins).min(), np.array(maxes).max()]","def readWaveformNames(self):\n self.sendMessage('WLIST:SIZE?')\n ansr=self.readMessage()\n msg=[]\n for i in xrange (1,int(ansr)+1):\n msg.append('WLIST:NAME? '+str(i))\n self.sendMessage(msg)\n wnames = self.readMessage()\n names=re.findall('\".*?\"',wnames)\n strippednames=[]\n for name in names:\n strippednames.append(name.rstrip('\"').lstrip('\"'))\n return strippednames","def get_spin_link_dict(peaklist):\n spin_link_dict = {}\n for peak in peaklist:\n spins = [spin for spin in peak\n if spin.atom is not None and spin.atom[0] == 'H']\n if len(spins) != 2:\n err = ('expected 2 Hydrogens in each peak, '\n 'found %d' % len(spins))\n raise ValueError(err)\n link = frozenset(spin.assignment for spin in spins)\n spin_link_dict.setdefault(link, []).append(peak)\n return spin_link_dict","def waveband(self):\n return self.get(\"waveband\", default=\"\", decode=True).split(\"#\")","def get_UL_bw(self,wavelength):\n sec_before = self.wavelengths[wavelength]['sec_UL_timestamp']\n if self.env.now > (sec_before + 2):\n # IF its 2 seconds ahead of last timestamp, it means no more pkts arrived since then\n return 0\n return self.wavelengths[wavelength]['last_UL_bps']","def numberOfWideBands(config=None):\n # Get correlator configuration\n c = config\n if c == None: \n c = utils.getConfigAstroband()\n\n # Determine if we have both wideband and spectral line astrobands. \n # If we do, we return nwide & maxbandwidth for sl only since \n # this is the correlator which will be attached to all ants.\n astrobands = [ abc[0] for abc in c ]\n if len( astrobands ) == 0:\n raise Exception, \"No existing astroband configuration.\"\n if max( astrobands ) > 8 and min( astrobands ) < 9: \n astrobands = [ ab for ab in astrobands if ab < 9 ]\n\n # Check bandwidth\n nwide = 0\n maxbandwidth = 0\n for t in c:\n astroband = t[0]\n # Skip band if it is not being used or is not in astroband list above.\n mp = commands.queryString('SignalPath.Mapping.Astroband%d.confTag' % (astroband) )\n if mp == 'NONE' or astroband not in astrobands: continue\n\n # Get bandwidth\n if t[2] == commands.BW500:\n bw = 500\n elif t[2] == commands.BW250:\n bw = 250\n elif t[2] == commands.BW125:\n bw = 125\n elif t[2] == commands.BW62:\n bw = 62\n elif t[2] == commands.BW31:\n bw = 31\n elif t[2] == commands.BW8:\n bw = 8\n elif t[2] == commands.BW2:\n bw = 2\n else:\n raise Exception, 'Could not find bandwith for '+str(t[2])\n\n # Maximum?\n if bw > maxbandwidth: \n maxbandwidth = bw\n if utils.isDualPol( astroband ):\n nwide = 2 \n else:\n nwide = 1\n elif bw == maxbandwidth:\n if utils.isDualPol( astroband ): \n nwide += 2 \n else:\n nwide += 1\n\n return nwide, maxbandwidth","def get_freq_details(diagnostics_dir, verbose=False):\n metafile_science = find_metadata_file(diagnostics_dir, 'mslist-scienceData*txt', verbose=False)\n if not metafile_science:\n return None, None, None\n\n with open(metafile_science, 'r') as mslist_file:\n lines = mslist_file.readlines()\n\n in_spw_block = False\n for line in lines:\n if in_spw_block:\n parts = line.split()\n chan_width = float(parts[10])*1000. # convert kHz to Hz\n cfreq = parts[12] #MHz\n nchan = parts[7]\n break\n else:\n in_spw_block = line.find('Frame') >= 0\n\n return chan_width, cfreq, nchan","def measure_wavelength_avg(self, from_time, to_time, print_n=False):\n from_idx = self._find_index_for_time(from_time)\n to_idx = self._find_index_for_time(to_time)\n \n # print number of measurements\n if print_n:\n n_measurements = to_idx - from_idx + 1\n print 'n measurements:', n_measurements\n \n # calculate overlap\n overlap = self.overlap()[from_idx:to_idx+1,:]\n \n # intitialize wavelength storage\n wavelengths = np.zeros(overlap.shape[0])\n \n for i in range(overlap.shape[0]):\n this_overlap = overlap[i,:]\n \n # set all overlap entries below 0.1% of the maximum overlap to zero\n this_overlap[this_overlap<0.001*np.max(this_overlap)] = 0.0\n \n nonzero = np.nonzero(this_overlap)\n \n # find connected section of chain with nonzero overlap\n consecutives = np.split(nonzero, np.where(np.diff(nonzero) != 1)[0]+1)\n \n if len(consecutives) != 1:\n warnings.warn('Wavelength could not be determined unambiguously.')\n return np.nan\n else:\n # add 1 since overlap involves two beads each\n wavelengths[i] = float( len(consecutives[0][0]) ) + 1\n \n return np.mean( wavelengths )","def get_wavelengths(system, info=False):\n\n system_data = system.SystemData\n wavelengths = system_data.Wavelengths\n N_wavelengths = wavelengths.NumberOfWavelengths\n\n if info is True:\n print(\"\\nReading Wavelengths\")\n print(\"Total Number of Wavelengths: %d\" % N_wavelengths)\n\n wavelength_array = np.zeros(N_wavelengths)\n\n for k in np.arange(1, N_wavelengths + 1):\n _wave = wavelengths.GetWavelength(k).Wavelength\n wavelength_array[k - 1] = _wave\n\n if info is True:\n print(\"%.5f microns\" % _wave)\n\n return wavelength_array","def bandwidth(self):\n return self.stop_hz - self.start_hz","def get_audio_features(sample, audio_data, max_len, data_truncating, data_filling, audio_cfg):\n if len(audio_data) > max_len:\n if data_truncating == \"fusion\":\n # fusion\n mel = get_mel(audio_data, audio_cfg)\n # split to three parts\n chunk_frames = max_len // audio_cfg['hop_size']+1 # the +1 related to how the spectrogram is computed\n total_frames = mel.shape[0]\n if chunk_frames == total_frames:\n # there is a corner case where the audio length is\n # larger than max_len but smaller than max_len+hop_size.\n # In this case, we just use the whole audio.\n mel_fusion = np.stack([mel, mel, mel, mel], axis=0)\n longer = [[False]]\n else:\n ranges = np.array_split(list(range(0, total_frames-chunk_frames+1)), 3)\n # print('total_frames-chunk_frames:', total_frames-chunk_frames,\n # 'len(audio_data):', len(audio_data),\n # 'chunk_frames:', chunk_frames,\n # 'total_frames:', total_frames)\n if len(ranges[1]) == 0:\n # if the audio is too short, we just use the first chunk\n ranges[1] = [0]\n if len(ranges[2]) == 0:\n # if the audio is too short, we just use the first chunk\n ranges[2] = [0]\n # randomly choose index for each part\n idx_front = np.random.choice(ranges[0])\n idx_middle = np.random.choice(ranges[1])\n idx_back = np.random.choice(ranges[2])\n # select mel\n mel_chunk_front = mel[idx_front:idx_front+chunk_frames, :]\n mel_chunk_middle = mel[idx_middle:idx_middle+chunk_frames, :]\n mel_chunk_back = mel[idx_back:idx_back+chunk_frames, :]\n\n # shrink the mel\n # Output may differ between torchvision.transforms.Resize and numpy.resize.\n #mel_shrink_torch = torch.from_numpy(mel[None])\n #mel_shrink_torch = torchvision.transforms.Resize(size=[chunk_frames, 64])(mel_shrink_torch)[0]\n #mel_shrink_torch = mel_shrink_torch.to('cpu').detach().numpy().copy()\n mel_shrink_numpy = np.resize(mel[None], (chunk_frames, 64))\n # logging.info(f\"mel_shrink.shape: {mel_shrink.shape}\")\n\n # stack\n mel_fusion = np.stack([mel_chunk_front, mel_chunk_middle, mel_chunk_back, mel_shrink_numpy], axis=0)\n longer = [[True]]\n # random crop to max_len (for compatibility)\n overflow = len(audio_data) - max_len\n idx = np.random.randint(0, overflow + 1)\n audio_data = audio_data[idx: idx + max_len]\n\n else: # padding if too short\n if len(audio_data) < max_len: # do nothing if equal\n if data_filling == \"repeatpad\":\n n_repeat = int(max_len/len(audio_data))\n audio_data = np.tile(audio_data, n_repeat)\n # audio_data = audio_data.unsqueeze(0).unsqueeze(0).unsqueeze(0)\n # audio_data = F.interpolate(audio_data,size=max_len,mode=\"bicubic\")[0,0,0]\n audio_data = np.pad(audio_data, [(0, max_len - len(audio_data))], \"constant\")\n elif data_filling == \"pad\":\n audio_data = np.pad(audio_data, [(0, max_len - len(audio_data))], \"constant\")\n elif data_filling == \"repeat\":\n n_repeat = int(max_len/len(audio_data))\n audio_data = np.tile(audio_data, n_repeat+1)[:max_len]\n \n if data_truncating == 'fusion':\n mel = get_mel(audio_data, audio_cfg)\n mel_fusion = np.stack([mel, mel, mel, mel], axis=0)\n longer = [[False]]\n\n return longer, mel_fusion, audio_data","def prepare_settings(\n label_count, sample_rate, clip_duration_ms,\n window_size_ms, window_stride_ms, dct_coefficient_count):\n desired_samples = int(sample_rate * clip_duration_ms / 1000)\n window_size_samples = int(sample_rate * window_size_ms / 1000)\n window_stride_samples = int(sample_rate * window_stride_ms / 1000)\n length_minus_window = (desired_samples - window_size_samples)\n if length_minus_window < 0:\n spectrogram_length = 0\n else:\n spectrogram_length = 1 + int(length_minus_window / window_stride_samples)\n fingerprint_size = dct_coefficient_count * spectrogram_length\n return {\n 'desired_samples': desired_samples,\n 'window_size_samples': window_size_samples,\n 'window_stride_samples': window_stride_samples,\n 'spectrogram_length': spectrogram_length,\n 'dct_coefficient_count': dct_coefficient_count,\n 'fingerprint_size': fingerprint_size,\n 'label_count': label_count,\n 'sample_rate': sample_rate,\n }","def initDictionary(bands):\r\n for x in bands:\r\n d[\"{}\".format(x)] = {ProdCost: [], AlbumSales: []}","def get_label_peak_window(\n pep_query,\n scan=None, ms_data=None, window_size=1\n):\n if scan is None and ms_data is None:\n return []\n\n label_mods = pep_query.get_label_mods\n\n if not label_mods:\n return []\n\n window = ms_labels.LABEL_MZ_WINDOW[label_mods[0]]\n window = (\n window[0] - window_size,\n window[1] + window_size\n )\n\n if scan is None:\n scan = ms_data[pep_query.basename][pep_query.quant_scan]\n\n return [\n (mz, i)\n for mz, i in scan.centroidedPeaks\n if mz > window[0] and mz < window[1]\n ]","def reference_spec_wavelength(spec, calib_lst, weight_lst):\n combined_calib = combine_calib(calib_lst, weight_lst)\n\n k = combined_calib['k']\n offset = combined_calib['offset']\n xorder = combined_calib['xorder']\n yorder = combined_calib['yorder']\n npixel = combined_calib['npixel']\n coeff = combined_calib['coeff']\n\n # calculate the wavelength for each aperture\n for row in spec:\n aperture = row['aperture']\n npoints = len(row['wavelength'])\n order = aperture*k + offset\n wavelength = get_wavelength(coeff, npixel,\n np.arange(npoints), np.repeat(order, npoints))\n row['order'] = order\n row['wavelength'] = wavelength\n\n card_lst = []\n #prefix = 'HIERARCH GAMSE WLCALIB'\n #if fiber is not None:\n # prefix = prefix + ' FIBER {}'.format(fiber)\n card_lst.append(('K', k))\n card_lst.append(('OFFSET', offset))\n card_lst.append(('XORDER', xorder))\n card_lst.append(('YORDER', yorder))\n card_lst.append(('NPIXEL', npixel))\n\n # write the coefficients to fits header\n for j, i in itertools.product(range(yorder+1), range(xorder+1)):\n key = 'COEFF {:d} {:d}'.format(j, i)\n value = coeff[j,i]\n card_lst.append((key, value))\n\n # write information for every reference\n for icalib, (calib, weight) in enumerate(zip(calib_lst, weight_lst)):\n prefix = 'REFERENCE {:d}'.format(icalib+1)\n card_lst.append((prefix+' FILEID', calib['fileid']))\n card_lst.append((prefix+' DATE-OBS', calib['date-obs']))\n card_lst.append((prefix+' EXPTIME', calib['exptime']))\n card_lst.append((prefix+' WEIGHT', weight))\n card_lst.append((prefix+' NTOT', calib['ntot']))\n card_lst.append((prefix+' NUSE', calib['nuse']))\n card_lst.append((prefix+' STDDEV', calib['std']))\n\n return spec, card_lst","def count_convert_wavelength_range(self):\n mini = ct.c_float()\n maxi = ct.c_float()\n self.lib.GetCountConvertWavelengthRange(ct.pointer(mini),\n ct.pointer(maxi))\n return (mini.value, maxi.value)","def stats():\r\n times_lst = []\r\n time_dict = {}\r\n for album, details in dbase().items():\r\n time_m = 0\r\n time_s = 0\r\n for songs, details_s in details[0].items():\r\n time = details_s[1].split(\":\")\r\n min = int(time[0])\r\n sec = int(time[1])\r\n time_m += min\r\n time_s += sec\r\n time_s = datetime.timedelta(seconds=time_s)\r\n time_m = datetime.timedelta(seconds=time_m)\r\n time = time_m + time_s\r\n time = str(time)\r\n times_lst.append(time)\r\n time_dict[album] = time\r\n\r\n time_dict = sorted(time_dict.items(), key=lambda x: x[1], reverse=True)\r\n return time_dict","def bandwidths(self):\n return (band.bandwidth for band in self)","def mspec(samples, winlen = 400, winshift = 200, preempcoeff=0.97, nfft=512, samplingrate=20000):\n frames = enframe(samples, winlen, winshift)\n preemph = preemp(frames, preempcoeff)\n windowed = windowing(preemph)\n spec = powerSpectrum(windowed, nfft)\n return logMelSpectrum(spec, samplingrate)","def estimate_phones(x):\n if x['mean_luminosity_km2'] > 5:\n return 10\n elif x['mean_luminosity_km2'] > 1:\n return 5\n else:\n return 1","def update(self, wnd):\n y = self.fft(wnd)\n amp = lambda f: y[int(round(self.f2b(wnd.fft_resolution, f)))]\n amps = [amp(fb) for fb in self.frequencies]\n return amps","def guessToParms(self, stguess):\n self.peakTyp = []\n self.parmVal = []\n self.parmName = []\n items = str(stguess).split(',')\n items = [item for item in items if item] # delete empty elements\n if self.first:\n # The first time peak is defined by 4 parameters:\n # type, xc, Amp, width\n n = 4\n self.first = False\n else:\n # Subsequently each peak is defined by 6 parameters:\n # type, xc, Amp, width, asym, Lfrac\n n = 6\n ntot = len(items)\n self.npeaks = int(ntot/n)\n if self.npeaks == 0:\n return\n for i in range(0, ntot, n):\n stpkno = str((i/n)+1)\n peakTyp = items[i].strip()\n self.peakTyp.append(peakTyp)\n self.parmVal.append(float(items[i+1]))\n self.parmName.append('xm'+stpkno)\n self.parmVal.append(float(items[i+2]))\n self.parmName.append('amp'+stpkno)\n self.parmVal.append(float(items[i+3]))\n self.parmName.append('wid'+stpkno)\n # Add two extra parameters, asym and Lfrac\n asym = 0.0\n Lfrac = 0.0\n if peakTyp == 'P' or peakTyp == 'AP':\n Lfrac = 0.5\n self.parmVal.append(asym)\n self.parmName.append('a' + stpkno)\n self.parmVal.append(Lfrac)\n self.parmName.append('m' + stpkno)\n\n # Set the parameter limits [xm, amp, fwhm, asym, Lfrac]\n minx = self.data[0].min()\n maxx = self.data[0].max()\n minamp = self.data[1].min() * 1.1\n maxamp = self.data[1].max() * 1.1\n minw = getSpan(self.data[0]) / self.npt\n maxw = getSpan(self.data[0]) / (self.npeaks+1)\n minasy = -1000/maxx\n maxasy = 1000/maxx\n minfrac = 0\n maxfrac = 1.0\n minbounds = []\n maxbounds = []\n for i in range(self.npeaks):\n minbounds.extend([minx, minamp, minw, minasy, minfrac])\n maxbounds.extend([maxx, maxamp, maxw, maxasy, maxfrac])\n self.bounds = (minbounds, maxbounds)","def get_wav_info(file_name):\n wr = wave.open(file_name, 'r')\n sample_width = wr.getsampwidth()\n frame_rate = wr.getframerate()\n num_frames = wr.getnframes()\n n_channels = wr.getnchannels()\n s = \"sample width: {} bytes\\n\".format(sample_width) + \\\n \"frame rate: {} Hz\\n\".format(frame_rate) + \\\n \"num frames: {}\\n\".format(num_frames) + \\\n \"track length: {} s\\n\".format(num_frames / frame_rate) + \\\n \"num channels: {}\\n\".format(n_channels)\n\n return s","def get_powermax_volume_parameters():\n return dict(\n vol_name=dict(required=False, type='str'),\n vol_id=dict(required=False, type='str'),\n size=dict(type='float'),\n sg_name=dict(required=False, type='str'),\n new_sg_name=dict(required=False, type='str'),\n new_name=dict(required=False, type='str'),\n cap_unit=dict(choices=['MB', 'GB', 'TB'], type='str'),\n vol_wwn=dict(required=False, type='str'),\n state=dict(required=True, type='str', choices=['absent', 'present'])\n )","def calc_power_spectrogram(audio_data, samplerate, n_mels=257, n_fft=400, hop_length=160):\n spectrogram = librosa.feature.melspectrogram(audio_data, sr=samplerate, n_mels=n_mels, n_fft=n_fft, hop_length=hop_length)\n\n # convert to log scale (dB)\n log_spectrogram = librosa.logamplitude(spectrogram, ref_power=np.max)\n\n # normalize\n normalized_spectrogram = normalize(log_spectrogram)\n\n return normalized_spectrogram.T","def setup_lls_fit_analy(spec_fil, zlls, lls_windows, NHI_mnx, nNHI=100, spec_keys=None):\n # Init\n if spec_keys is None:\n spec_keys = dict(sig='ERROR', flux='FLUX', wave='WAVE')\n # Load up spectrum (Table and xspec)\n spec = Table.read(spec_fil)\n # Deal with NANs\n sig = spec[spec_keys['sig']].data.flatten()\n sig[np.isnan(sig)] = 0.\n xspec = XSpectrum1D.from_tuple((np.array(spec[spec_keys['wave']].data.flatten()),\n np.array(spec[spec_keys['flux']].data.flatten()),\n sig), masking='none')\n\n # Analysis pixels\n pixels = []\n for window in lls_windows:\n gdwv = np.where((xspec.wavelength >= window[0]*u.AA) &\n (xspec.wavelength <= window[1]*u.AA))[0]\n pixels.append(gdwv)\n gdwv = np.concatenate(pixels)\n\n # NHI\n NHI = np.linspace(NHI_mnx[0], NHI_mnx[1], num=nNHI)\n wv_rest = xspec.wavelength[gdwv] / (zlls+1)\n energy = wv_rest.to(u.eV, equivalencies=u.spectral())\n # Get photo_cross and calculate tau\n tau0 = (10.**NHI[0] / u.cm**2) * ltaa.photo_cross(1, 1, energy)\n\n # Return\n return spec, xspec, gdwv, NHI, tau0","def calc_spectra(stream, data_type):\n \n import numpy as np\n from mtspec import mtspec\n from scipy import interpolate\n from scipy.stats import binned_statistic \n\n # Read in file \n tr = stream[0]\n data = tr.data\n delta = tr.stats.delta\n samprate = tr.stats.sampling_rate\n npts = tr.stats.npts\n \n # Determine nyquist frequency\n nyquist = 0.5 * samprate\n \n\n # Calc spectra amplitudes and frequencies \n # Switched number of tapers from 7 to 5. Decreases computation time and\n # results are similar\n amp_squared, freq = mtspec(data, delta=delta, time_bandwidth=4, \n number_of_tapers=5, nfft=npts, quadratic=True)\n \n # Convert from power spectra to amplitude spectra\n amp = np.sqrt(amp_squared)\n \n # Use scipy interpolate function to fill in data in missing bins\n f = interpolate.interp1d(freq, amp)\n freq_new = np.arange(np.min(freq), np.max(freq), 0.0001)\n amp_new = f(freq_new)\n\n # Remove certain frequencies that are too low or high. \n indexes = []\n \n for i, val in enumerate(freq_new):\n \n # Remove frequencies below 1/2 length of record\n if val <= 1/(delta*npts*0.5) :\n indexes.append(i)\n \n # Remove frequencies above 10 Hz for sm data because of the way it was processed \n elif val > 10 and data_type == 'sm':\n indexes.append(i)\n\n # Remove frequencies above nyquist frequency for disp data\n # (it's already removed in the previous step for sm data)\n elif val > nyquist and data_type == 'disp': \n indexes.append(i)\n \n # Remove any duplicate indexes\n indexes = np.unique(indexes)\n freq_new = np.delete(freq_new,indexes)\n amp_new = np.delete(amp_new,indexes) \n \n # Set up bins\n if data_type == 'sm':\n # Starting bins at 0.004 Hz (that is about equal to half the length\n # of the record for the synthetic and observed data) and ending at\n # 10 Hz because after that the sm data is unusable due to how it was\n # processed. \n bins = np.logspace(np.log10(0.004), np.log10(10), num=21)\n \n elif data_type == 'disp':\n # Starting bins at 0.004 Hz (that is about equal to half the length\n # of the record for the synthetic and observed data) and ending at\n # 0.5 Hz because that is the nyquist frequency .\n bins = np.logspace(np.log10(0.004), np.log10(0.5), num=21)\n \n bin_means, bin_edges, binnumber = binned_statistic(freq_new,\n amp_new,\n statistic='mean',\n bins=bins)\n \n # for i in range(len(bin_means)):\n # bin_means[i] = 10**bin_means[i]\n \n \n return(bin_means, freq, amp)","def getLaps(self):\n\n if self.pj[OBSERVATIONS][self.observationId][\"type\"] in [LIVE]:\n\n if self.liveObservationStarted:\n now = QTime()\n now.start() # current time\n memLaps = Decimal(str(round(self.liveStartTime.msecsTo(now) / 1000, 3)))\n return memLaps\n else:\n return Decimal(\"0.0\")\n\n if self.pj[OBSERVATIONS][self.observationId][\"type\"] in [MEDIA]:\n\n if self.playerType == VIEWER:\n return Decimal(0)\n\n if self.playerType == VLC:\n if self.playMode == FFMPEG:\n # cumulative time\n memLaps = Decimal(self.FFmpegGlobalFrame * (1000 / list(self.fps.values())[0]) / 1000).quantize(\n Decimal(\".001\"))\n return memLaps\n elif self.playMode == VLC:\n # cumulative time\n memLaps = Decimal(\n str(round((sum(self.duration[0: self.media_list.index_of_item(self.mediaplayer.get_media())]) +\n self.mediaplayer.get_time()) / 1000, 3)))\n return memLaps","def incandPeakInfoLG(self):\r\n\t\tself.incandBaseline_LG = (np.mean(self.lowGainWideBandIncandData[0:10]))\r\n\t\t\t\t\r\n\t\traw_incand_max_LG = np.amax(self.lowGainWideBandIncandData)\r\n\t\tincand_max_LG = raw_incand_max_LG - self.incandBaseline_LG\t\t\r\n\t\tincand_max_index_LG = np.argmax(self.lowGainWideBandIncandData)\r\n\t\t\r\n\t\tself.incandMax_LG =incand_max_LG\r\n\t\tself.incandMaxPos_LG = incand_max_index_LG","def getFWHM(antenna, freq):\n diameter = getDiameter(antenna)\n lam = 299792458.0 / (freq * 1e9)\n fwhmo = lam / math.pi * 180.0 * 60.0\n fwhm = 1.22 * fwhmo / diameter\n return fwhm","def generate_wavelength_model(comp_lamp_path, night_path, plot_path):\n\n # read 1D comp lamp spectrum\n spec = Table.read(comp_lamp_path)\n\n # read wavelength guess file\n guess_path = path.abspath(path.join(night_path,\n '..', 'wavelength_guess.csv'))\n pix_wav = np.genfromtxt(guess_path, delimiter=',', names=True)\n\n # get emission line centroids at the guessed positions of the lines\n pix_x0s = fit_all_lines(spec['pix'], spec['flux'], spec['ivar'],\n pix_wav['wavelength'], pix_wav['pixel'])\n\n # only keep successful ones:\n mask = np.isfinite(pix_x0s)\n logger.debug(\"Successfully fit {}/{} comp. lamp lines\"\n .format(mask.sum(), len(mask)))\n pix_wav = pix_wav[mask]\n pix_x0s = pix_x0s[mask]\n\n # --------------------------------------------------------------------------\n # fit a gaussian process to determine the pixel-to-wavelength transformation\n #\n idx = np.argsort(pix_x0s)\n med_x = np.median(pix_x0s[idx])\n x = pix_x0s[idx] - med_x\n y = pix_wav['wavelength'][idx]\n\n model = GPModel(x=x, y=y, n_bg_coef=n_bg_coef, x_shift=med_x)\n\n # Fit for the maximum likelihood parameters\n bounds = model.gp.get_parameter_bounds()\n init_params = model.gp.get_parameter_vector()\n soln = minimize(model, init_params, method=\"L-BFGS-B\",\n bounds=bounds)\n model.gp.set_parameter_vector(soln.x)\n logger.debug(\"Success: {}, Final log-likelihood: {}\".format(soln.success,\n -soln.fun))\n\n # ---\n # residuals to the mean model\n x_grid = np.linspace(0, 1600, 1024) - med_x\n mu, var = model.gp.predict(y, x_grid, return_var=True)\n std = np.sqrt(var)\n\n _y_mean = model.mean_model.get_value(x)\n _mu_mean = model.mean_model.get_value(x_grid)\n\n # Plot the maximum likelihood model\n fig,ax = plt.subplots(1, 1, figsize=(8,8))\n\n # data\n ax.scatter(x + med_x, y - _y_mean, marker='o')\n\n # full GP model\n gp_color = \"#ff7f0e\"\n ax.plot(x_grid+med_x, mu - _mu_mean, color=gp_color, marker='')\n ax.fill_between(x_grid+med_x, mu+std-_mu_mean, mu-std-_mu_mean,\n color=gp_color, alpha=0.3, edgecolor=\"none\")\n\n ax.set_xlabel('pixel')\n ax.set_ylabel(r'wavelength [$\\AA$]')\n ax.set_title(path.basename(comp_lamp_path))\n\n fig.tight_layout()\n fig.savefig(path.join(plot_path, 'wavelength_mean_subtracted.png'), dpi=200)\n # ---\n\n # ---\n # residuals to full GP model\n mu, var = model.gp.predict(y, x_grid, return_var=True)\n std = np.sqrt(var)\n\n y_mu, var = model.gp.predict(y, x, return_var=True)\n\n # Plot the maximum likelihood model\n fig,ax = plt.subplots(1, 1, figsize=(12,8))\n\n # data\n ax.scatter(x + med_x, y - y_mu, marker='o')\n\n gp_color = \"#ff7f0e\"\n ax.plot(x_grid+med_x, mu-mu, color=gp_color, marker='')\n ax.fill_between(x_grid+med_x, std, -std, color=gp_color,\n alpha=0.3, edgecolor=\"none\")\n\n ax.set_xlabel('pixel')\n ax.set_ylabel(r'wavelength residual [$\\AA$]')\n ax.set_title(path.basename(comp_lamp_path))\n\n ax.set_ylim(-1, 1)\n ax.axvline(683., zorder=-10, color='#666666', alpha=0.5)\n\n ax2 = ax.twinx()\n ax2.set_ylim([x/6563*300000 for x in ax.get_ylim()])\n ax2.set_ylabel(r'velocity error at ${{\\rm H}}_\\alpha$ [{}]'\n .format((u.km/u.s).to_string(format='latex_inline')))\n\n fig.tight_layout()\n fig.savefig(path.join(plot_path, 'wavelength_residuals.png'), dpi=200)\n # --------------------------------------------------------------------------\n\n return model","def feedback_limit_khz(self):\n return self._feedback_limit_khz","def analyzeWAV(inputFile):\n data, fs, nbits = audiolab.wavread(inputFile)\n samplingRate = fs\n return [data, samplingRate]","def calc_peak_mags(model_table, filts=[\"u\",\"g\",\"r\",\"i\",\"z\",\"y\",\"J\",\"H\",\"K\"], magidxs=[0,1,2,3,4,5,6,7,8]):\n\n # Initiaize peak mag dictionarts\n model_table_tts = {}\n model_table_mags = {}\n model_table_appmags = {}\n for filt, magidx in zip(filts, magidxs):\n model_table_tts[filt] = []\n model_table_mags[filt] = []\n model_table_appmags[filt] = []\n\n for row in model_table:\n t, lbol, mag = row[\"t\"], row[\"lbol\"], row[\"mag\"]\n for filt, magidx in zip(filts,magidxs):\n idx = np.where(~np.isnan(mag[magidx]))[0]\n if len(idx) == 0:\n model_table_tts[filt].append(np.nan)\n model_table_mags[filt].append(np.nan)\n model_table_appmags[filt].append(np.nan)\n else:\n ii = np.argmin(mag[magidx][idx])\n model_table_tts[filt].append(t[idx][ii])\n model_table_mags[filt].append(mag[magidx][idx][ii])\n model_table_appmags[filt].append(mag[magidx][idx][ii]+5*(np.log10(row[\"dist\"]*1e6) - 1))\n\n for filt, magidx in zip(filts, magidxs):\n model_table[\"peak_tt_%s\"%filt] = model_table_tts[filt]\n model_table[\"peak_mag_%s\"%filt] = model_table_mags[filt] \n model_table[\"peak_appmag_%s\"%filt] = model_table_appmags[filt] \n\n return model_table","def calculateMaxAmplitude(sampleWidth: int) -> int:\n return 2 ** (sampleWidth * NUM_BITS_IN_A_BYTE - 1) - 1","def wav2(bins, weis):\n\n mean = np.average(bins, weights=weis)\n var = np.average((bins-mean)**2, weights=weis)\n ##\n sum1 = weis.sum()\n sum2 = (weis**2).sum()\n rms = np.sqrt(sum1*var/(sum1-sum2/sum1))\n\n return mean, rms","def wavelength(self):\n return wavelength(energy)","def bands(self) -> int:\n ...","def set_UL_bw(self,oid, wavelength, pkt_size, timestamp):\n try: \n aux = self.wavelengths[wavelength]\n except:\n print \"CREATED WAVELENGTH %d\" %wavelength\n self.create_wavelength(wavelength)\n\n sec_before = self.wavelengths[wavelength]['sec_UL_timestamp']\n if self.env.now > (sec_before + 1):\n #Then a second has passed. Time to flush counter\n print \"MONITOR - passou 1 segundo - %f > %f\" % (self.env.now, sec_before)\n print \"WAVELENGTH %d - SECOND BPS == %f\" % (wavelength,self.wavelengths[wavelength]['UL_bps'])\n self.wavelengths[wavelength]['last_UL_bps'] = self.wavelengths[wavelength]['UL_bps']\n self.wavelengths[wavelength]['UL_bps'] = 0\n self.wavelengths[wavelength]['sec_UL_timestamp'] = self.env.now\n \n self.wavelengths[wavelength]['UL_bps']+=pkt_size\n self.wavelengths[wavelength]['last_UL_timestamp'] = self.env.now\n\n self.bandwidth_UL_file.write(\"{},{},{},{}\\n\".format(wavelength,oid,pkt_size,timestamp))","def peak_height(self):\n return np.array([max(self.waveform[ch]) for ch in range(self.nchannels)])","def find_closest_peaks(power, freqs, guess_freqs):\n # find the maxima in the power spectrum\n maxima = sig.argrelextrema(power, np.greater)\n\n maxima_freqs = np.zeros(freqs.shape)\n maxima_freqs[maxima] = freqs[maxima]\n\n # determine the peaks as the closest maxima to\n # each of the standing wave frequencies\n peak_indices = [find_nearest_idx(maxima_freqs, f) for f in guess_freqs]\n return peak_indices","def compute_melmat(self, num_mel_bands=12, freq_min=64, freq_max=8000,\n num_fft_bands=513, sample_rate=16000):\n center_frequencies_mel, lower_edges_mel, upper_edges_mel = self.melfrequencies_mel_filterbank(\n num_mel_bands,\n freq_min,\n freq_max,\n num_fft_bands\n )\n\n center_frequencies_hz = self.mel_to_hertz(center_frequencies_mel)\n lower_edges_hz = self.mel_to_hertz(lower_edges_mel)\n upper_edges_hz = self.mel_to_hertz(upper_edges_mel)\n freqs = linspace(0.0, sample_rate / 2.0, num_fft_bands)\n melmat = zeros((num_mel_bands, num_fft_bands))\n\n for imelband, (center, lower, upper) in enumerate(zip(\n center_frequencies_hz, lower_edges_hz, upper_edges_hz)):\n\n left_slope = (freqs >= lower) == (freqs <= center)\n melmat[imelband, left_slope] = (\n (freqs[left_slope] - lower) / (center - lower)\n )\n\n right_slope = (freqs >= center) == (freqs <= upper)\n melmat[imelband, right_slope] = (\n (upper - freqs[right_slope]) / (upper - center)\n )\n return melmat, (center_frequencies_mel, freqs)","def print_peak_data_short(sp) : \n print('%d %4d %s %s %.6f %.6f %.6f %d %.6f %.6f %.6f %.6f %.6f %d %.6f %.6f %.6f %.6f %d %d' % \\\n (sp.frameNumber, sp.runnum, sp.tstamp, sp.s_fid,\\\n sp.photonEnergyEv, sp.wavelengthA,\\\n sp.GMD, sp.peak_index, sp.peak_x_raw, sp.peak_y_raw,\\\n sp.peak_r_assembled, sp.peak_q, sp.peak_resA, sp.nPixels,\\\n sp.totalIntensity, sp.maxIntensity, sp.sigmaBG, sp.SNR,\\\n sp.tsec, sp.fid))","def summary(self) -> None:\n if not self._custom_wave:\n print(\n f\"{self.name}\\n\"\n + f\"{self.start_wavelength} < lambda (A) < {self.end_wavelength}\\n\"\n + f\"R = {self.R_res}\\n\"\n + f\"Sampling = {self.R_samp} pix/FWHM\"\n )\n else:\n print(\n f\"{self.name}\\n\"\n + f\"Custom Wavelength w/\\n\"\n + f\"({self.wave[0]} < lambda (A) < {self.wave[-1]})\\n\"\n + f\"R = {self.R_res}\\n\"\n )","def getPulseWave(ham: Dict[str, Any], names: Union[str, List[str]]) -> Dict[str, Any]:\n if isinstance(names, str):\n return ham[\"control\"][names][\"waveforms\"]\n else:\n waves = {}\n for name in names:\n wave = ham[\"control\"][names][\"waveforms\"]\n waves[name] = wave\n return waves","def spectrl2_data():\n # reference spectra generated with solar_utils==0.3\n kwargs = {\n 'surface_tilt': 0,\n 'relative_airmass': 1.4899535986910446,\n 'apparent_zenith': 47.912086486816406,\n 'aoi': 47.91208648681641,\n 'ground_albedo': 0.2,\n 'surface_pressure': 101300,\n 'ozone': 0.344,\n 'precipitable_water': 1.42,\n 'aerosol_turbidity_500nm': 0.1,\n 'dayofyear': 75\n }\n df = pd.read_csv(SPECTRL2_TEST_DATA)\n # convert um to nm\n df['wavelength'] *= 1000\n df[['specdif', 'specdir', 'specetr', 'specglo']] /= 1000\n return kwargs, df"],"string":"[\n \"def stubb_fitlers(wave_min=350., wave_max=1050):\\n throughPath = os.path.join(getPackageDir('throughputs'), 'baseline')\\n bps = {}\\n lsstKeys = ['u', 'y']\\n bps = {}\\n for key in lsstKeys:\\n bp = np.loadtxt(os.path.join(throughPath, 'total_'+key+'.dat'),\\n dtype=zip(['wave', 'trans'], [float]*2))\\n bpTemp = Bandpass()\\n good = np.where((bp['trans'] > 0.) & (bp['wave'] > wave_min) & (bp['wave'] < wave_max))\\n bpTemp.setBandpass(bp['wave'], bp['trans'], wavelen_min=bp['wave'][good].min(),\\n wavelen_max=bp['wave'][good].max())\\n bps[key+'_truncated'] = bpTemp\\n return bps\",\n \"def lamg(freq, w):\\n la = lam(freq)\\n return la / _np.sqrt(1.0 - (la / (2 * w)) ** 2) # wavelength in WG-62 waveguide\",\n \"def _decode_35698(data):\\n start_byte = 0\\n n_bytes = 2\\n var_id = struct.unpack('<H', data[start_byte:start_byte + n_bytes])[0]\\n if var_id == 29981:\\n start_byte += n_bytes\\n n_bytes = 16\\n min_wavelength, max_wavelength = struct.unpack(\\n '<dd', data[start_byte:start_byte + n_bytes])\\n return {'min_wavelength': min_wavelength,\\n 'max_wavelength': max_wavelength}\",\n \"def make_Bandwidth(typicalBandwidth=2500, maximumBandwidth=10000):\\n\\n return {'maximumBandwidth': maximumBandwidth,\\n 'typicalBandwidth': typicalBandwidth\\n }\",\n \"def get_line_wavelengths():\\n line_wavelengths = OrderedDict() ; line_ratios = OrderedDict()\\n \\n line_wavelengths['PaB'] = [12821]\\n line_ratios['PaB'] = [1.]\\n line_wavelengths['Ha'] = [6564.61]\\n line_ratios['Ha'] = [1.]\\n line_wavelengths['Hb'] = [4862.68]\\n line_ratios['Hb'] = [1.]\\n line_wavelengths['Hg'] = [4341.68]\\n line_ratios['Hg'] = [1.]\\n line_wavelengths['Hd'] = [4102.892]\\n line_ratios['Hd'] = [1.]\\n \\n line_wavelengths['OIII-4363'] = [4364.436]\\n line_ratios['OIII-4363'] = [1.]\\n line_wavelengths['OIII'] = [5008.240, 4960.295]\\n line_ratios['OIII'] = [2.98, 1]\\n \\n # Split doublet, if needed\\n line_wavelengths['OIII4959'] = [4960.295]\\n line_ratios['OIII4959'] = [1]\\n line_wavelengths['OIII5007'] = [5008.240]\\n line_ratios['OIII5007'] = [1]\\n \\n line_wavelengths['OII'] = [3727.092, 3729.875]\\n line_ratios['OII'] = [1, 1.] \\n \\n line_wavelengths['OI-6302'] = [6302.046, 6363.67]\\n line_ratios['OI-6302'] = [1, 0.33]\\n\\n line_wavelengths['NeIII'] = [3869]\\n line_ratios['NeIII'] = [1.]\\n line_wavelengths['NeV'] = [3346.8]\\n line_ratios['NeV'] = [1.]\\n line_wavelengths['NeVI'] = [3426.85]\\n line_ratios['NeVI'] = [1.]\\n \\n line_wavelengths['SIII'] = [9068.6, 9530.6][::-1]\\n line_ratios['SIII'] = [1, 2.44][::-1]\\n \\n # Split doublet, if needed\\n line_wavelengths['SIII9068'] = [9068.6]\\n line_ratios['SIII9068'] = [1]\\n line_wavelengths['SIII9531'] = [9530.6]\\n line_ratios['SIII9531'] = [1]\\n \\n line_wavelengths['SII'] = [6718.29, 6732.67]\\n line_ratios['SII'] = [1., 1.] \\n \\n line_wavelengths['HeII'] = [4687.5]\\n line_ratios['HeII'] = [1.]\\n line_wavelengths['HeI-5877'] = [5877.2]\\n line_ratios['HeI-5877'] = [1.]\\n line_wavelengths['HeI-3889'] = [3889.5]\\n line_ratios['HeI-3889'] = [1.]\\n line_wavelengths['HeI-1083'] = [10830.]\\n line_ratios['HeI-1083'] = [1.]\\n \\n line_wavelengths['MgII'] = [2799.117]\\n line_ratios['MgII'] = [1.]\\n \\n line_wavelengths['CIV-1549'] = [1549.480]\\n line_ratios['CIV-1549'] = [1.]\\n line_wavelengths['CIII-1908'] = [1908.734]\\n line_ratios['CIII-1908'] = [1.]\\n line_wavelengths['OIII-1663'] = [1665.85]\\n line_ratios['OIII-1663'] = [1.]\\n line_wavelengths['HeII-1640'] = [1640.4]\\n line_ratios['HeII-1640'] = [1.]\\n \\n line_wavelengths['NII'] = [6549.86, 6585.27]\\n line_ratios['NII'] = [1., 3]\\n line_wavelengths['NIII-1750'] = [1750.]\\n line_ratios['NIII-1750'] = [1.]\\n line_wavelengths['NIV-1487'] = [1487.]\\n line_ratios['NIV-1487'] = [1.]\\n line_wavelengths['NV-1240'] = [1240.81]\\n line_ratios['NV-1240'] = [1.]\\n\\n line_wavelengths['Lya'] = [1215.4]\\n line_ratios['Lya'] = [1.]\\n \\n line_wavelengths['Lya+CIV'] = [1215.4, 1549.49]\\n line_ratios['Lya+CIV'] = [1., 0.1]\\n \\n line_wavelengths['Ha+SII'] = [6564.61, 6718.29, 6732.67]\\n line_ratios['Ha+SII'] = [1., 1./10, 1./10]\\n line_wavelengths['Ha+SII+SIII+He'] = [6564.61, 6718.29, 6732.67, 9068.6, 9530.6, 10830.]\\n line_ratios['Ha+SII+SIII+He'] = [1., 1./10, 1./10, 1./20, 2.44/20, 1./25.]\\n\\n line_wavelengths['Ha+NII+SII+SIII+He'] = [6564.61, 6549.86, 6585.27, 6718.29, 6732.67, 9068.6, 9530.6, 10830.]\\n line_ratios['Ha+NII+SII+SIII+He'] = [1., 1./(4.*4), 3./(4*4), 1./10, 1./10, 1./20, 2.44/20, 1./25.]\\n \\n line_wavelengths['OIII+Hb'] = [5008.240, 4960.295, 4862.68]\\n line_ratios['OIII+Hb'] = [2.98, 1, 3.98/6.]\\n \\n line_wavelengths['OIII+Hb+Ha'] = [5008.240, 4960.295, 4862.68, 6564.61]\\n line_ratios['OIII+Hb+Ha'] = [2.98, 1, 3.98/10., 3.98/10.*2.86]\\n\\n line_wavelengths['OIII+Hb+Ha+SII'] = [5008.240, 4960.295, 4862.68, 6564.61, 6718.29, 6732.67]\\n line_ratios['OIII+Hb+Ha+SII'] = [2.98, 1, 3.98/10., 3.98/10.*2.86*4, 3.98/10.*2.86/10.*4, 3.98/10.*2.86/10.*4]\\n\\n line_wavelengths['OIII+OII'] = [5008.240, 4960.295, 3729.875]\\n line_ratios['OIII+OII'] = [2.98, 1, 3.98/4.]\\n \\n line_wavelengths['OII+Ne'] = [3729.875, 3869]\\n line_ratios['OII+Ne'] = [1, 1./5]\\n \\n return line_wavelengths, line_ratios\",\n \"def mel_frequencies(n_mels=128, fmin=0.0, fmax=11025.0, htk=False):\\n\\n # 'Center freqs' of mel bands - uniformly spaced between limits\\n min_mel = hz_to_mel(fmin, htk=htk)\\n max_mel = hz_to_mel(fmax, htk=htk)\\n\\n mels = np.linspace(min_mel, max_mel, n_mels)\\n\\n return mel_to_hz(mels, htk=htk)\",\n \"def mel_frequencies(n_mels=128, fmin=0.0, fmax=11025.0, htk=False):\\n\\n # 'Center freqs' of mel bands - uniformly spaced between limits\\n min_mel = hz_to_mel(fmin, htk=htk)\\n max_mel = hz_to_mel(fmax, htk=htk)\\n\\n mels = np.linspace(min_mel, max_mel, n_mels)\\n\\n return mel_to_hz(mels, htk=htk)\",\n \"def calculate_wavelength_metric(wavelength_min, wavelength_max):\\n length_max = np.log(550) * 2\\n wavelength = np.abs(wavelength_max + wavelength_min) / 2\\n log_wl = np.log(wavelength)\\n default_met = np.array(log_wl / length_max)\\n scaled_met = 1.75 * (default_met - 0.5) + 0.5\\n if wavelength == 0:\\n return 0\\n else:\\n return scaled_met.clip(min=10e-11, max=1)\",\n \"def _get_lsp_config_frr_bandwidth(self):\\n return self.__lsp_config_frr_bandwidth\",\n \"def wavelength_solution(file_name):\\n file_data = read_file(file_name)\\n header_data = file_data[0]\\n image_data = file_data[1]\\n\\n range_begin = header_data['CRVAL3']\\n pixel_begin = header_data['CRPIX3']\\n step_size = header_data['CD3_3']\\n steps = len(image_data)\\n range_end = range_begin + steps * step_size\\n return {'begin': range_begin, 'end': range_end, 'steps': steps}\",\n \"def get_nlth_dict(rms_uKarcmin_T,type,lmax,spectra=None,rms_uKarcmin_pol=None,beamfile=None):\\n\\n if beamfile is not None:\\n l,bl=np.loadtxt(beamfile,unpack=True)\\n else:\\n bl=np.ones(lmax+2)\\n\\n lth=np.arange(2,lmax+2)\\n nl_th={}\\n if spectra is None:\\n nl_th['TT']=np.ones(lmax)*(rms_uKarcmin_T*np.pi/(60*180))**2/bl[2:lmax+2]**2\\n if type=='Dl':\\n nl_th['TT']*=lth*(lth+1)/(2*np.pi)\\n return nl_th\\n else:\\n if rms_uKarcmin_pol is None:\\n rms_uKarcmin_pol=rms_uKarcmin_T*np.sqrt(2)\\n for spec in spectra:\\n nl_th[spec]=np.zeros(lmax)\\n nl_th['TT']=np.ones(lmax)*(rms_uKarcmin_T*np.pi/(60*180))**2/bl[:lmax]**2\\n nl_th['EE']=np.ones(lmax)*(rms_uKarcmin_pol*np.pi/(60*180))**2/bl[:lmax]**2\\n nl_th['BB']=np.ones(lmax)*(rms_uKarcmin_pol*np.pi/(60*180))**2/bl[:lmax]**2\\n if type=='Dl':\\n for spec in spectra:\\n nl_th[spec]*=lth*(lth+1)/(2*np.pi)\\n return(nl_th)\",\n \"def storeWavelengths(self, nm):\\n pre = \\\"w,0\\\"\\n d = {\\\"wavelength_nm\\\": list(nm)}\\n self._writeline(pre, str(d))\",\n \"def sans_monitor() -> dict:\\n return {**beamline.beamline(scatter=False), **tof.elastic_wavelength('tof')}\",\n \"def _lookup_bands(platform, wavelengths):\\r\\n wave_bands = {\\r\\n Platform.Landsat5: {\\r\\n \\\"blue\\\": \\\"1\\\",\\r\\n \\\"green\\\": \\\"2\\\",\\r\\n \\\"red\\\": \\\"3\\\",\\r\\n \\\"nir\\\": \\\"4\\\",\\r\\n \\\"swir1\\\": \\\"5\\\",\\r\\n \\\"tirs\\\": \\\"6\\\",\\r\\n \\\"swir2\\\": \\\"7\\\",\\r\\n },\\r\\n Platform.Landsat7: {\\r\\n \\\"blue\\\": \\\"1\\\",\\r\\n \\\"green\\\": \\\"2\\\",\\r\\n \\\"red\\\": \\\"3\\\",\\r\\n \\\"nir\\\": \\\"4\\\",\\r\\n \\\"swir1\\\": \\\"5\\\",\\r\\n \\\"tirs1\\\": \\\"6_VCID_1\\\",\\r\\n \\\"tirs2\\\": \\\"6_VCID_2\\\",\\r\\n \\\"swir2\\\": \\\"7\\\",\\r\\n \\\"pan\\\": \\\"8\\\",\\r\\n },\\r\\n Platform.Landsat8: {\\r\\n \\\"aerosol\\\": \\\"1\\\",\\r\\n \\\"blue\\\": \\\"2\\\",\\r\\n \\\"green\\\": \\\"3\\\",\\r\\n \\\"red\\\": \\\"4\\\",\\r\\n \\\"nir\\\": \\\"5\\\",\\r\\n \\\"swir1\\\": \\\"6\\\",\\r\\n \\\"swir2\\\": \\\"7\\\",\\r\\n \\\"pan\\\": \\\"8\\\",\\r\\n \\\"cirrus\\\": \\\"9\\\",\\r\\n \\\"tirs1\\\": \\\"10\\\",\\r\\n \\\"tirs2\\\": \\\"11\\\",\\r\\n },\\r\\n Platform.Sentinel2: {\\r\\n \\\"aerosol\\\": \\\"0\\\",\\r\\n \\\"blue\\\": \\\"1\\\",\\r\\n \\\"green\\\": \\\"2\\\",\\r\\n \\\"red\\\": \\\"3\\\",\\r\\n \\\"rededge1\\\": \\\"4\\\",\\r\\n \\\"rededge2\\\": \\\"5\\\",\\r\\n \\\"rededge3\\\": \\\"6\\\",\\r\\n \\\"nir\\\": \\\"7\\\",\\r\\n \\\"rededge4\\\": \\\"8\\\",\\r\\n \\\"watervapor\\\": \\\"9\\\",\\r\\n \\\"cirrus\\\": \\\"10\\\",\\r\\n \\\"swir1\\\": \\\"11\\\",\\r\\n \\\"swir2\\\": \\\"12\\\",\\r\\n },\\r\\n }\\r\\n\\r\\n return [wave_bands[platform][wavelength.lower()] for wavelength in wavelengths]\",\n \"def preprocessing(self, spectra, windownum, peaknum):\\n sampleDict = {}\\n for spectrum in spectra:\\n assert spectrum.getAnnotation() is None\\n parentMass = spectrum.getParentMass()\\n winSize = parentMass / windownum\\n winList = [0]\\n mass = 0\\n for k in range(windownum+1):\\n mass = mass + winSize\\n winList.append(mass)\\n \\n i = 1 \\n selecpeaks = []\\n peaks = []\\n for peak in spectrum.getPeaks():\\n mz = peak.getMz()\\n while i < len(winList)-1: \\n if mz > winList[i]: \\n i += 1\\n if peaks != []:\\n temppeaks = self.sortedPeak(peaks,peaknum)\\n selecpeaks.extend(temppeaks)\\n peaks = []\\n else: \\n peaks.append(peak)\\n break\\n if i >= len(winList) : break \\n title = spectrum.getTitle() \\n sampleDict[title] = selecpeaks\\n# print spectrum.getParentMass()\\n# print spectrum.getTitle()\\n# break\\n return sampleDict\",\n \"def getPeakProperties(self):\\n peaks = {}\\n for pname in self.properties:\\n peaks[pname] = self.peak_fitter.getPeakProperty(pname)\\n\\n # x,y,z corrections.\\n if (pname == \\\"x\\\"):\\n peaks[pname] -= float(self.peak_finder.margin)\\n\\n elif (pname == \\\"y\\\"):\\n peaks[pname] -= float(self.peak_finder.margin)\\n \\n elif (pname == \\\"z\\\"):\\n peaks[pname] = self.peak_fitter.rescaleZ(peaks[pname])\\n\\n return peaks\",\n \"def wavelength(self):\\n return self.get(self._names[\\\"wavelength\\\"])\",\n \"def _init_meg_map_dict(bands, length=0):\\n\\n # Initialize dictionary\\n meg_map = dict()\\n\\n # Add oscillation bands\\n for band in bands:\\n meg_map[band] = np.zeros(length)\\n\\n return meg_map\",\n \"def get_log_melspectrogram(audio, sr = 22050, hop_length = 220, n_fft = 1024, n_mels = 80, fmin = 64, fmax = 8000):\\n bands = librosa.feature.melspectrogram(\\n y=audio, sr=sr, hop_length=hop_length, n_fft=n_fft, n_mels=n_mels, fmin=fmin, fmax=fmax, dtype=np.float32)\\n return librosa.core.power_to_db(bands, amin=1e-7)\",\n \"def getBandwidth(self):\\n # Use mean of the magnitudes as threshold\\n threshold = np.mean([x[1] for x in self.fDomain])\\n \\n # Find freqencies which have magnitude greater than threshold\\n nonZero = [f for f,x in self.fDomain if x > threshold]\\n\\n bandwidth = max(nonZero) - min(nonZero)\\n return bandwidth\",\n \"def bls_peakfinder(results):\\n maxima = find_peaks(results.power, distance=100)[0]\\n\\n top_power_inds = maxima[np.argsort(results.power[maxima])[::-1]]\\n\\n highest_peak = results.power[top_power_inds[0]]\\n next_highest_peak = results.power[top_power_inds[1]]\\n\\n significance = highest_peak / next_highest_peak\\n\\n return top_power_inds, significance\",\n \"def GetWavelengths (self) :\\n\\t\\treturn self.run(\\\"GetWavelengths\\\")\",\n \"def _decode_35700(data):\\n start_byte = 0\\n n_bytes = 2\\n var_id = struct.unpack('<H', data[start_byte:start_byte + n_bytes])[0]\\n if var_id == 29979:\\n start_byte += n_bytes\\n n_bytes = 8\\n wavelength_step = struct.unpack(\\n '<d', data[start_byte:start_byte + n_bytes])[0]\\n return {'wavelength_step': wavelength_step}\",\n \"def compute_melspecs(audio):\\n return librosa.feature.melspectrogram(y=audio,\\n sr=SR,\\n n_mels=N_MELS,\\n n_fft=N_FFT,\\n hop_length=HOP_LENGTH,\\n fmin=MEL_FMIN,\\n fmax=MEL_FMAX)\",\n \"def melfrequencies_mel_filterbank(self, num_bands, freq_min, freq_max, num_fft_bands):\\n\\n mel_max = self.hertz_to_mel(freq_max)\\n mel_min = self.hertz_to_mel(freq_min)\\n delta_mel = abs(mel_max - mel_min) / (num_bands + 1.0)\\n frequencies_mel = mel_min + delta_mel * arange(0, num_bands + 2)\\n lower_edges_mel = frequencies_mel[:-2]\\n upper_edges_mel = frequencies_mel[2:]\\n center_frequencies_mel = frequencies_mel[1:-1]\\n return center_frequencies_mel, lower_edges_mel, upper_edges_mel\",\n \"def wavelength(self):\\n return self.getparam(\\\"WAVELENGTH\\\")\",\n \"def wavelength(self):\\n return self.getparam(\\\"WAVELENGTH\\\")\",\n \"def mel(sr, n_fft, n_mels=128, fmin=0.0, fmax=None, htk=False):\\n\\n if fmax is None:\\n fmax = float(sr) / 2\\n\\n # Initialize the weights\\n n_mels = int(n_mels)\\n weights = np.zeros((n_mels, int(1 + n_fft / 2)))\\n\\n # Center freqs of each FFT bin\\n fftfreqs = librosa.fft_frequencies(sr=sr, n_fft=n_fft)\\n\\n # 'Center freqs' of mel bands - uniformly spaced between limits\\n freqs = librosa.mel_frequencies(n_mels,\\n fmin=fmin,\\n fmax=fmax,\\n htk=htk,\\n extra=True)\\n\\n # Slaney-style mel is scaled to be approx constant energy per channel\\n enorm = 2.0 / (freqs[2:n_mels+2] - freqs[:n_mels])\\n\\n for i in range(n_mels):\\n # lower and upper slopes for all bins\\n lower = (fftfreqs - freqs[i]) / (freqs[i+1] - freqs[i])\\n upper = (freqs[i+2] - fftfreqs) / (freqs[i+2] - freqs[i+1])\\n\\n # .. then intersect them with each other and zero\\n weights[i] = np.maximum(0, np.minimum(lower, upper)) * enorm[i]\\n\\n return weights\",\n \"def bandwidth(configuration):\\n bandwidth_dict_all = {\\n \\\"HL\\\" : {'H1' : 117.4, 'L1' : 117.4},\\n \\\"HLV\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9},\\n \\\"HLVK\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, 'K1' : 148.9},\\n \\\"HLVKI\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, 'K1' : 148.9, 'I1' : 117.4},\\n \\\"GW170817\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9},\\n \\\"GW170817_without_Virgo\\\" : {'H1' : 117.4, 'L1' : 117.4},\\n \\\"GW170814\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9},\\n \\\"design\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9 },\\n \\\"early\\\" : {'H1' : 123.7, 'L1' : 123.7 },\\n \\\"half_virgo\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9 },\\n \\\"half_ligo\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9 },\\n \\\"nosrm\\\" : {'H1' : 43, 'L1' : 43, 'V1': 58 },\\n \\\"india\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, \\\"I1\\\" : 117.4 },\\n \\\"kagra\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, \\\"I1\\\" : 117.4, \\\\\\n \\\"K1\\\" : 89.0 },\\n \\\"bala\\\" : {'H1' : 117.4, 'H2' : 117.4, 'L1' : 117.4, 'V1': 148.9, \\\\\\n \\\"I1\\\" : 117.4, \\\"K1\\\" : 89.0 },\\n \\\"sa\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, \\\"I1\\\" : 117.4, \\\\\\n \\\"K1\\\" : 89.0 , \\\"S1\\\": 117.4},\\n \\\"sa2\\\" : {'H1' : 117.4, 'L1' : 117.4, 'V1': 148.9, \\\"I1\\\" : 117.4, \\\\\\n \\\"K1\\\" : 89.0 , \\\"S1\\\": 117.4},\\n \\\"steve\\\" : {'H1' : 100.0, 'L1' : 100.0, 'V1': 100.0, \\\"I1\\\" : 100.0 },\\n \\\"s6vsr2\\\" : {'H1' : 100., 'L1' : 100., 'V1': 120. }\\n }\\n return(bandwidth_dict_all[configuration])\",\n \"def wavelength_ex(hdulist):\\n wave = hdulist[1].data['loglam']\\n wave = 10**wave\\n\\n return wave\",\n \"def getBandwidths( astrobands ):\\n\\n slPrefix = \\\"Control.SpectralLineCorrelator.Slcband\\\"\\n wbPrefix = \\\"Control.WidebandCorrelator.Wbcband\\\"\\n bwSuffix = \\\".ControlBandPoints.bandwidth\\\"\\n spmMpPrefix = \\\"SignalPath.Mapping.Astroband%d.Input1\\\" \\n corrBandMpName = spmMpPrefix + \\\".corrBandNo\\\"\\n bwMpNames = []\\n for astroband in astrobands: \\n corrDesStr = commands.astrobandCorrelator( astroband )\\n corrBandNo = commands.queryInt( corrBandMpName%astroband )\\n if corrDesStr == 'SPECTRAL':\\n bwMpNames.append( \\\"%s%d%s\\\"%(slPrefix,corrBandNo,bwSuffix) )\\n elif corrDesStr == 'WIDEBAND':\\n bwMpNames.append( \\\"%s%d%s\\\"%(wbPrefix,corrBandNo,bwSuffix) )\\n else:\\n raise Exception, 'Invalid corrDesStr: '+ corrDesStr\\n \\n bwMpValues = commands.queryMpValues( bwMpNames )\\n return bwMpValues[:]\",\n \"def repackageSamples(pinsToMeasure, pinMap, nMilliBlocks, samples):\\n\\n channels = [None, None, None, None]\\n for pinName in pinsToMeasure:\\n channels[pinMap[pinName]] = ( { \\\"pinName\\\": pinName, \\\"isAudio\\\": isAudio(pinName), \\\"min\\\": [], \\\"max\\\": [] } )\\n\\n i = 0\\n for blk in range(0, nMilliBlocks):\\n for channel in channels:\\n if channel != None:\\n channel[\\\"max\\\"].append(ord(samples[i]))\\n i += 1\\n channel[\\\"min\\\"].append(ord(samples[i]))\\n i += 1\\n\\n return channels\",\n \"def waveparameterh(L):\\r\\n return 8.13 - ((250 - 0.7 * L) / 125) ** 3\",\n \"def measure_program(self, channels: Iterable[str]) -> Dict[str, numpy.ndarray]:\",\n \"def wavelength(energy):\\r\\n return 2 * np.pi * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy\",\n \"def FindNormalizationWeights(wavelength,\\n wave_resol,\\n alpha_resol,\\n beta_resol):\\n alpha_weight = 1.0\\n beta_weight = 1.0\\n lambda_weight = 1.0\\n\\n # alpha psf weighting\\n alpha_wave_cutoff = alpha_resol[0]\\n alpha_a_short = alpha_resol[1]\\n alpha_b_short = alpha_resol[2]\\n alpha_a_long = alpha_resol[3]\\n alpha_b_long = alpha_resol[4]\\n if wavelength < alpha_wave_cutoff:\\n alpha_weight = alpha_a_short + alpha_b_short * wavelength\\n else:\\n alpha_weight = alpha_a_long + alpha_b_long * wavelength\\n\\n # beta psf weighting\\n beta_wave_cutoff = beta_resol[0]\\n beta_a_short = beta_resol[1]\\n beta_b_short = beta_resol[2]\\n beta_a_long = beta_resol[3]\\n beta_b_long = beta_resol[4]\\n if wavelength < beta_wave_cutoff:\\n beta_weight = beta_a_short + beta_b_short * wavelength\\n else:\\n beta_weight = beta_a_long + beta_b_long * wavelength\\n\\n # wavelength weighting\\n wavecenter = wave_resol[0]\\n a_ave = wave_resol[1]\\n b_ave = wave_resol[2]\\n c_ave = wave_resol[3]\\n wave_diff = wavelength - wavecenter\\n resolution = a_ave + b_ave * wave_diff + c_ave * wave_diff * wave_diff\\n lambda_weight = wavelength / resolution\\n weight = [alpha_weight, beta_weight, lambda_weight]\\n return weight\",\n \"def load_clip_times_FPTL_format(clip_list_file, \\n path_to_data, \\n start_times_file, \\n output_dir,\\n clip_window=None, \\n clip_window_origin=None,\\n plot_fluor_around_peaks=False,\\n delay = 0.0933492779732,\\n print_peak_vals=True,\\n print_peak_times = True ):\\n\\n print \\\"clip_list_file\\\", clip_list_file\\n pkl_file = open(clip_list_file, 'rb')\\n data = pickle.load(pkl_file)\\n print 'data', data\\n\\n movie_info_dict = dict()\\n all_start_times_dict = load_start_times(start_times_file)\\n\\n all_peak_vals = dict()\\n\\n for key in data:\\n if key != 'labels':\\n movie_info = dict()\\n trial = data[key]\\n print 'data[labels]', data['labels']\\n print 'key', key\\n label = data['labels'][key]\\n print label.split('_', 3)\\n animal_id, date, exp_type, mouse_type = label.split('_', 3)\\n name = animal_id + '_' + date + '_' + exp_type\\n print name\\n print mouse_type\\n\\n movie_info['movie_file'] = get_movie_file(name, path_to_data)\\n movie_info['output_file'] = get_output_file(name, output_dir)\\n peak_inds = data[key]['peak_indices']\\n if 'fluor_data' in trial:\\n time_stamps = trial['time_stamps']\\n fluor_data = trial['fluor_data']\\n else:\\n print \\\"using decimated time series\\\"\\n time_stamps = trial['time_stamps_decimated']\\n fluor_data = trial['fluor_data_decimated']\\n time_stamps = time_stamps - delay\\n print \\\"INCLUDING DELAY from filter: \\\", delay\\n\\n\\n movie_info['peak_times'] = time_stamps[peak_inds]\\n movie_info['peak_vals'] = fluor_data[peak_inds]\\n movie_info['name'] = name\\n movie_info['start_time'] = all_start_times_dict[name]\\n movie_info['mouse_type'] = mouse_type\\n movie_info['interaction_start'] = None\\n movie_info['interaction_end'] = None\\n movie_info['mouse_type'] = mouse_type\\n\\n movie_info_dict[name] = movie_info\\n\\n all_peak_vals[name] = movie_info['peak_vals']\\n\\n if plot_fluor_around_peaks:\\n if clip_window is not None and clip_window_origin is not None:\\n plotFluorAroundPeaks(fluor_data, time_stamps, peak_inds,\\n clip_window, clip_window_origin,\\n output_dir, name, movie_info['start_time'])\\n\\n if print_peak_vals:\\n output_folder = output_dir + '/peak_vals/'\\n if not os.path.exists(output_folder):\\n os.makedirs(output_folder)\\n w = csv.writer(open(output_folder+'peak_vals.csv', \\\"w\\\"), delimiter=',')\\n for key, val in all_peak_vals.items():\\n w.writerow([key] + [', '.join([str(x) for x in val])])\\n\\n pickle.dump( all_peak_vals, open( output_folder + 'peak_vals.pkl', \\\"wb\\\" ) )\\n\\n\\n if print_peak_times:\\n output_folder = output_dir + '/peak_times/'\\n if not os.path.exists(output_folder):\\n os.makedirs(output_folder)\\n filename = output_folder+'peak_times.txt'\\n f = open(filename, 'w')\\n for trial in movie_info_dict.keys():\\n movie_info = movie_info_dict[trial]\\n peak_times = movie_info['peak_times']\\n name = movie_info['name']\\n f.write(\\\"%s\\\\n\\\" % name)\\n for val in peak_times:\\n f.write(\\\"%f\\\\n\\\" %val)\\n f.close()\\n print filename\\n\\n\\n ## Print for debugging, and to check that labels match up with blind data\\n # print 'peak_inds', peak_inds, np.max(peak_inds)\\n # print \\\"movie_info['peak_times'] \\\", movie_info['peak_times'] \\n # print \\\"movie_info['peak_vals']\\\", movie_info['peak_vals']\\n # pp = pprint.PrettyPrinter(indent=4)\\n # pp.pprint( trial['labels'])\\n\\n return movie_info_dict\",\n \"def wavelength(energy):\\n return 2 * PI * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy\",\n \"def fetchChannelMapping(verbose=False):\\n\\n # Check (from pbworks):\\n #High freq. 305 473 360 170.312 \\n #Medium freq. 154 424 209 140.820 \\n #Low freq. 079 400 134 126.172 \\n\\n calibrator_chans=[55, 57, 63, 66, 68, 69, 71, 72, 73, 76, 77, 79, 83, 84, 85, 86, 90, 92, 99, 100, 101, 103, 104, 107, 108, 110, 117, 119, 121, 122, 123, 126, 130, 131, 134, 136, 137, 140, 141, 145, 147, 150, 151, 156, 157, 161, 162, 168, 170, 175, 176, 178, 185, 188, 196, 197, 201, 202, 209, 213, 217, 221, 224, 230, 235, 238, 242, 246, 254, 255, 258, 259, 260, 264, 268, 269, 271, 274, 278, 279, 280, 283, 286, 291, 295, 297, 301, 306, 307, 312, 313, 314, 317, 319, 322, 323, 325, 328, 329, 332, 341, 343, 344, 346, 347, 352, 356, 360, 361, 364, 369, 371, 382, 383, 390, 398, 401, 404, 411, 412, 414, 419]\\n\\n lofar2beams={}; cal2field={}; field2cal={}; cal2lofar={}; field2lofar={}\\n\\n zero_chan=55\\n num_field_chans=366\\n num_total_chans=488\\n for nf in range(zero_chan,zero_chan+num_total_chans):\\n lofar_chan=nf\\n field_chan=lofar_chan-zero_chan\\n field2lofar[field_chan]=lofar_chan\\n if lofar_chan in calibrator_chans:\\n cal_chan=num_field_chans+calibrator_chans.index(lofar_chan)\\n if verbose:\\n print lofar_chan, field_chan, ' C ', cal_chan\\n lofar2beams[lofar_chan]=(field_chan,cal_chan)\\n cal2field[cal_chan]=field_chan\\n field2cal[field_chan]=cal_chan\\n cal2lofar[cal_chan]=lofar_chan\\n else:\\n if verbose:\\n print lofar_chan, lofar_chan-zero_chan, ' - ', ' - '\\n lofar2beams[lofar_chan]=(field_chan,None)\\n field2cal[field_chan]=None\\n\\n return lofar2beams,cal2field,field2cal,cal2lofar,field2lofar\",\n \"def mel_frequencies(n_mels: int, fmin: float, fmax: float):\\n low = hz_to_mel(torch.tensor(float(fmin))).item()\\n high = hz_to_mel(torch.tensor(float(fmax))).item()\\n mels = torch.linspace(low, high, n_mels)\\n return mel_to_hz(mels)\",\n \"def peaks(n, binCenters, method=\\\"JI\\\", window=100, peakAmpThresh=0.00005, valleyThresh=0.00003):\\n data = zip(binCenters, n)\\n binCenters = np.array(binCenters)\\n firstCenter = (min(binCenters)+1.5*window)/window*window\\n lastCenter = (max(binCenters)-window)/window*window\\n if firstCenter < -1200: firstCenter = -1200\\n if lastCenter > 3600: lastCenter = 3600\\n\\n\\n if method == \\\"slope\\\" or method == \\\"hybrid\\\":\\n peaks = {}\\n peakInfo = peaksBySlope(n, binCenters, lookahead=20, delta=valleyThresh, averageHist=True)\\n\\n #find correspondences between peaks and valleys, and set valleys are left and right Indices\\n #see the other method(s) for clarity!\\n\\n peakData = peakInfo[\\\"peaks\\\"]\\n valleyData = peakInfo[\\\"valleys\\\"]\\n\\n #print len(peakData[0]), len(peakData[1])\\n for i in xrange(len(peakData[0])):\\n nearestIndex = findNearestIndex(valleyData[0], peakData[0][i])\\n if valleyData[0][nearestIndex] < peakData[0][i]:\\n leftIndex = findNearestIndex(binCenters, valleyData[0][nearestIndex])\\n if (len(valleyData[0][nearestIndex+1:]) == 0):\\n rightIndex = findNearestIndex(binCenters, peakData[0][i]+window/2.0)\\n else:\\n offset = nearestIndex+1\\n nearestIndex = offset+findNearestIndex(valleyData[0][offset:], peakData[0][i])\\n rightIndex = findNearestIndex(binCenters, valleyData[0][nearestIndex])\\n else:\\n rightIndex = findNearestIndex(binCenters, valleyData[0][nearestIndex])\\n if (len(valleyData[0][:nearestIndex]) == 0):\\n leftIndex = findNearestIndex(binCenters, peakData[0][i]-window/2.0)\\n else:\\n nearestIndex = findNearestIndex(valleyData[0][:nearestIndex], peakData[0][i])\\n leftIndex = findNearestIndex(binCenters, valleyData[0][nearestIndex])\\n\\n pos = findNearestIndex(binCenters, peakData[0][i])\\n #print binCenters[pos], peakData[1][i], binCenters[leftIndex], binCenters[rightIndex]\\n peaks[pos] = [peakData[1][i], leftIndex, rightIndex]\\n\\n if method == \\\"hybrid\\\": slopePeaks = peaks\\n \\n if method == \\\"JI\\\" or method == \\\"ET\\\" or method == \\\"hybrid\\\":\\n peaks = {}\\n #Obtain max value per interval\\n if method == \\\"JI\\\" or method == \\\"hybrid\\\":\\n firstCenter = nearestJI(firstCenter)\\n lastCenter = nearestJI(lastCenter)\\n\\n interval = firstCenter\\n prevInterval = firstCenter-window\\n #NOTE: All *intervals are in cents. *indices are of binCenters/n\\n while interval < lastCenter:\\n if method == \\\"ET\\\":\\n leftIndex = findNearestIndex(binCenters, interval-window/2)\\n rightIndex = findNearestIndex(binCenters, interval+window/2)\\n interval += window\\n elif method == \\\"JI\\\" or method == \\\"hybrid\\\":\\n leftIndex = findNearestIndex(binCenters, (interval+prevInterval)/2.0)\\n prevInterval = interval\\n interval = nextJI(interval)\\n rightIndex = findNearestIndex(binCenters, (interval+prevInterval)/2.0)\\n peakPos = np.argmax(n[leftIndex:rightIndex])\\n peakAmp = n[leftIndex+peakPos]\\n peaks[leftIndex+peakPos] = [peakAmp, leftIndex, rightIndex]\\n \\n #print binCenters[leftIndex], binCenters[rightIndex], binCenters[leftIndex+peakPos], peakAmp\\n #NOTE: All the indices (left/rightIndex, peakPos) are to be changed to represent respective cent \\n #value corresponding to the bin. Right now, they are indices of respective binCenters in the array.\\n \\n if method == \\\"hybrid\\\":\\n #Mix peaks from slope method and JI method.\\n p1 = slopePeaks.keys()\\n p2 = peaks.keys()\\n allPeaks = {} #overwriting peaks dict\\n for p in p1:\\n nearIndex = findNearestIndex(p2, p)\\n if abs(p-p2[nearIndex]) < window/2.0: p2.pop(nearIndex)\\n \\n for p in p1: allPeaks[p] = slopePeaks[p]\\n for p in p2: allPeaks[p] = peaks[p]\\n peaks = allPeaks\\n\\n #Filter the peaks and retain eligible peaks, also get their valley points.\\n\\n # ----> peakAmpThresh <---- : remove the peaks which are below that\\n\\n for pos in peaks.keys():\\n #pos is an index in binCenters/n. DOES NOT refer to a cent value.\\n if peaks[pos][0] < peakAmpThresh:\\n #print \\\"peakAmp: \\\", binCenters[pos]\\n peaks.pop(pos)\\n\\n #Check if either left or right valley is deeper than ----> valleyThresh <----.\\n valleys = {}\\n for pos in peaks.keys():\\n leftLobe = n[peaks[pos][1]:pos]\\n rightLobe = n[pos:peaks[pos][2]]\\n #Sanity check: Is it a genuine peak? Size of distributions on either side of the peak should be comparable.\\n if len(leftLobe) == 0 or len(rightLobe) == 0:\\n continue\\n if 1.0*len(leftLobe)/len(rightLobe) < 0.15 or 1.0*len(leftLobe)/len(rightLobe) > 6.67:\\n #print \\\"size: \\\", binCenters[pos]\\n #peaks.pop(pos)\\n continue\\n\\n leftValleyPos = np.argmin(leftLobe)\\n rightValleyPos = np.argmin(rightLobe)\\n if (abs(leftLobe[leftValleyPos]-n[pos]) < valleyThresh and abs(rightLobe[rightValleyPos]-n[pos]) < valleyThresh):\\n #print \\\"valley: \\\", binCenters[pos]\\n peaks.pop(pos)\\n else:\\n valleys[peaks[pos][1]+leftValleyPos] = leftLobe[leftValleyPos]\\n valleys[pos+rightValleyPos] = rightLobe[rightValleyPos]\\n \\n if len(peaks) > 0:\\n temp1 = np.array(peaks.values())\\n temp1 = temp1[:, 0]\\n\\n return {'peaks':[binCenters[peaks.keys()], temp1], 'valleys':[binCenters[valleys.keys()], valleys.values()]}\\n else:\\n return {'peaks':[[], []], 'valleys':[[], []]}\",\n \"def efficiency_vs_w(wmax, wmin=10, Lmax=1000, Lmin=102.4, p=75, fmax=5.7e9,\\r\\n p1=database['K+'], p2=database['pi+'], p3=database['p+'],\\r\\n E=1e6, delta_p=1.6e-2, nw=10, nL=10, ng=50, nl=50, nf=20,\\r\\n resolution=0.01, w_resolution=0.01, plot=True,\\r\\n set_freq=5.7e9, count_L=False, count_w=True):\\r\\n if resolution == None:\\r\\n if set_freq == None:\\r\\n est = timing(nw*nL*ng*nl*nf*4e-05)\\r\\n else:\\r\\n est = timing(nw*nL*ng*nl*4e-05)\\r\\n print('Estimated total time: {0}'.format(est))\\r\\n else:\\r\\n num = int(round(np.log10(Lmax-Lmin))-1)-np.log10(resolution)+1\\r\\n if set_freq == None:\\r\\n est = timing(nw*10*num*ng*nl*nf*4e-05)\\r\\n else:\\r\\n est = timing(nw*10*num*ng*nl*4e-05)\\r\\n print('Estimated maximum total time: {0}'.format(est))\\r\\n start = time.time()\\r\\n if w_resolution == None:\\r\\n w_range = np.linspace(wmin, wmax, int(nw))\\r\\n plot_w, length, intensity = [], [], []\\r\\n for w in w_range:\\r\\n if count_w == True:\\r\\n if count_L == True:\\r\\n print(f'w = {w} mm')\\r\\n else:\\r\\n print(w)\\r\\n eff = efficiency_vs_length(w, Lmax, Lmin, p, fmax,p1, p2, p3, E,\\r\\n delta_p, nL, ng, nl, nf, resolution,\\r\\n False, set_freq, False, count_L)\\r\\n if eff != None:\\r\\n plot_w.append(w)\\r\\n length.append(eff[0])\\r\\n intensity.append(eff[2])\\r\\n file = open(f'Save_Data_efficiency_vs_w_{wmin}_{wmax}.txt','a')\\r\\n file.write(f'{[plot_w[-1], length[-1], intensity[-1]]}\\\\n')\\r\\n file.close()\\r\\n length, intensity = np.array(length), np.array(intensity)\\r\\n ratio = 1/(length*intensity)\\r\\n ratio *= (np.max(intensity)-np.min(intensity))/(np.max(ratio)-np.min(ratio))\\r\\n ratio += ((np.min(intensity))-np.min(ratio))\\r\\n output = [plot_w[np.argmax(ratio)], plot_w[np.argmin(length)], plot_w[np.argmin(intensity)]]\\r\\n else:\\r\\n wmax = 10*(int(wmax/10)+2)\\r\\n wmin = 10*int(wmin/10)\\r\\n n = 10\\r\\n while n >= w_resolution:\\r\\n if n == 10 and plot == True:\\r\\n w_range = np.arange(wmin, wmax, n)\\r\\n graph_w, graph_length, graph_intensity, graph_ratio = [], [], [], []\\r\\n for w in w_range:\\r\\n if count_w == True:\\r\\n if count_L == True:\\r\\n print(f'w = {w} mm')\\r\\n else:\\r\\n print(w)\\r\\n eff = efficiency_vs_length(w, Lmax, Lmin, p, fmax,p1, p2, p3, E,\\r\\n delta_p, nL, ng, nl, nf, resolution,\\r\\n False, set_freq, False, count_L)\\r\\n if eff != None:\\r\\n graph_w.append(w)\\r\\n graph_length.append(eff[0])\\r\\n graph_intensity.append(eff[2])\\r\\n graph_ratio.append(1/(eff[0]*eff[2]))\\r\\n i, d_ratio = 1, 0\\r\\n while d_ratio >= 0 and i < np.size(graph_ratio):\\r\\n d_ratio = graph_ratio[i] - graph_ratio[i-1]\\r\\n i += 1\\r\\n if i >= np.size(graph_ratio):\\r\\n output = None\\r\\n break\\r\\n graph_ratio = np.array(graph_ratio)\\r\\n graph_ratio *= (np.max(graph_intensity)-np.min(graph_intensity))/(np.max(graph_ratio)-np.min(graph_ratio))\\r\\n graph_ratio += ((np.min(graph_intensity))-np.min(graph_ratio))\\r\\n d = -int(np.log10(n))\\r\\n output = [round(graph_w[np.argmax(graph_ratio)], d),\\r\\n graph_length[np.argmax(graph_ratio)],\\r\\n graph_intensity[np.argmax(graph_ratio)]]\\r\\n wmax = graph_w[i-1]\\r\\n wmin = graph_w[i-3]\\r\\n n /= 10\\r\\n else:\\r\\n w_range = np.arange(wmin, wmax+n, n)\\r\\n plot_w, length, intensity, ratio = [], [], [], []\\r\\n i, d_ratio = 0, 0\\r\\n d = -int(np.log10(n))\\r\\n while d_ratio >= 0 and i < np.size(w_range):\\r\\n if count_w == True:\\r\\n if count_L == True:\\r\\n print(f'w = {round(w_range[i], d)} mm')\\r\\n else:\\r\\n print(round(w_range[i], d))\\r\\n eff = efficiency_vs_length(w_range[i], Lmax, Lmin, p, fmax,p1,\\r\\n p2, p3, E, delta_p, nL, ng, nl, nf,\\r\\n resolution, False, set_freq, False,\\r\\n count_L)\\r\\n if eff != None:\\r\\n plot_w.append(w_range[i])\\r\\n length.append(eff[0])\\r\\n intensity.append(eff[2])\\r\\n ratio.append(1/(eff[0]*eff[2]))\\r\\n if np.size(ratio) == 1:\\r\\n d_ratio = ratio[-1]\\r\\n else:\\r\\n d_ratio = ratio[-1] - ratio[-2]\\r\\n i += 1\\r\\n if i >= np.size(w_range):\\r\\n output = None\\r\\n break\\r\\n output = [round(plot_w[np.argmax(ratio)], d),\\r\\n length[np.argmax(ratio)],\\r\\n intensity[np.argmax(ratio)]]\\r\\n wmax = w_range[i-1]\\r\\n wmin = w_range[i-3]\\r\\n n /= 10\\r\\n if plot == True:\\r\\n if w_resolution != None:\\r\\n plot_w, length, intensity, ratio = graph_w, graph_length, graph_intensity, graph_ratio\\r\\n fig = plt.figure(figsize=[12, 4])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n line1, = ax.plot(plot_w, length, 'r', lw=2, alpha=0.6, label='Target Distance')\\r\\n ax2 = ax.twinx()\\r\\n line2, = ax2.plot(plot_w, intensity, 'g', lw=2, alpha=0.6, label='Intensity Required')\\r\\n line3, = ax2.plot(plot_w, ratio, 'b', lw=2, alpha=0.6, label='Reciprocal Product')\\r\\n ax.set_xlabel('Collimator Width / mm', fontsize=20)\\r\\n ax.set_ylabel('Target Distance / m', fontsize=20, color='r')\\r\\n ax2.set_ylabel(r'Intensity / I$_0$', fontsize=20, color='g')\\r\\n ax.set_xlim(np.min(plot_w), np.max(plot_w))\\r\\n ax.tick_params(axis='y', colors=line1.get_color())\\r\\n ax2.tick_params(axis='y', colors=line2.get_color())\\r\\n# ax.set_ylim(0)\\r\\n lines = [line1, line2, line3]\\r\\n ax.legend(lines, [l.get_label() for l in lines], loc=[0.70, 0.12], fontsize=15)\\r\\n ax.minorticks_on()\\r\\n ax2.minorticks_on()\\r\\n ax.grid()\\r\\n ax.set_title(' Minimum required target distance and proton intensity as a function of beam stopper inner radius', fontsize=16)\\r\\n plt.show()\\r\\n print(f'Total time: {timing(time.time()-start)}')\\r\\n return output\",\n \"def _frequency_to_wavelength(freq):\\n return ifc.SPEED_OF_LIGHT_METRES_PER_SECOND / freq\",\n \"def get_power_spectra(self, n_psbins=50, k_min=None, k_max=None, save=True):\\n\\n if self.Park19:\\n # chunk_z_list_HERA = [27.408, 20.306, 16.0448, 13.204, 11.17485714,\\n # 9.653, 8.46933333, 7.5224, 6.74763636, 6.102,\\n # 5.55569231, 5.08742857]\\n chunk_z_list_HERA = [27.15742, 22.97586, 19.66073, 16.98822, 14.80234,\\n 12.99172, 11.4751, 10.19206, 9.09696, 8.15475,\\n 7.33818, 6.62582, 6.0006]\\n else:\\n chunk_z_list_HERA = [27.4, 23.4828, 20.5152, 18.1892, 16.3171, 14.7778, 13.4898, 12.3962,\\n 11.4561, 10.6393, 9.92308, 9.28986, 8.72603, 8.22078, 7.76543,\\n 7.35294, 6.97753, 6.63441, 6.31959, 6.0297, 5.7619, 5.51376, 5.28319,\\n 5.06838]#, 4.86777, 4.68]\\n\\n if self.lightcones is None:\\n self.get_lightcones()\\n chunk_indices_HERA = [np.argmin(np.abs(self.lc_redshifts - z_HERA)) for z_HERA in chunk_z_list_HERA][::-1]\\n\\n if self.vb: print(f' Making powerspectra in {len(chunk_z_list_HERA)} chunks')\\n\\n self.PS = {}\\n use_ETHOS = self.lightcones[0].flag_options.pystruct['USE_ETHOS']\\n\\n for lc in self.lightcones:\\n if use_ETHOS:\\n h_PEAK = np.round(lc.astro_params.pystruct['h_PEAK'],1)\\n key = f'h_PEAK={h_PEAK:.1f}'\\n else:\\n key = self.cosmology\\n\\n theta = lc.astro_params.pystruct[self.param_21cmfast]\\n\\n if self.param == 'k_PEAK':\\n theta = 1./theta**self.k_PEAK_order\\n\\n if self.param == 'L_X' or 'F' in self.param or self.param == 'M_TURN':\\n theta = np.log10(theta) # make L_X, F log10\\n\\n if key not in self.PS:\\n self.PS[key] = {} ##### TODO load PS nicely\\n\\n if self.vb: print(f' Getting PS for {key}, {self.param}={theta}')\\n\\n # Make PS\\n if k_min is None:\\n k_min = self.k_fundamental\\n if k_max is None:\\n k_max = self.k_max\\n\\n self.PS_z_HERA, self.PS[key][f'{self.param}={theta}'] = powerspectra_chunks(lc,\\n n_psbins=n_psbins,\\n chunk_indices=chunk_indices_HERA,\\n k_min=k_min,\\n k_max=k_max)\\n\\n del lc\\n\\n if save:\\n np.save(self.PS_file, self.PS, allow_pickle=True)\\n if self.vb: print(f' saved PS to {self.PS_file}')\\n\\n np.save(self.PS_z_HERA_file, self.PS_z_HERA, allow_pickle=True)\\n if self.vb: print(f' saved PS_z_HERA to {self.PS_z_HERA_file}')\\n\\n return\",\n \"def load_and_get_stats(filename):\\n\\n import scipy.io.wavfile as siow\\n sampling_rate, amplitude_vector = siow.read(filename)\\n\\n wav_length = amplitude_vector.shape[0] / sampling_rate\\n\\n return sampling_rate, amplitude_vector, wav_length\",\n \"def checkfrequency(inputgiven):\\n data_size = 40000\\n wav_file = wave.open(inputgiven, 'r')\\n data = wav_file.readframes(data_size)\\n wav_file.close()\\n data = struct.unpack('{n}h'.format(n=data_size), data)\\n print max(data)\",\n \"def guess_wavelength(x, aperture, identlist, linelist, param):\\n rough_wl = None\\n\\n # guess wavelength from the identified lines in this order\\n if aperture in identlist:\\n list1 = identlist[aperture]\\n if list1.size >= 2:\\n fit_order = min(list1.size-1, 2)\\n local_coeff = np.polyfit(list1['pixel'], list1['wavelength'],\\n deg=fit_order)\\n rough_wl = np.polyval(local_coeff, x)\\n\\n # guess wavelength from global wavelength solution\\n if rough_wl is None and param['coeff'].size > 0:\\n npixel = param['npixel']\\n order = aperture*param['k'] + param['offset']\\n rough_wl = get_wavelength(param['coeff'], param['npixel'], x, order)\\n\\n if rough_wl is None:\\n return None\\n else:\\n # now find the nearest wavelength in linelist\\n wave_list = np.array([line[0] for line in linelist])\\n iguess = np.abs(wave_list-rough_wl).argmin()\\n guess_wl = wave_list[iguess]\\n return guess_wl\",\n \"def _magsamples(self):\\n if self._derived_properties[\\\"magsamples\\\"] is None:\\n if self.lbda is None:\\n raise AttributeError(\\\"lbda not set.\\\")\\n self.derive_magsamples()\\n \\n return self._derived_properties[\\\"magsamples\\\"]\",\n \"def lms_freq_hz(self):\\n return self._lms_freq_hz\",\n \"def get_dictionary_of_peptides_and_isomeric_peak_areas(self, fout_peptides_isomeric_peak_areas):\\n \\n try:\\n fin_handle = open(fout_peptides_isomeric_peak_areas)\\n\\n except IOError:\\n raise(\\\"Provide a file containing percentage peak_area of isomeric peptides\\\")\\n\\n # local list; this appends all lines within a block and is emptied at the end of the block\\n L_peptide_isomeric_peak_area = []\\n\\n block_start = False; pep_NC = \\\"\\\"\\n \\n for line in fin_handle:\\n \\n line = line.strip()\\n \\n # skipping the blank line\\n if not line.strip():\\n continue\\n \\n # skipping the comment line\\n if line[0]==\\\"#\\\":\\n continue\\n \\n \\n if line==\\\"PEPSTART\\\": block_start=True\\n\\n elif line==\\\"PEPEND\\\" :\\n block_start=False\\n \\n #end elif\\n \\n if block_start and line!=\\\"PEPSTART\\\":\\n L = line.split(\\\":\\\")\\n if L[0].strip() == \\\"peptide\\\":\\n pep_NC = L[1].strip() #e.g, '15-25'\\n\\n elif L[0].strip()==\\\"IsomericPeptidesPeakArea\\\":\\n right_side = L[1].strip()\\n\\n L_modtypes_freq_peak_area = [m.strip() for m in right_side.split(\\\" \\\")]\\n percentage_peak_area = L_modtypes_freq_peak_area[-1] # last column\\n D_modtype_freq = {}\\n\\n # running the loop so as to skip the last element\\n for i, m in enumerate(L_modtypes_freq_peak_area[:-1]):\\n mtype = (m.split('=')[0]).strip()\\n freq = (m.split('=')[1]).strip()\\n D_modtype_freq[mtype] = freq\\n\\n #end for\\n\\n L_peptide_isomeric_peak_area.append((D_modtype_freq, percentage_peak_area))\\n \\n # end if block_start and line!=\\\"PEPSTART\\\" \\n\\n # pushing into the dictionary after end of each block\\n\\n if line==\\\"PEPEND\\\":\\n\\n # sorting the list based on total frequency of isomeric peptides\\n L_sorted = sorted(L_peptide_isomeric_peak_area, key=lambda x: sum([int(f) for f in x[0].values()]))\\n \\n self._D_peptide_isomeric_peak_areas[pep_NC] = L_sorted\\n \\n #emptying the list for next block\\n L_peptide_isomeric_peak_area = []\\n \\n # emptying the peptide N_loc, C_loc string at the end of the block\\n pep_NC = \\\"\\\"\",\n \"def signal_dictionary(music_filename):\\n\\tx = []\\n\\ty = []\\n\\tassign_points = {}\\n\\n\\tsignal = input_waves.WAVtoSignal(music_filename)\\n\\tfor i in range(len(signal)):\\n\\t\\tx = signal[i][0]\\n\\t\\ty = signal[i][1]\\n\\t\\tassign_points.update({x:y})\\n\\tprint 'assign dictionary complete'\\n\\treturn assign_points\",\n \"def print_leaks(self):\\n for key in sorted(self.leaks.keys()):\\n print('Failure mode: '+key)\\n print('Failure rate: {:.2~}'.format(self.leaks[key][0]))\\n print('Flow rate: {:.2~}'.format(\\n self.leaks[key][1].to(ureg.ft**3/ureg.min)))\\n print('Event duration: {:.2~}'.format(self.leaks[key][2]))\\n print()\",\n \"def narrowIncandPeakInfoLG(self):\\r\\n\\t\\tself.narrowIncandBaseline_LG = (np.mean(self.lowGainNarrowBandIncandData[0:10]))\\r\\n\\t\\t\\t\\t\\r\\n\\t\\traw_narrowIncand_max_LG = np.amax(self.lowGainNarrowBandIncandData)\\r\\n\\t\\tnarrowIncand_max_LG = raw_narrowIncand_max_LG - self.narrowIncandBaseline_LG\\t\\t\\r\\n\\t\\tnarrowIncand_max_index_LG = np.argmax(self.lowGainNarrowBandIncandData)\\r\\n\\t\\t\\r\\n\\t\\tself.narrowIncandMax_LG =narrowIncand_max_LG\\r\\n\\t\\tself.narrowIncandMaxPos_LG = narrowIncand_max_index_LG\",\n \"def _get_lsp_config_frr_bandwidth_configured(self):\\n return self.__lsp_config_frr_bandwidth_configured\",\n \"def wavelength_range(fits_list):\\r\\n mins = []\\r\\n maxes = []\\r\\n for fname in fits_list:\\r\\n spec = np.genfromtxt(fname.replace('fits', 'txt'), names='wave, flux', \\r\\n dtype='f4, f4')\\r\\n mins.append(spec['wave'].min())\\r\\n maxes.append(spec['wave'].max())\\r\\n return [np.array(mins).min(), np.array(maxes).max()]\",\n \"def readWaveformNames(self):\\n self.sendMessage('WLIST:SIZE?')\\n ansr=self.readMessage()\\n msg=[]\\n for i in xrange (1,int(ansr)+1):\\n msg.append('WLIST:NAME? '+str(i))\\n self.sendMessage(msg)\\n wnames = self.readMessage()\\n names=re.findall('\\\".*?\\\"',wnames)\\n strippednames=[]\\n for name in names:\\n strippednames.append(name.rstrip('\\\"').lstrip('\\\"'))\\n return strippednames\",\n \"def get_spin_link_dict(peaklist):\\n spin_link_dict = {}\\n for peak in peaklist:\\n spins = [spin for spin in peak\\n if spin.atom is not None and spin.atom[0] == 'H']\\n if len(spins) != 2:\\n err = ('expected 2 Hydrogens in each peak, '\\n 'found %d' % len(spins))\\n raise ValueError(err)\\n link = frozenset(spin.assignment for spin in spins)\\n spin_link_dict.setdefault(link, []).append(peak)\\n return spin_link_dict\",\n \"def waveband(self):\\n return self.get(\\\"waveband\\\", default=\\\"\\\", decode=True).split(\\\"#\\\")\",\n \"def get_UL_bw(self,wavelength):\\n sec_before = self.wavelengths[wavelength]['sec_UL_timestamp']\\n if self.env.now > (sec_before + 2):\\n # IF its 2 seconds ahead of last timestamp, it means no more pkts arrived since then\\n return 0\\n return self.wavelengths[wavelength]['last_UL_bps']\",\n \"def numberOfWideBands(config=None):\\n # Get correlator configuration\\n c = config\\n if c == None: \\n c = utils.getConfigAstroband()\\n\\n # Determine if we have both wideband and spectral line astrobands. \\n # If we do, we return nwide & maxbandwidth for sl only since \\n # this is the correlator which will be attached to all ants.\\n astrobands = [ abc[0] for abc in c ]\\n if len( astrobands ) == 0:\\n raise Exception, \\\"No existing astroband configuration.\\\"\\n if max( astrobands ) > 8 and min( astrobands ) < 9: \\n astrobands = [ ab for ab in astrobands if ab < 9 ]\\n\\n # Check bandwidth\\n nwide = 0\\n maxbandwidth = 0\\n for t in c:\\n astroband = t[0]\\n # Skip band if it is not being used or is not in astroband list above.\\n mp = commands.queryString('SignalPath.Mapping.Astroband%d.confTag' % (astroband) )\\n if mp == 'NONE' or astroband not in astrobands: continue\\n\\n # Get bandwidth\\n if t[2] == commands.BW500:\\n bw = 500\\n elif t[2] == commands.BW250:\\n bw = 250\\n elif t[2] == commands.BW125:\\n bw = 125\\n elif t[2] == commands.BW62:\\n bw = 62\\n elif t[2] == commands.BW31:\\n bw = 31\\n elif t[2] == commands.BW8:\\n bw = 8\\n elif t[2] == commands.BW2:\\n bw = 2\\n else:\\n raise Exception, 'Could not find bandwith for '+str(t[2])\\n\\n # Maximum?\\n if bw > maxbandwidth: \\n maxbandwidth = bw\\n if utils.isDualPol( astroband ):\\n nwide = 2 \\n else:\\n nwide = 1\\n elif bw == maxbandwidth:\\n if utils.isDualPol( astroband ): \\n nwide += 2 \\n else:\\n nwide += 1\\n\\n return nwide, maxbandwidth\",\n \"def get_freq_details(diagnostics_dir, verbose=False):\\n metafile_science = find_metadata_file(diagnostics_dir, 'mslist-scienceData*txt', verbose=False)\\n if not metafile_science:\\n return None, None, None\\n\\n with open(metafile_science, 'r') as mslist_file:\\n lines = mslist_file.readlines()\\n\\n in_spw_block = False\\n for line in lines:\\n if in_spw_block:\\n parts = line.split()\\n chan_width = float(parts[10])*1000. # convert kHz to Hz\\n cfreq = parts[12] #MHz\\n nchan = parts[7]\\n break\\n else:\\n in_spw_block = line.find('Frame') >= 0\\n\\n return chan_width, cfreq, nchan\",\n \"def measure_wavelength_avg(self, from_time, to_time, print_n=False):\\n from_idx = self._find_index_for_time(from_time)\\n to_idx = self._find_index_for_time(to_time)\\n \\n # print number of measurements\\n if print_n:\\n n_measurements = to_idx - from_idx + 1\\n print 'n measurements:', n_measurements\\n \\n # calculate overlap\\n overlap = self.overlap()[from_idx:to_idx+1,:]\\n \\n # intitialize wavelength storage\\n wavelengths = np.zeros(overlap.shape[0])\\n \\n for i in range(overlap.shape[0]):\\n this_overlap = overlap[i,:]\\n \\n # set all overlap entries below 0.1% of the maximum overlap to zero\\n this_overlap[this_overlap<0.001*np.max(this_overlap)] = 0.0\\n \\n nonzero = np.nonzero(this_overlap)\\n \\n # find connected section of chain with nonzero overlap\\n consecutives = np.split(nonzero, np.where(np.diff(nonzero) != 1)[0]+1)\\n \\n if len(consecutives) != 1:\\n warnings.warn('Wavelength could not be determined unambiguously.')\\n return np.nan\\n else:\\n # add 1 since overlap involves two beads each\\n wavelengths[i] = float( len(consecutives[0][0]) ) + 1\\n \\n return np.mean( wavelengths )\",\n \"def get_wavelengths(system, info=False):\\n\\n system_data = system.SystemData\\n wavelengths = system_data.Wavelengths\\n N_wavelengths = wavelengths.NumberOfWavelengths\\n\\n if info is True:\\n print(\\\"\\\\nReading Wavelengths\\\")\\n print(\\\"Total Number of Wavelengths: %d\\\" % N_wavelengths)\\n\\n wavelength_array = np.zeros(N_wavelengths)\\n\\n for k in np.arange(1, N_wavelengths + 1):\\n _wave = wavelengths.GetWavelength(k).Wavelength\\n wavelength_array[k - 1] = _wave\\n\\n if info is True:\\n print(\\\"%.5f microns\\\" % _wave)\\n\\n return wavelength_array\",\n \"def bandwidth(self):\\n return self.stop_hz - self.start_hz\",\n \"def get_audio_features(sample, audio_data, max_len, data_truncating, data_filling, audio_cfg):\\n if len(audio_data) > max_len:\\n if data_truncating == \\\"fusion\\\":\\n # fusion\\n mel = get_mel(audio_data, audio_cfg)\\n # split to three parts\\n chunk_frames = max_len // audio_cfg['hop_size']+1 # the +1 related to how the spectrogram is computed\\n total_frames = mel.shape[0]\\n if chunk_frames == total_frames:\\n # there is a corner case where the audio length is\\n # larger than max_len but smaller than max_len+hop_size.\\n # In this case, we just use the whole audio.\\n mel_fusion = np.stack([mel, mel, mel, mel], axis=0)\\n longer = [[False]]\\n else:\\n ranges = np.array_split(list(range(0, total_frames-chunk_frames+1)), 3)\\n # print('total_frames-chunk_frames:', total_frames-chunk_frames,\\n # 'len(audio_data):', len(audio_data),\\n # 'chunk_frames:', chunk_frames,\\n # 'total_frames:', total_frames)\\n if len(ranges[1]) == 0:\\n # if the audio is too short, we just use the first chunk\\n ranges[1] = [0]\\n if len(ranges[2]) == 0:\\n # if the audio is too short, we just use the first chunk\\n ranges[2] = [0]\\n # randomly choose index for each part\\n idx_front = np.random.choice(ranges[0])\\n idx_middle = np.random.choice(ranges[1])\\n idx_back = np.random.choice(ranges[2])\\n # select mel\\n mel_chunk_front = mel[idx_front:idx_front+chunk_frames, :]\\n mel_chunk_middle = mel[idx_middle:idx_middle+chunk_frames, :]\\n mel_chunk_back = mel[idx_back:idx_back+chunk_frames, :]\\n\\n # shrink the mel\\n # Output may differ between torchvision.transforms.Resize and numpy.resize.\\n #mel_shrink_torch = torch.from_numpy(mel[None])\\n #mel_shrink_torch = torchvision.transforms.Resize(size=[chunk_frames, 64])(mel_shrink_torch)[0]\\n #mel_shrink_torch = mel_shrink_torch.to('cpu').detach().numpy().copy()\\n mel_shrink_numpy = np.resize(mel[None], (chunk_frames, 64))\\n # logging.info(f\\\"mel_shrink.shape: {mel_shrink.shape}\\\")\\n\\n # stack\\n mel_fusion = np.stack([mel_chunk_front, mel_chunk_middle, mel_chunk_back, mel_shrink_numpy], axis=0)\\n longer = [[True]]\\n # random crop to max_len (for compatibility)\\n overflow = len(audio_data) - max_len\\n idx = np.random.randint(0, overflow + 1)\\n audio_data = audio_data[idx: idx + max_len]\\n\\n else: # padding if too short\\n if len(audio_data) < max_len: # do nothing if equal\\n if data_filling == \\\"repeatpad\\\":\\n n_repeat = int(max_len/len(audio_data))\\n audio_data = np.tile(audio_data, n_repeat)\\n # audio_data = audio_data.unsqueeze(0).unsqueeze(0).unsqueeze(0)\\n # audio_data = F.interpolate(audio_data,size=max_len,mode=\\\"bicubic\\\")[0,0,0]\\n audio_data = np.pad(audio_data, [(0, max_len - len(audio_data))], \\\"constant\\\")\\n elif data_filling == \\\"pad\\\":\\n audio_data = np.pad(audio_data, [(0, max_len - len(audio_data))], \\\"constant\\\")\\n elif data_filling == \\\"repeat\\\":\\n n_repeat = int(max_len/len(audio_data))\\n audio_data = np.tile(audio_data, n_repeat+1)[:max_len]\\n \\n if data_truncating == 'fusion':\\n mel = get_mel(audio_data, audio_cfg)\\n mel_fusion = np.stack([mel, mel, mel, mel], axis=0)\\n longer = [[False]]\\n\\n return longer, mel_fusion, audio_data\",\n \"def prepare_settings(\\n label_count, sample_rate, clip_duration_ms,\\n window_size_ms, window_stride_ms, dct_coefficient_count):\\n desired_samples = int(sample_rate * clip_duration_ms / 1000)\\n window_size_samples = int(sample_rate * window_size_ms / 1000)\\n window_stride_samples = int(sample_rate * window_stride_ms / 1000)\\n length_minus_window = (desired_samples - window_size_samples)\\n if length_minus_window < 0:\\n spectrogram_length = 0\\n else:\\n spectrogram_length = 1 + int(length_minus_window / window_stride_samples)\\n fingerprint_size = dct_coefficient_count * spectrogram_length\\n return {\\n 'desired_samples': desired_samples,\\n 'window_size_samples': window_size_samples,\\n 'window_stride_samples': window_stride_samples,\\n 'spectrogram_length': spectrogram_length,\\n 'dct_coefficient_count': dct_coefficient_count,\\n 'fingerprint_size': fingerprint_size,\\n 'label_count': label_count,\\n 'sample_rate': sample_rate,\\n }\",\n \"def initDictionary(bands):\\r\\n for x in bands:\\r\\n d[\\\"{}\\\".format(x)] = {ProdCost: [], AlbumSales: []}\",\n \"def get_label_peak_window(\\n pep_query,\\n scan=None, ms_data=None, window_size=1\\n):\\n if scan is None and ms_data is None:\\n return []\\n\\n label_mods = pep_query.get_label_mods\\n\\n if not label_mods:\\n return []\\n\\n window = ms_labels.LABEL_MZ_WINDOW[label_mods[0]]\\n window = (\\n window[0] - window_size,\\n window[1] + window_size\\n )\\n\\n if scan is None:\\n scan = ms_data[pep_query.basename][pep_query.quant_scan]\\n\\n return [\\n (mz, i)\\n for mz, i in scan.centroidedPeaks\\n if mz > window[0] and mz < window[1]\\n ]\",\n \"def reference_spec_wavelength(spec, calib_lst, weight_lst):\\n combined_calib = combine_calib(calib_lst, weight_lst)\\n\\n k = combined_calib['k']\\n offset = combined_calib['offset']\\n xorder = combined_calib['xorder']\\n yorder = combined_calib['yorder']\\n npixel = combined_calib['npixel']\\n coeff = combined_calib['coeff']\\n\\n # calculate the wavelength for each aperture\\n for row in spec:\\n aperture = row['aperture']\\n npoints = len(row['wavelength'])\\n order = aperture*k + offset\\n wavelength = get_wavelength(coeff, npixel,\\n np.arange(npoints), np.repeat(order, npoints))\\n row['order'] = order\\n row['wavelength'] = wavelength\\n\\n card_lst = []\\n #prefix = 'HIERARCH GAMSE WLCALIB'\\n #if fiber is not None:\\n # prefix = prefix + ' FIBER {}'.format(fiber)\\n card_lst.append(('K', k))\\n card_lst.append(('OFFSET', offset))\\n card_lst.append(('XORDER', xorder))\\n card_lst.append(('YORDER', yorder))\\n card_lst.append(('NPIXEL', npixel))\\n\\n # write the coefficients to fits header\\n for j, i in itertools.product(range(yorder+1), range(xorder+1)):\\n key = 'COEFF {:d} {:d}'.format(j, i)\\n value = coeff[j,i]\\n card_lst.append((key, value))\\n\\n # write information for every reference\\n for icalib, (calib, weight) in enumerate(zip(calib_lst, weight_lst)):\\n prefix = 'REFERENCE {:d}'.format(icalib+1)\\n card_lst.append((prefix+' FILEID', calib['fileid']))\\n card_lst.append((prefix+' DATE-OBS', calib['date-obs']))\\n card_lst.append((prefix+' EXPTIME', calib['exptime']))\\n card_lst.append((prefix+' WEIGHT', weight))\\n card_lst.append((prefix+' NTOT', calib['ntot']))\\n card_lst.append((prefix+' NUSE', calib['nuse']))\\n card_lst.append((prefix+' STDDEV', calib['std']))\\n\\n return spec, card_lst\",\n \"def count_convert_wavelength_range(self):\\n mini = ct.c_float()\\n maxi = ct.c_float()\\n self.lib.GetCountConvertWavelengthRange(ct.pointer(mini),\\n ct.pointer(maxi))\\n return (mini.value, maxi.value)\",\n \"def stats():\\r\\n times_lst = []\\r\\n time_dict = {}\\r\\n for album, details in dbase().items():\\r\\n time_m = 0\\r\\n time_s = 0\\r\\n for songs, details_s in details[0].items():\\r\\n time = details_s[1].split(\\\":\\\")\\r\\n min = int(time[0])\\r\\n sec = int(time[1])\\r\\n time_m += min\\r\\n time_s += sec\\r\\n time_s = datetime.timedelta(seconds=time_s)\\r\\n time_m = datetime.timedelta(seconds=time_m)\\r\\n time = time_m + time_s\\r\\n time = str(time)\\r\\n times_lst.append(time)\\r\\n time_dict[album] = time\\r\\n\\r\\n time_dict = sorted(time_dict.items(), key=lambda x: x[1], reverse=True)\\r\\n return time_dict\",\n \"def bandwidths(self):\\n return (band.bandwidth for band in self)\",\n \"def mspec(samples, winlen = 400, winshift = 200, preempcoeff=0.97, nfft=512, samplingrate=20000):\\n frames = enframe(samples, winlen, winshift)\\n preemph = preemp(frames, preempcoeff)\\n windowed = windowing(preemph)\\n spec = powerSpectrum(windowed, nfft)\\n return logMelSpectrum(spec, samplingrate)\",\n \"def estimate_phones(x):\\n if x['mean_luminosity_km2'] > 5:\\n return 10\\n elif x['mean_luminosity_km2'] > 1:\\n return 5\\n else:\\n return 1\",\n \"def update(self, wnd):\\n y = self.fft(wnd)\\n amp = lambda f: y[int(round(self.f2b(wnd.fft_resolution, f)))]\\n amps = [amp(fb) for fb in self.frequencies]\\n return amps\",\n \"def guessToParms(self, stguess):\\n self.peakTyp = []\\n self.parmVal = []\\n self.parmName = []\\n items = str(stguess).split(',')\\n items = [item for item in items if item] # delete empty elements\\n if self.first:\\n # The first time peak is defined by 4 parameters:\\n # type, xc, Amp, width\\n n = 4\\n self.first = False\\n else:\\n # Subsequently each peak is defined by 6 parameters:\\n # type, xc, Amp, width, asym, Lfrac\\n n = 6\\n ntot = len(items)\\n self.npeaks = int(ntot/n)\\n if self.npeaks == 0:\\n return\\n for i in range(0, ntot, n):\\n stpkno = str((i/n)+1)\\n peakTyp = items[i].strip()\\n self.peakTyp.append(peakTyp)\\n self.parmVal.append(float(items[i+1]))\\n self.parmName.append('xm'+stpkno)\\n self.parmVal.append(float(items[i+2]))\\n self.parmName.append('amp'+stpkno)\\n self.parmVal.append(float(items[i+3]))\\n self.parmName.append('wid'+stpkno)\\n # Add two extra parameters, asym and Lfrac\\n asym = 0.0\\n Lfrac = 0.0\\n if peakTyp == 'P' or peakTyp == 'AP':\\n Lfrac = 0.5\\n self.parmVal.append(asym)\\n self.parmName.append('a' + stpkno)\\n self.parmVal.append(Lfrac)\\n self.parmName.append('m' + stpkno)\\n\\n # Set the parameter limits [xm, amp, fwhm, asym, Lfrac]\\n minx = self.data[0].min()\\n maxx = self.data[0].max()\\n minamp = self.data[1].min() * 1.1\\n maxamp = self.data[1].max() * 1.1\\n minw = getSpan(self.data[0]) / self.npt\\n maxw = getSpan(self.data[0]) / (self.npeaks+1)\\n minasy = -1000/maxx\\n maxasy = 1000/maxx\\n minfrac = 0\\n maxfrac = 1.0\\n minbounds = []\\n maxbounds = []\\n for i in range(self.npeaks):\\n minbounds.extend([minx, minamp, minw, minasy, minfrac])\\n maxbounds.extend([maxx, maxamp, maxw, maxasy, maxfrac])\\n self.bounds = (minbounds, maxbounds)\",\n \"def get_wav_info(file_name):\\n wr = wave.open(file_name, 'r')\\n sample_width = wr.getsampwidth()\\n frame_rate = wr.getframerate()\\n num_frames = wr.getnframes()\\n n_channels = wr.getnchannels()\\n s = \\\"sample width: {} bytes\\\\n\\\".format(sample_width) + \\\\\\n \\\"frame rate: {} Hz\\\\n\\\".format(frame_rate) + \\\\\\n \\\"num frames: {}\\\\n\\\".format(num_frames) + \\\\\\n \\\"track length: {} s\\\\n\\\".format(num_frames / frame_rate) + \\\\\\n \\\"num channels: {}\\\\n\\\".format(n_channels)\\n\\n return s\",\n \"def get_powermax_volume_parameters():\\n return dict(\\n vol_name=dict(required=False, type='str'),\\n vol_id=dict(required=False, type='str'),\\n size=dict(type='float'),\\n sg_name=dict(required=False, type='str'),\\n new_sg_name=dict(required=False, type='str'),\\n new_name=dict(required=False, type='str'),\\n cap_unit=dict(choices=['MB', 'GB', 'TB'], type='str'),\\n vol_wwn=dict(required=False, type='str'),\\n state=dict(required=True, type='str', choices=['absent', 'present'])\\n )\",\n \"def calc_power_spectrogram(audio_data, samplerate, n_mels=257, n_fft=400, hop_length=160):\\n spectrogram = librosa.feature.melspectrogram(audio_data, sr=samplerate, n_mels=n_mels, n_fft=n_fft, hop_length=hop_length)\\n\\n # convert to log scale (dB)\\n log_spectrogram = librosa.logamplitude(spectrogram, ref_power=np.max)\\n\\n # normalize\\n normalized_spectrogram = normalize(log_spectrogram)\\n\\n return normalized_spectrogram.T\",\n \"def setup_lls_fit_analy(spec_fil, zlls, lls_windows, NHI_mnx, nNHI=100, spec_keys=None):\\n # Init\\n if spec_keys is None:\\n spec_keys = dict(sig='ERROR', flux='FLUX', wave='WAVE')\\n # Load up spectrum (Table and xspec)\\n spec = Table.read(spec_fil)\\n # Deal with NANs\\n sig = spec[spec_keys['sig']].data.flatten()\\n sig[np.isnan(sig)] = 0.\\n xspec = XSpectrum1D.from_tuple((np.array(spec[spec_keys['wave']].data.flatten()),\\n np.array(spec[spec_keys['flux']].data.flatten()),\\n sig), masking='none')\\n\\n # Analysis pixels\\n pixels = []\\n for window in lls_windows:\\n gdwv = np.where((xspec.wavelength >= window[0]*u.AA) &\\n (xspec.wavelength <= window[1]*u.AA))[0]\\n pixels.append(gdwv)\\n gdwv = np.concatenate(pixels)\\n\\n # NHI\\n NHI = np.linspace(NHI_mnx[0], NHI_mnx[1], num=nNHI)\\n wv_rest = xspec.wavelength[gdwv] / (zlls+1)\\n energy = wv_rest.to(u.eV, equivalencies=u.spectral())\\n # Get photo_cross and calculate tau\\n tau0 = (10.**NHI[0] / u.cm**2) * ltaa.photo_cross(1, 1, energy)\\n\\n # Return\\n return spec, xspec, gdwv, NHI, tau0\",\n \"def calc_spectra(stream, data_type):\\n \\n import numpy as np\\n from mtspec import mtspec\\n from scipy import interpolate\\n from scipy.stats import binned_statistic \\n\\n # Read in file \\n tr = stream[0]\\n data = tr.data\\n delta = tr.stats.delta\\n samprate = tr.stats.sampling_rate\\n npts = tr.stats.npts\\n \\n # Determine nyquist frequency\\n nyquist = 0.5 * samprate\\n \\n\\n # Calc spectra amplitudes and frequencies \\n # Switched number of tapers from 7 to 5. Decreases computation time and\\n # results are similar\\n amp_squared, freq = mtspec(data, delta=delta, time_bandwidth=4, \\n number_of_tapers=5, nfft=npts, quadratic=True)\\n \\n # Convert from power spectra to amplitude spectra\\n amp = np.sqrt(amp_squared)\\n \\n # Use scipy interpolate function to fill in data in missing bins\\n f = interpolate.interp1d(freq, amp)\\n freq_new = np.arange(np.min(freq), np.max(freq), 0.0001)\\n amp_new = f(freq_new)\\n\\n # Remove certain frequencies that are too low or high. \\n indexes = []\\n \\n for i, val in enumerate(freq_new):\\n \\n # Remove frequencies below 1/2 length of record\\n if val <= 1/(delta*npts*0.5) :\\n indexes.append(i)\\n \\n # Remove frequencies above 10 Hz for sm data because of the way it was processed \\n elif val > 10 and data_type == 'sm':\\n indexes.append(i)\\n\\n # Remove frequencies above nyquist frequency for disp data\\n # (it's already removed in the previous step for sm data)\\n elif val > nyquist and data_type == 'disp': \\n indexes.append(i)\\n \\n # Remove any duplicate indexes\\n indexes = np.unique(indexes)\\n freq_new = np.delete(freq_new,indexes)\\n amp_new = np.delete(amp_new,indexes) \\n \\n # Set up bins\\n if data_type == 'sm':\\n # Starting bins at 0.004 Hz (that is about equal to half the length\\n # of the record for the synthetic and observed data) and ending at\\n # 10 Hz because after that the sm data is unusable due to how it was\\n # processed. \\n bins = np.logspace(np.log10(0.004), np.log10(10), num=21)\\n \\n elif data_type == 'disp':\\n # Starting bins at 0.004 Hz (that is about equal to half the length\\n # of the record for the synthetic and observed data) and ending at\\n # 0.5 Hz because that is the nyquist frequency .\\n bins = np.logspace(np.log10(0.004), np.log10(0.5), num=21)\\n \\n bin_means, bin_edges, binnumber = binned_statistic(freq_new,\\n amp_new,\\n statistic='mean',\\n bins=bins)\\n \\n # for i in range(len(bin_means)):\\n # bin_means[i] = 10**bin_means[i]\\n \\n \\n return(bin_means, freq, amp)\",\n \"def getLaps(self):\\n\\n if self.pj[OBSERVATIONS][self.observationId][\\\"type\\\"] in [LIVE]:\\n\\n if self.liveObservationStarted:\\n now = QTime()\\n now.start() # current time\\n memLaps = Decimal(str(round(self.liveStartTime.msecsTo(now) / 1000, 3)))\\n return memLaps\\n else:\\n return Decimal(\\\"0.0\\\")\\n\\n if self.pj[OBSERVATIONS][self.observationId][\\\"type\\\"] in [MEDIA]:\\n\\n if self.playerType == VIEWER:\\n return Decimal(0)\\n\\n if self.playerType == VLC:\\n if self.playMode == FFMPEG:\\n # cumulative time\\n memLaps = Decimal(self.FFmpegGlobalFrame * (1000 / list(self.fps.values())[0]) / 1000).quantize(\\n Decimal(\\\".001\\\"))\\n return memLaps\\n elif self.playMode == VLC:\\n # cumulative time\\n memLaps = Decimal(\\n str(round((sum(self.duration[0: self.media_list.index_of_item(self.mediaplayer.get_media())]) +\\n self.mediaplayer.get_time()) / 1000, 3)))\\n return memLaps\",\n \"def incandPeakInfoLG(self):\\r\\n\\t\\tself.incandBaseline_LG = (np.mean(self.lowGainWideBandIncandData[0:10]))\\r\\n\\t\\t\\t\\t\\r\\n\\t\\traw_incand_max_LG = np.amax(self.lowGainWideBandIncandData)\\r\\n\\t\\tincand_max_LG = raw_incand_max_LG - self.incandBaseline_LG\\t\\t\\r\\n\\t\\tincand_max_index_LG = np.argmax(self.lowGainWideBandIncandData)\\r\\n\\t\\t\\r\\n\\t\\tself.incandMax_LG =incand_max_LG\\r\\n\\t\\tself.incandMaxPos_LG = incand_max_index_LG\",\n \"def getFWHM(antenna, freq):\\n diameter = getDiameter(antenna)\\n lam = 299792458.0 / (freq * 1e9)\\n fwhmo = lam / math.pi * 180.0 * 60.0\\n fwhm = 1.22 * fwhmo / diameter\\n return fwhm\",\n \"def generate_wavelength_model(comp_lamp_path, night_path, plot_path):\\n\\n # read 1D comp lamp spectrum\\n spec = Table.read(comp_lamp_path)\\n\\n # read wavelength guess file\\n guess_path = path.abspath(path.join(night_path,\\n '..', 'wavelength_guess.csv'))\\n pix_wav = np.genfromtxt(guess_path, delimiter=',', names=True)\\n\\n # get emission line centroids at the guessed positions of the lines\\n pix_x0s = fit_all_lines(spec['pix'], spec['flux'], spec['ivar'],\\n pix_wav['wavelength'], pix_wav['pixel'])\\n\\n # only keep successful ones:\\n mask = np.isfinite(pix_x0s)\\n logger.debug(\\\"Successfully fit {}/{} comp. lamp lines\\\"\\n .format(mask.sum(), len(mask)))\\n pix_wav = pix_wav[mask]\\n pix_x0s = pix_x0s[mask]\\n\\n # --------------------------------------------------------------------------\\n # fit a gaussian process to determine the pixel-to-wavelength transformation\\n #\\n idx = np.argsort(pix_x0s)\\n med_x = np.median(pix_x0s[idx])\\n x = pix_x0s[idx] - med_x\\n y = pix_wav['wavelength'][idx]\\n\\n model = GPModel(x=x, y=y, n_bg_coef=n_bg_coef, x_shift=med_x)\\n\\n # Fit for the maximum likelihood parameters\\n bounds = model.gp.get_parameter_bounds()\\n init_params = model.gp.get_parameter_vector()\\n soln = minimize(model, init_params, method=\\\"L-BFGS-B\\\",\\n bounds=bounds)\\n model.gp.set_parameter_vector(soln.x)\\n logger.debug(\\\"Success: {}, Final log-likelihood: {}\\\".format(soln.success,\\n -soln.fun))\\n\\n # ---\\n # residuals to the mean model\\n x_grid = np.linspace(0, 1600, 1024) - med_x\\n mu, var = model.gp.predict(y, x_grid, return_var=True)\\n std = np.sqrt(var)\\n\\n _y_mean = model.mean_model.get_value(x)\\n _mu_mean = model.mean_model.get_value(x_grid)\\n\\n # Plot the maximum likelihood model\\n fig,ax = plt.subplots(1, 1, figsize=(8,8))\\n\\n # data\\n ax.scatter(x + med_x, y - _y_mean, marker='o')\\n\\n # full GP model\\n gp_color = \\\"#ff7f0e\\\"\\n ax.plot(x_grid+med_x, mu - _mu_mean, color=gp_color, marker='')\\n ax.fill_between(x_grid+med_x, mu+std-_mu_mean, mu-std-_mu_mean,\\n color=gp_color, alpha=0.3, edgecolor=\\\"none\\\")\\n\\n ax.set_xlabel('pixel')\\n ax.set_ylabel(r'wavelength [$\\\\AA$]')\\n ax.set_title(path.basename(comp_lamp_path))\\n\\n fig.tight_layout()\\n fig.savefig(path.join(plot_path, 'wavelength_mean_subtracted.png'), dpi=200)\\n # ---\\n\\n # ---\\n # residuals to full GP model\\n mu, var = model.gp.predict(y, x_grid, return_var=True)\\n std = np.sqrt(var)\\n\\n y_mu, var = model.gp.predict(y, x, return_var=True)\\n\\n # Plot the maximum likelihood model\\n fig,ax = plt.subplots(1, 1, figsize=(12,8))\\n\\n # data\\n ax.scatter(x + med_x, y - y_mu, marker='o')\\n\\n gp_color = \\\"#ff7f0e\\\"\\n ax.plot(x_grid+med_x, mu-mu, color=gp_color, marker='')\\n ax.fill_between(x_grid+med_x, std, -std, color=gp_color,\\n alpha=0.3, edgecolor=\\\"none\\\")\\n\\n ax.set_xlabel('pixel')\\n ax.set_ylabel(r'wavelength residual [$\\\\AA$]')\\n ax.set_title(path.basename(comp_lamp_path))\\n\\n ax.set_ylim(-1, 1)\\n ax.axvline(683., zorder=-10, color='#666666', alpha=0.5)\\n\\n ax2 = ax.twinx()\\n ax2.set_ylim([x/6563*300000 for x in ax.get_ylim()])\\n ax2.set_ylabel(r'velocity error at ${{\\\\rm H}}_\\\\alpha$ [{}]'\\n .format((u.km/u.s).to_string(format='latex_inline')))\\n\\n fig.tight_layout()\\n fig.savefig(path.join(plot_path, 'wavelength_residuals.png'), dpi=200)\\n # --------------------------------------------------------------------------\\n\\n return model\",\n \"def feedback_limit_khz(self):\\n return self._feedback_limit_khz\",\n \"def analyzeWAV(inputFile):\\n data, fs, nbits = audiolab.wavread(inputFile)\\n samplingRate = fs\\n return [data, samplingRate]\",\n \"def calc_peak_mags(model_table, filts=[\\\"u\\\",\\\"g\\\",\\\"r\\\",\\\"i\\\",\\\"z\\\",\\\"y\\\",\\\"J\\\",\\\"H\\\",\\\"K\\\"], magidxs=[0,1,2,3,4,5,6,7,8]):\\n\\n # Initiaize peak mag dictionarts\\n model_table_tts = {}\\n model_table_mags = {}\\n model_table_appmags = {}\\n for filt, magidx in zip(filts, magidxs):\\n model_table_tts[filt] = []\\n model_table_mags[filt] = []\\n model_table_appmags[filt] = []\\n\\n for row in model_table:\\n t, lbol, mag = row[\\\"t\\\"], row[\\\"lbol\\\"], row[\\\"mag\\\"]\\n for filt, magidx in zip(filts,magidxs):\\n idx = np.where(~np.isnan(mag[magidx]))[0]\\n if len(idx) == 0:\\n model_table_tts[filt].append(np.nan)\\n model_table_mags[filt].append(np.nan)\\n model_table_appmags[filt].append(np.nan)\\n else:\\n ii = np.argmin(mag[magidx][idx])\\n model_table_tts[filt].append(t[idx][ii])\\n model_table_mags[filt].append(mag[magidx][idx][ii])\\n model_table_appmags[filt].append(mag[magidx][idx][ii]+5*(np.log10(row[\\\"dist\\\"]*1e6) - 1))\\n\\n for filt, magidx in zip(filts, magidxs):\\n model_table[\\\"peak_tt_%s\\\"%filt] = model_table_tts[filt]\\n model_table[\\\"peak_mag_%s\\\"%filt] = model_table_mags[filt] \\n model_table[\\\"peak_appmag_%s\\\"%filt] = model_table_appmags[filt] \\n\\n return model_table\",\n \"def calculateMaxAmplitude(sampleWidth: int) -> int:\\n return 2 ** (sampleWidth * NUM_BITS_IN_A_BYTE - 1) - 1\",\n \"def wav2(bins, weis):\\n\\n mean = np.average(bins, weights=weis)\\n var = np.average((bins-mean)**2, weights=weis)\\n ##\\n sum1 = weis.sum()\\n sum2 = (weis**2).sum()\\n rms = np.sqrt(sum1*var/(sum1-sum2/sum1))\\n\\n return mean, rms\",\n \"def wavelength(self):\\n return wavelength(energy)\",\n \"def bands(self) -> int:\\n ...\",\n \"def set_UL_bw(self,oid, wavelength, pkt_size, timestamp):\\n try: \\n aux = self.wavelengths[wavelength]\\n except:\\n print \\\"CREATED WAVELENGTH %d\\\" %wavelength\\n self.create_wavelength(wavelength)\\n\\n sec_before = self.wavelengths[wavelength]['sec_UL_timestamp']\\n if self.env.now > (sec_before + 1):\\n #Then a second has passed. Time to flush counter\\n print \\\"MONITOR - passou 1 segundo - %f > %f\\\" % (self.env.now, sec_before)\\n print \\\"WAVELENGTH %d - SECOND BPS == %f\\\" % (wavelength,self.wavelengths[wavelength]['UL_bps'])\\n self.wavelengths[wavelength]['last_UL_bps'] = self.wavelengths[wavelength]['UL_bps']\\n self.wavelengths[wavelength]['UL_bps'] = 0\\n self.wavelengths[wavelength]['sec_UL_timestamp'] = self.env.now\\n \\n self.wavelengths[wavelength]['UL_bps']+=pkt_size\\n self.wavelengths[wavelength]['last_UL_timestamp'] = self.env.now\\n\\n self.bandwidth_UL_file.write(\\\"{},{},{},{}\\\\n\\\".format(wavelength,oid,pkt_size,timestamp))\",\n \"def peak_height(self):\\n return np.array([max(self.waveform[ch]) for ch in range(self.nchannels)])\",\n \"def find_closest_peaks(power, freqs, guess_freqs):\\n # find the maxima in the power spectrum\\n maxima = sig.argrelextrema(power, np.greater)\\n\\n maxima_freqs = np.zeros(freqs.shape)\\n maxima_freqs[maxima] = freqs[maxima]\\n\\n # determine the peaks as the closest maxima to\\n # each of the standing wave frequencies\\n peak_indices = [find_nearest_idx(maxima_freqs, f) for f in guess_freqs]\\n return peak_indices\",\n \"def compute_melmat(self, num_mel_bands=12, freq_min=64, freq_max=8000,\\n num_fft_bands=513, sample_rate=16000):\\n center_frequencies_mel, lower_edges_mel, upper_edges_mel = self.melfrequencies_mel_filterbank(\\n num_mel_bands,\\n freq_min,\\n freq_max,\\n num_fft_bands\\n )\\n\\n center_frequencies_hz = self.mel_to_hertz(center_frequencies_mel)\\n lower_edges_hz = self.mel_to_hertz(lower_edges_mel)\\n upper_edges_hz = self.mel_to_hertz(upper_edges_mel)\\n freqs = linspace(0.0, sample_rate / 2.0, num_fft_bands)\\n melmat = zeros((num_mel_bands, num_fft_bands))\\n\\n for imelband, (center, lower, upper) in enumerate(zip(\\n center_frequencies_hz, lower_edges_hz, upper_edges_hz)):\\n\\n left_slope = (freqs >= lower) == (freqs <= center)\\n melmat[imelband, left_slope] = (\\n (freqs[left_slope] - lower) / (center - lower)\\n )\\n\\n right_slope = (freqs >= center) == (freqs <= upper)\\n melmat[imelband, right_slope] = (\\n (upper - freqs[right_slope]) / (upper - center)\\n )\\n return melmat, (center_frequencies_mel, freqs)\",\n \"def print_peak_data_short(sp) : \\n print('%d %4d %s %s %.6f %.6f %.6f %d %.6f %.6f %.6f %.6f %.6f %d %.6f %.6f %.6f %.6f %d %d' % \\\\\\n (sp.frameNumber, sp.runnum, sp.tstamp, sp.s_fid,\\\\\\n sp.photonEnergyEv, sp.wavelengthA,\\\\\\n sp.GMD, sp.peak_index, sp.peak_x_raw, sp.peak_y_raw,\\\\\\n sp.peak_r_assembled, sp.peak_q, sp.peak_resA, sp.nPixels,\\\\\\n sp.totalIntensity, sp.maxIntensity, sp.sigmaBG, sp.SNR,\\\\\\n sp.tsec, sp.fid))\",\n \"def summary(self) -> None:\\n if not self._custom_wave:\\n print(\\n f\\\"{self.name}\\\\n\\\"\\n + f\\\"{self.start_wavelength} < lambda (A) < {self.end_wavelength}\\\\n\\\"\\n + f\\\"R = {self.R_res}\\\\n\\\"\\n + f\\\"Sampling = {self.R_samp} pix/FWHM\\\"\\n )\\n else:\\n print(\\n f\\\"{self.name}\\\\n\\\"\\n + f\\\"Custom Wavelength w/\\\\n\\\"\\n + f\\\"({self.wave[0]} < lambda (A) < {self.wave[-1]})\\\\n\\\"\\n + f\\\"R = {self.R_res}\\\\n\\\"\\n )\",\n \"def getPulseWave(ham: Dict[str, Any], names: Union[str, List[str]]) -> Dict[str, Any]:\\n if isinstance(names, str):\\n return ham[\\\"control\\\"][names][\\\"waveforms\\\"]\\n else:\\n waves = {}\\n for name in names:\\n wave = ham[\\\"control\\\"][names][\\\"waveforms\\\"]\\n waves[name] = wave\\n return waves\",\n \"def spectrl2_data():\\n # reference spectra generated with solar_utils==0.3\\n kwargs = {\\n 'surface_tilt': 0,\\n 'relative_airmass': 1.4899535986910446,\\n 'apparent_zenith': 47.912086486816406,\\n 'aoi': 47.91208648681641,\\n 'ground_albedo': 0.2,\\n 'surface_pressure': 101300,\\n 'ozone': 0.344,\\n 'precipitable_water': 1.42,\\n 'aerosol_turbidity_500nm': 0.1,\\n 'dayofyear': 75\\n }\\n df = pd.read_csv(SPECTRL2_TEST_DATA)\\n # convert um to nm\\n df['wavelength'] *= 1000\\n df[['specdif', 'specdir', 'specetr', 'specglo']] /= 1000\\n return kwargs, df\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.601255","0.5668921","0.56192625","0.5610423","0.5600852","0.5598455","0.5598455","0.55850786","0.5564336","0.548778","0.5483454","0.5475823","0.5408421","0.5390249","0.5387245","0.5372645","0.5349552","0.53355616","0.5279677","0.52596873","0.52552986","0.5217675","0.52144605","0.52040637","0.5181064","0.51708907","0.51708907","0.51580054","0.514653","0.5144115","0.5139606","0.51381683","0.5129357","0.5114717","0.5086487","0.5074106","0.5042364","0.5031146","0.50227374","0.5020617","0.50032175","0.49973643","0.49889693","0.49886876","0.4988498","0.49798176","0.49779996","0.4973593","0.49456114","0.49450976","0.49417093","0.49381495","0.49357712","0.49347818","0.49332398","0.49089172","0.49023372","0.48994547","0.4894091","0.4886402","0.4886041","0.4884332","0.48838493","0.48824218","0.4864153","0.48567495","0.48510647","0.48498186","0.4818446","0.48145697","0.48098695","0.47975093","0.4795789","0.47957078","0.47934464","0.47907174","0.47889003","0.4788886","0.478436","0.47789124","0.47751454","0.4773597","0.47667113","0.47666118","0.47633967","0.4762433","0.47557527","0.47526202","0.4752287","0.47504812","0.4742352","0.47412047","0.4736197","0.47306308","0.47293243","0.47226912","0.47214794","0.4717961","0.4716695","0.4714691"],"string":"[\n \"0.601255\",\n \"0.5668921\",\n \"0.56192625\",\n \"0.5610423\",\n \"0.5600852\",\n \"0.5598455\",\n \"0.5598455\",\n \"0.55850786\",\n \"0.5564336\",\n \"0.548778\",\n \"0.5483454\",\n \"0.5475823\",\n \"0.5408421\",\n \"0.5390249\",\n \"0.5387245\",\n \"0.5372645\",\n \"0.5349552\",\n \"0.53355616\",\n \"0.5279677\",\n \"0.52596873\",\n \"0.52552986\",\n \"0.5217675\",\n \"0.52144605\",\n \"0.52040637\",\n \"0.5181064\",\n \"0.51708907\",\n \"0.51708907\",\n \"0.51580054\",\n \"0.514653\",\n \"0.5144115\",\n \"0.5139606\",\n \"0.51381683\",\n \"0.5129357\",\n \"0.5114717\",\n \"0.5086487\",\n \"0.5074106\",\n \"0.5042364\",\n \"0.5031146\",\n \"0.50227374\",\n \"0.5020617\",\n \"0.50032175\",\n \"0.49973643\",\n \"0.49889693\",\n \"0.49886876\",\n \"0.4988498\",\n \"0.49798176\",\n \"0.49779996\",\n \"0.4973593\",\n \"0.49456114\",\n \"0.49450976\",\n \"0.49417093\",\n \"0.49381495\",\n \"0.49357712\",\n \"0.49347818\",\n \"0.49332398\",\n \"0.49089172\",\n \"0.49023372\",\n \"0.48994547\",\n \"0.4894091\",\n \"0.4886402\",\n \"0.4886041\",\n \"0.4884332\",\n \"0.48838493\",\n \"0.48824218\",\n \"0.4864153\",\n \"0.48567495\",\n \"0.48510647\",\n \"0.48498186\",\n \"0.4818446\",\n \"0.48145697\",\n \"0.48098695\",\n \"0.47975093\",\n \"0.4795789\",\n \"0.47957078\",\n \"0.47934464\",\n \"0.47907174\",\n \"0.47889003\",\n \"0.4788886\",\n \"0.478436\",\n \"0.47789124\",\n \"0.47751454\",\n \"0.4773597\",\n \"0.47667113\",\n \"0.47666118\",\n \"0.47633967\",\n \"0.4762433\",\n \"0.47557527\",\n \"0.47526202\",\n \"0.4752287\",\n \"0.47504812\",\n \"0.4742352\",\n \"0.47412047\",\n \"0.4736197\",\n \"0.47306308\",\n \"0.47293243\",\n \"0.47226912\",\n \"0.47214794\",\n \"0.4717961\",\n \"0.4716695\",\n \"0.4714691\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54686236"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":81599,"cells":{"query":{"kind":"string","value":"Set a number of lamp parameters at once using keyword arguments, e.g. spectra.lamps(red_enabled=True, red_intensity=255, blue_enabled=False) Intensity values must be in the range [0, 255]. Valid lamp names can be retrieved with get_lamp_specs()."},"document":{"kind":"string","value":"def lamps(self, **lamp_parameters):\n self._set_state(lamp_parameters.items())"},"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 setParameters(self, lam=45, **ukwargs):\n\t\tEvolutionStrategy1p1.setParameters(self, **ukwargs)\n\t\tself.lam = lam\n\t\tif ukwargs: logger.info('Unused arguments: %s' % (ukwargs))","def setLSLimits(*args):\n args[0].Limit.LSLimit.ls_limit = args[1]","def setLCLimits(*args):\n args[0].Limit.LCLimit.lc_limit = args[1]","def all_lamps_slow():\n HOUSE = pre_process.get_house()\n\n for id_num, lamp in HOUSE.lamps.items():\n lamp.turn_on()\n lamp.set_transition_time(500)\n lamp.set_brigthness(254)\n lamp.send_command()","def get_lamp_parameters(p, header, filename=None, kind=None):\n\n func_name = __NAME__ + '.get_lamp_parameters()'\n # get relevant (cass/ref) fiber position (for lamp identification)\n gkwargs = dict(return_value=True, dtype=str)\n if p['FIBER'] == 'C':\n p['FIB_POS'] = spirouImage.ReadParam(p, header, 'kw_CREF', **gkwargs)\n p['FIB_POS_ID'] = p['kw_CREF'][0]\n elif p['FIBER'] in ['AB', 'A', 'B']:\n p['FIB_POS'] = spirouImage.ReadParam(p, header, 'kw_CCAS', **gkwargs)\n p['FIB_POS_ID'] = p['kw_CCAS'][0]\n else:\n emsg1 = ('Fiber position cannot be identified for fiber={0}'\n .format(p['FIB_TYP']))\n emsg2 = ' function={0}'.format(__NAME__)\n WLOG(p, 'error', [emsg1, emsg2])\n # set the source of fib_pos\n p.set_sources(['FIB_POS', 'FIB_POS_ID'], func_name)\n\n # identify lamp\n if kind is not None:\n lamp = kind\n elif filename is not None:\n lamp = decide_on_lamp_type(p, filename=filename)\n else:\n lamp = decide_on_lamp_type(p, filename=p['ARG_FILE_NAMES'][0])\n\n # -------------------------------------------------------------------------\n # Now set parameters in p based on lamp type\n\n # the lamp type\n p['LAMP_TYPE'] = lamp\n p.set_source('LAMP_TYPE', func_name)\n # the lamp file\n p['IC_LL_LINE_FILE'] = p['IC_LL_LINE_FILE_ALL'][lamp]\n p.set_source('IC_LL_LINE_FILE', func_name)\n # the lamp cat type\n p['IC_CAT_TYPE'] = p['IC_CAT_TYPE_ALL'][lamp]\n p.set_source('IC_CAT_TYPE', func_name)\n # -------------------------------------------------------------------------\n # finally return p\n return p","def lmp(self, lmp):\n\n self.logger.debug(\"In 'lmp' setter.\")\n\n self._lmp = lmp","def lra_parameters(**kwargs):\n pars = {'d1' : 0.1,\n 'd2' : 2.1,\n 'd3' : 0.9967,\n 'd5' : 0.2,\n 'a2' : 0.4,\n 'c1' : 0.4,\n 'c0' : 4,\n 'rc' : 7,\n 'rl' : 0.05,\n 'ver' : 0.9,\n 'Ker' : 0.1,\n 'ip3' : 0.1,\n 'noise' : False,\n 'ICs' : [0.05,0.99]\n }\n\n ## User-defined parameters\n pars = gu.varargin(pars,**kwargs)\n # Parameters must be floats\n for k,item in pars.iteritems():\n if isscalar(item):\n pars[k] = float(item)\n elif isinstance(item, bool):\n pars[k] = np.intc(item)\n else:\n pars[k] = array(item,dtype=float)\n return pars","def __init__(self, lam=1.0):\n self.lam = lam\n\n # these are set in fit\n self.b = None # float\n self.w = None # (nvars, ) array","def configure_global_lldp_parameters(self, **kwargs):\n pass","def set_lam_nll(self, lam_nll=1.0):\n zero_ary = np.zeros((1,))\n new_lam = zero_ary + lam_nll\n self.lam_nll.set_value(to_fX(new_lam))\n return","def setLinearAirDamping(*argv):","def _iotool_lamp_commands(self, **lamps):\n commands = []\n for lamp, enabled in lamps.items():\n if enabled is None:\n continue\n pin = self._spconfig.IOTOOL_LAMP_PINS[lamp]\n if enabled:\n commands.append(self._iotool.commands.set_high(pin))\n else:\n commands.append(self._iotool.commands.set_low(pin))\n return commands","def __init__(self, lms, temp=1.0, alphas=[0.7, 0.2, 0.1]):\r\n super().__init__(lms[0], temp)\r\n self.lms = lms\r\n self.alphas = alphas\r\n assert (abs(sum(alphas) - 1) < 0.0000001)","def set_lims(self):\n xx_min, xx_max = self.set_period_limits()\n y_min = self.tf.rho.min()\n y_min = max(y_min, 1e-20)\n y_max = self.tf.rho.max()\n y_max = max(y_max, 1e-20)\n\n yy_min = 10 ** (np.floor(np.log10(y_min)))\n if (np.log10(y_min) - np.log10(yy_min)) < 0.15:\n yy_min = 10 ** (np.log10(yy_min) - 0.3)\n\n yy_max = 10 ** (np.ceil(np.log10(y_max)))\n if (np.log10(yy_max) - np.log10(y_max)) < 0.15:\n yy_max = 10 ** (np.log10(yy_max) + 0.3)\n\n if abs(yy_max - yy_min) > 1:\n lims = [xx_min, xx_max, yy_min, yy_max, 0, 90]\n else:\n lims = [xx_min, xx_max, 0.01, 1e4, 0, 90]\n\n orient = 0.0\n return lims, orient","def lammps(parameter, iteration, numberlist, density, chainlength):\n # input parameters\n var = parameter[0]\n x = var * numberlist[0]\n y = var * numberlist[1] * 1.732 / 2\n z = x / 2\n #nodeid = 55 + iteration % 5\n M = int((x * y * z * density - 4 * numberlist[0] * numberlist[1] * int(z / 0.3)) / chainlength) \n os.environ['var'] = str(var)\n os.environ['iteration'] = str(iteration)\n os.environ['M'] = str(M)\n #os.environ['nodeid'] = str(nodeid)\n # copy the files to modify\n os.system(\"cp in.asymmetric in.asymmetric_$iteration\")\n os.system(\"cp run_lammps.sh run_lammps_$iteration.sh\")\n os.system(\"cp MultiBCP_hexagonal_post.py MultiBCP_hexagonal_post_$iteration.py\")\n # modify relevant files\n os.system('sed -i -e \"s/distance = 12/distance = $var/\" MultiBCP_hexagonal_post_$iteration.py')\n os.system(\"python MultiBCP_hexagonal_post_$iteration.py\")\n time.sleep(3)\n os.system('sed -i -e \"s/3072/$M/\" in.asymmetric_$iteration')#modify according to the parameters\n os.system('sed -i -e \"s/XN_100/XN_100_$iteration/\" in.asymmetric_$iteration')\n os.system('sed -i -e \"s/finalasymmetric/finalasymmetric_$iteration/\" in.asymmetric_$iteration')\n os.system('sed -i -e \"s/POSTA2B8/POSTA2B8_$iteration/\" run_lammps_$iteration.sh')\n os.system('sed -i -e \"s/posta2b8.out/posta2b8_$iteration.out/\" run_lammps_$iteration.sh')\n #os.system('sed -i -e \"s/node55/node$nodeid/\" run_lammps_$iteration.sh')\n os.system('sed -i -e \"s/in.asymmetric/in.asymmetric_$iteration/\" run_lammps_$iteration.sh')\n # run the simulation\n os.system(\"sbatch run_lammps_$iteration.sh\")\n return None","def __init__(self,\n L=1,\n steer_max=0.45 * pi,\n **kwargs\n ):\n super().__init__(**kwargs)\n\n self._l = L\n self._steer_max = steer_max","def setLSData(*args):\n args[0].Data.LSData.lc_data = args[1]","def set_parameters(self, L, r):\n self.L = L\n self.r = r","def setParams(self,dim=20, nIter=5, lamb=0.05, alph=40):\n self._dim = dim\n self._nIter = nIter\n self._lamb = lamb\n self._alph = alph","def set_lam_kld(self, lam_kld_z=1.0, lam_kld_q2p=1.0, lam_kld_p2q=1.0):\n zero_ary = np.zeros((1,))\n new_lam = zero_ary + lam_kld_z\n self.lam_kld_z.set_value(to_fX(new_lam))\n new_lam = zero_ary + lam_kld_q2p\n self.lam_kld_q2p.set_value(to_fX(new_lam))\n new_lam = zero_ary + lam_kld_p2q\n self.lam_kld_p2q.set_value(to_fX(new_lam))\n return","def __init__(\n self,\n nb_samples: int,\n clip_values: Tuple[float, float],\n lam: Union[float, Tuple[float, float]],\n apply_fit: bool = False,\n apply_predict: bool = True,\n ) -> None:\n super().__init__(\n apply_fit=apply_fit, apply_predict=apply_predict, nb_samples=nb_samples, clip_values=clip_values\n )\n\n self.lam = lam\n self.lam_range = (0.0, lam) if isinstance(lam, (int, float)) else lam\n self._check_params()","def lsits(self, lsits: List[LsitsParam]):\n\n self._lsits = lsits","def initiate_lmp(self, cs_springs):\n lmp = lammps()\n \n lmp.command('units metal')\n lmp.command('atom_style full')\n \n large_tilt = self._check_large_tilt()\n if large_tilt:\n lmp.command('box tilt large')\n\n lmp.command('read_data {}'.format(self.file_name))\n \n lmp.command('group cores type {}'.format(self.type_core()))\n if len(self.bond_types) != 0:\n lmp.command('group shells type {}'.format(self.type_shell()))\n\n if cs_springs:\n lmp.command('pair_style buck/coul/long/cs 10.0')\n lmp.command('pair_coeff * * 0 1 0')\n\n lmp.command('bond_style harmonic') \n for bond in self.bond_types:\n lmp.command(bond.bond_string())\n else:\n lmp.command('pair_style buck/coul/long 10.0')\n lmp.command('pair_coeff * * 0 1 0')\n\n lmp.command('kspace_style ewald 1e-6')\n\n #setup for minimization\n lmp.command('min_style cg')\n return lmp","def _set_train_params(self,\n lr: float = 1e-3,\n l2norm: float = 1e-2,\n ):\n self.lr = lr\n self.l2norm = l2norm\n self.optimizer = torch.optim.Adam(\n self.model.parameters(), lr=lr, weight_decay=l2norm)","def _set_learning_rates(\n self, lr_a=None, lr_alpha=None, lr_l=None, lr_labda=None, lr_c=None\n ):\n if lr_a:\n self._a_train.lr.assign(lr_a)\n if lr_alpha:\n self._alpha_train.lr.assign(lr_alpha)\n if self.use_lyapunov:\n if lr_l:\n self._l_train.lr.assign(lr_l)\n if lr_labda:\n self._lambda_train.lr.assign(lr_labda)\n else:\n if lr_c:\n self._q_train.lr.assign(lr_c)","def lammps(step, atomnum, boxbounds, addson = ''):\r\n\r\n line = 'ITEM: TIMESTEP\\n'\r\n line += str(step) + '\\n'\r\n\r\n line += 'ITEM: NUMBER OF ATOMS\\n'\r\n line += str(atomnum) + '\\n'\r\n\r\n line += 'ITEM: BOX BOUNDS pp pp pp\\n'\r\n line += '%.6f %.6f\\n' %(boxbounds[0, 0], boxbounds[0, 1])\r\n line += '%.6f %.6f\\n' %(boxbounds[1, 0], boxbounds[1, 1])\r\n if boxbounds.shape[0] == 3:\r\n line += '%.6f %.6f\\n' %(boxbounds[2, 0], boxbounds[2, 1])\r\n else:\r\n line += '%.6f %.6f\\n' %(-0.5, 0.5)\r\n\r\n line += 'ITEM: ATOMS id type x y z %s\\n' %addson\r\n\r\n return line","def set_L(self, xlambda, Lcap=False):\n if (Lcap):\n xlambda /= self.get_N() - 1.\n self.set_par('XLAMBDA_0', float(xlambda))","def default_parameters():\n prm = Parameters('lvad_model')\n\n prm.add('lvad_volume', 66.0)\n\n prm.add('alpha_slope', 0.0091)\n prm.add('alpha_intercept', 1.4)\n\n prm.add('beta_slope', -0.19)\n prm.add('beta_intercept', -1.9)\n\n prm.add('frequency', float())\n\n return prm","def setLeds(number: int, red: int, green: int, blue: int):\n pass","def init_lp(data, **kwargs):\r\n d = []\r\n CL = []; CT = []\r\n rhoL = []; rhoT = []\r\n alphaL = []; alphaT = []\r\n omega = kwargs.get('omega', 0)\r\n # layers\r\n for layer in data['layers'].values():\r\n d.append(layer[1])\r\n mat_name = layer[0]\r\n if mat_name=='meta':\r\n metaparam = layer[2:]\r\n prop = mat.properties(mat_name, omega/2/np.pi, *metaparam)\r\n # prop = [u[0] for u in prop] # avoid array (1,)\r\n else:\r\n prop = mat.properties(mat_name, omega/2/np.pi)\r\n # prop = [ u[0] for u in prop if u!=[] ] # avoid array (1,)\r\n if prop==[]:\r\n return\r\n CL.append(prop[0])\r\n CT.append(prop[1])\r\n rhoL.append(prop[2])\r\n rhoT.append(prop[3])\r\n alphaL.append(prop[4])\r\n alphaT.append(prop[5])\r\n lp = (d, CL, CT, rhoL, rhoT, alphaL, alphaT)\r\n mat_name = data['halfspace_left']\r\n prop = mat.properties(mat_name, omega/2/np.pi)\r\n # prop = [u[0] for u in prop] # avoid array (1,)\r\n [ lp[i+1].insert(0, prop[i]) for i in range(6) ]\r\n mat_name = data['halfspace_right']\r\n prop = mat.properties(mat_name, omega/2/np.pi)\r\n # prop = [u[0] for u in prop] # avoid array (1,)\r\n [ lp[i+1].append(prop[i]) for i in range(6) ]\r\n return lp","def _add_lamp_outlets(self):\r\n lst = self.model.get_all_lamp_outlets()\r\n\r\n for itm in lst:\r\n self._add_lamp_outlet(itm)","def join_lens_with_light_loose(kwargs_lens,kwargs_lens_light,prior_list):\n \n logL = 0\n \n if not kwargs_lens: \n pass\n elif not kwargs_lens_light:\n pass\n else:\n for i in range(len(prior_list)):\n light_index, lens_index, param, sigma = prior_list[i]\n \n model_val = kwargs_lens[lens_index][param] \n mean_val = kwargs_lens_light[light_index][param]\n \n dist = (model_val - mean_val)**2 / sigma ** 2 / 2\n logL -= np.sum(dist)\n \n# print('prior: {}_lens \\n lens_val: {} \\n light value: {} \\n sigma: {}'.format(param,model_val,mean_val,sigma))\n \n return logL","def setParameters(self, A_l=0.9, A_u=1.0, r_l=0.001, r_u=0.1, tao_1=0.1, tao_2=0.1, **ukwargs):\n\t\tAdaptiveBatAlgorithm.setParameters(self, **ukwargs)\n\t\tself.A_l, self.A_u, self.r_l, self.r_u, self.tao_1, self.tao_2 = A_l, A_u, r_l, r_u, tao_1, tao_2","def __init__(self, *args, **kwargs):\n super(LinlLis, self).__init__(\n ('linl', Bits(maxlen=4)),\n ('lis', Bits(maxlen=4)),\n *args, **kwargs\n )","def set_params(self, **kwargs):\n\n kw_keys = list(kwargs)\n\n if 'alpha' in kw_keys:\n self.alpha = kwargs['alpha']\n\n if 'beta' in kw_keys:\n self.beta = kwargs['beta']\n\n if 'gamma' in kw_keys: \n \tself.gamma = kwargs['gamma']\n\n if 'epsilon' in kw_keys:\n self.epsilon = kwargs['epsilon']\n \n self.nact = self.highbound-self.lowbound\n self.actions = np.arange(self.nact)","def setLaserPower(self,wavelength, power, job, seq=1):\n self.emptyCMDlist()\n\n c = \"/cli:python /app:matrix /sys:1 /cmd:adjustls /seq:\" + str(seq) + \" /exp:\" + job\n if int(wavelength) == 405:\n c += \" /lsq:uv /lid:405\"\n else:\n c += \" /lsq:vis /lid:\" + str(wavelength)\n c+= \" /tar:laser /value:\" + str(float(power))\n self.addtoCMDlist(c)\n self.sendCMDlist()","def __init__(self, l_smooth = LS):\n self.l_smooth = l_smooth","def __call__(self, lam=1.0, size=None, **kwargs):\n return super().__call__(lam, size=size, **kwargs)","def amps(self, amp: NumType):\n self._amp = amp","def mle_parameters(self, start=None, random_seed=None):\n\n if random_seed is not None:\n np.random.seed(random_seed)\n\n if start is None:\n start = self.sample_parameters_posterior(1)[0, :]\n\n bounds = self.get_bounds_parameters\n\n objective_function = self.objective_llh\n grad_function = self.grad_llh\n\n optimization = Optimization(\n LBFGS_NAME,\n objective_function,\n bounds,\n grad_function,\n minimize=False)\n\n return optimization.optimize(start)","def set_lam_l2w(self, lam_l2w=1e-3):\n zero_ary = np.zeros((1,))\n new_lam = zero_ary + lam_l2w\n self.lam_l2w.set_value(to_fX(new_lam))\n return","def setLightingOptions(lightID, val, otype):\n odict = {'ambient':'AMBIENT','diffuse':'DIFFUSE','specular':'SPECULAR',\n 'constant':'CONSTANT','linear':'LINEAR','quadratic':'QUADRATIC'}\n dislin.litopt(lightID, val, odict[otype])","def setHsla ( self, h, s = 0.0, l = 0.0, a = 1.0 ):\n #self.reset()\n\n # Check if argument is list\n if isinstance(h, list):\n s = h[1]\n l = h[2]\n if len(h) == 4: # Alpha in the list\n a = h[3]\n h = h[0]\n\n # If any component is int ( 0 - 255 ) convert to float ( 0 - 1)\n hsla = [ h, s, l, a ]\n for i in range(len(hsla)):\n if isinstance( hsla[i], int ):\n hsla[i] = hsla[i] / 360.0 if i == 0 else hsla[i] / 100.0\n\n self.h = hsla[0]\n self.s = hsla[1]\n self.l = hsla[2]\n self.a = hsla[3]\n self.hsl = [ hsla[0], hsla[1], hsla[2] ]\n self.hsla = [ hsla[0], hsla[1], hsla[2], hsla[3] ]\n\n self.updateFromHsl()","def set_parameters(self,params):\n K3Supervisor.set_parameters(self,params)\n self.blending.set_parameters(self.parameters)","def setLum ( self, newlum ):\n if isinstance( newlum, int ):\n newlum /= 100\n if newlum > 1.0:\n newlum = 1.0\n if newlum < 0.0:\n newlum = 0.0\n self.l = newlum\n self.hsl[2] = newlum\n self.hsla[2] = newlum\n self.updateFromHsl()","def ISM_lums(line,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n GR = glo.global_results()\n\n L_tot = getattr(GR,'L_%s_sun' % line)\n L_H2 = getattr(GR,'L_%s_H2_sun' % line)\n L_HI = getattr(GR,'L_%s_HI_sun' % line)\n L_HII = getattr(GR,'L_%s_HII_sun' % line)\n fig, ax = plt.subplots(figsize=(8, 6 ),facecolor='w')\n x=ax.hist(np.log10(L_tot[L_tot > 0]),bins=100,alpha=0.6,label='tot',color='grey')\n x=ax.hist(np.log10(L_H2[L_H2 > 0]),bins=100,alpha=0.6,label='H2',color='r')\n x=ax.hist(np.log10(L_HI[L_HI > 0]),bins=100,alpha=0.8,label='HI',color='orange')\n x=ax.hist(np.log10(L_HII[L_HII > 0]),bins=100,alpha=0.5,label='HII',color='b')\n ax.set_xlabel(getlabel('l'+line))\n ax.set_ylabel('Number of galaxies')\n plt.legend()\n if p.savefig:\n plt.savefig(p.d_plot + 'luminosity/ISM_lums_%s.png' % line)","def param_init_lstm(options, params, prefix='lstm'):\n W = numpy.concatenate([ortho_weight(options['dim_proj']),\n ortho_weight(options['dim_proj']),\n ortho_weight(options['dim_proj']),\n ortho_weight(options['dim_proj'])], axis=1)\n params[_p(prefix, 'W')] = W\n U = numpy.concatenate([ortho_weight(options['dim_proj']),\n ortho_weight(options['dim_proj']),\n ortho_weight(options['dim_proj']),\n ortho_weight(options['dim_proj'])], axis=1)\n params[_p(prefix, 'U')] = U\n b = numpy.zeros((4 * options['dim_proj'],))\n params[_p(prefix, 'b')] = b.astype(config.floatX)\n\n return params","def modify_lvars(self, *args):\n return _ida_hexrays.user_lvar_modifier_t_modify_lvars(self, *args)","def __init__(self, maxsteps=None, lrate=None, eps=None, verbose=None):\r\n\r\n self.maxsteps= maxsteps\r\n self.lrate = lrate\r\n self.nochange= eps\r\n\tself.verbose = verbose","def _set_leg_params(self):\n self.p = 0.01600\n self.q = 0.00000\n self.r = 0.02000\n self.c = 0.01811\n self.u = 0.00000\n self.v = 0.00000\n self.e = -0.06000\n self.h = -0.02820\n self.s = 0.02200\n self.d1 = 0.0\n self.d2 = 0.0\n self.d3 = 0.0\n self.stability = 0.0","def lr_setter(optimizer, epoch, args, bl=False):\n\n lr = args.lr\n if bl:\n lr = args.lrbl * (0.1 ** (epoch // (args.epochb * 0.5)))\n else:\n if args.cos:\n lr *= ((0.01 + math.cos(0.5 * (math.pi * epoch / args.epochs))) / 1.01)\n else:\n if epoch >= args.epochs_decay[0]:\n lr *= 0.1\n if epoch >= args.epochs_decay[1]:\n lr *= 0.1\n for param_group in optimizer.param_groups:\n param_group['lr'] = lr","def get_lamp_specs(self):\n return {lamp: self._LAMP_SPECS[lamp] for lamp in self._available_lamps}","def _define_SLACS_fit_params(self):\n\t\t# Fit params from R_eff\n\t\tself.a = -0.41\n\t\tself.b = 0.39\n\t\t#self.delta_a = 0.12\n\t\t#self.delta_b = 0.10\n\t\tself.intrinsic_scatter = 0.14\n\t\t# Fit params from vel_disp\n\t\tself.a_v = 0.07\n\t\tself.b_v = -0.12\n\t\tself.int_v = 0.17","def lammps_parameter_alloy(self, alloy, i=1, j=2):\n\n if not isinstance(i, int) or i <= 0:\n raise TypeError('i must be an integer > 0')\n if not isinstance(j, int) or j <= i:\n raise TypeError('j must be an integer > i')\n\n contents = f\"zbl({i},{j}) = 0\\n\"\n contents += f\"nn2({i},{j}) = 1\\n\"\n contents += f\"Ec({i},{j}) = {alloy.Ec:.8g}\\n\"\n contents += f\"re({i},{j}) = {alloy.Re:.8g}\\n\"\n contents += f\"alpha({i},{j}) = {alloy.alpha:.15g}\\n\"\n contents += f\"attrac({i},{j}) = {alloy['d+']:.6g}\\n\"\n contents += f\"repuls({i},{j}) = {alloy['d-']:.6g}\\n\"\n\n contents += f\"Cmin({i},{i},{j}) = {alloy.Cmin_iji:.15g}\\n\"\n contents += f\"Cmin({j},{j},{i}) = {alloy.Cmin_jij:.15g}\\n\"\n contents += f\"Cmin({i},{j},{i}) = {alloy.Cmin_iij:.15g}\\n\"\n contents += f\"Cmin({i},{j},{j}) = {alloy.Cmin_ijj:.15g}\\n\"\n contents += f\"Cmin({j},{i},{i}) = {alloy.Cmin_iij:.15g}\\n\"\n contents += f\"Cmin({j},{i},{j}) = {alloy.Cmin_ijj:.15g}\\n\"\n\n contents += f\"Cmax({i},{i},{j}) = {alloy.Cmax_iji:.15g}\\n\"\n contents += f\"Cmax({j},{j},{i}) = {alloy.Cmax_jij:.15g}\\n\"\n contents += f\"Cmax({i},{j},{i}) = {alloy.Cmax_iij:.15g}\\n\"\n contents += f\"Cmax({i},{j},{j}) = {alloy.Cmax_ijj:.15g}\\n\"\n contents += f\"Cmax({j},{i},{i}) = {alloy.Cmax_iij:.15g}\\n\"\n contents += f\"Cmax({j},{i},{j}) = {alloy.Cmax_ijj:.15g}\\n\"\n\n contents += f\"lattce({i},{j}) = '{alloy.lat}'\\n\"\n\n return contents","def lj(string):\n\n\tljparams = dict({\n\t\t\t\t\t'lat0' : 5.269,\t\t# Lattice constant for argon at 0 K in angstroms\n\t\t\t\t\t'lat20' : 5.315,\t# Lattice constant for argon at 20 K in angstroms\n\t\t\t\t\t'lat35' : 5.355,\t# Lattice constant for argon at 35 K in angstroms\n\t\t\t\t\t'lat50' : 5.401,\t# Lattice constant for argon at 50 K in angstroms\n\t\t\t\t\t'lat65' : 5.455,\t# Lattice constant for argon at 65 K in angstroms\n\t\t\t\t\t'lat80' : 5.527,\t# Lattice constant for argon at 80 K in angstroms\n\t\t\t\t\t'epsilon' : 1.67e-21,\t# Epsilon constant for argon in joules\n\t\t\t\t\t'sigma' : 3.40e-10,\t# Sigma constant for argon in meters\n\t\t\t\t\t'mass' : 6.63e-26,\t# Mass constant for argon in kilograms\n\t\t\t\t\t'tau' : 2.14e-12\t# Tau constant for argon in seconds\n\t\t\t\t\t})\t\n\n\ttry:\n\t\treturn ljparams[string]\n\texcept KeyError, e:\n\t\tprint \"KeyError: %s is not a valid key for ntpy.param.lj().\" % e\n\t\traise","def push_state(self, **lamp_parameters):\n # Also note that we do not filter out identical states from being pushed.\n # Since the enabled state can be fiddled with IOTool, there is good reason\n # for pushing an enabled state identical to the current one, so that it\n # will be restored after any such fiddling.\n old_state = {}\n for prop, value in lamp_parameters.items():\n getter, setter = self._get_getter_setter(prop)\n old_state[prop] = getter()\n setter(value)\n self._state_stack.append(old_state)","def __init__(self,\r\n lightpos=(10, -10, 20),\r\n lightcol=(1.0, 1.0, 1.0),\r\n lightamb=(0.1, 0.1, 0.2)):\r\n super(Light, self).__init__()\r\n self.lightpos = lightpos\r\n self.lightcol = lightcol\r\n self.lightamb = lightamb","def setMaterialParameters(val, ptype):\n pdict = {'ambient':'AMBIENT','diffuse':'DIFFUSE','specular':'SPECULAR',\n 'exponent':'EXPONENT'}\n dislin.matopt(val, pdict[ptype])","def place_headlamp_light():\n\n lx = 1.0\n ly = light_height\n lz = 2.0\n #light_position = [lx, ly, lz, 1.0]\n light_position = [0.0, 0.0, 0.0, 1]\n light_ambient = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\n light_diffuse = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\n light_specular = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\n light_direction = [1.0, -1.0, 1.0, 0.0] # Light points down\n # glViewport(0, 0, win_width, win_height)\n # glMatrixMode(GL_PROJECTION)\n # glLoadIdentity()\n # gluPerspective(40.0, float(win_width) / float(win_height), 0.01, 100.0)\n #\n # glMatrixMode(GL_MODELVIEW)\n # glLoadIdentity()\n # glPushMatrix()\n glLightfv(GL_LIGHT4, GL_POSITION, light_position)\n\n\n\n #glLightfv(GL_LIGHT4, GL_POSITION, (GLfloat * 4)(0.0, 0.0, 0.0, 1))\n glLightfv(GL_LIGHT4, GL_AMBIENT, light_ambient)\n glLightfv(GL_LIGHT4, GL_DIFFUSE, light_diffuse)\n glLightfv(GL_LIGHT4, GL_SPECULAR, light_specular)\n\n # Constant attenuation (for distance, etc.)\n # Only works for fixed light locations! Otherwise disabled\n # glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 2.0)\n # glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.0)\n # glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0)\n\n glLightf(GL_LIGHT4, GL_CONSTANT_ATTENUATION, 3.0)\n glLightf(GL_LIGHT4, GL_LINEAR_ATTENUATION, 0.0)\n glLightf(GL_LIGHT4, GL_QUADRATIC_ATTENUATION, 0.0)\n\n # Create a spotlight effect (none at the moment)\n if headlamp_is_on:\n glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 30.0)\n glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 0.0)\n glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, light_direction)\n else:\n glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 180.0)\n glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 0.0)\n\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\n # Try GL_TRUE - but then watch what happens when light is low\n\n glEnable(GL_LIGHT4)\n\n # This part draws a SELF-COLORED sphere (in spot where light is!)\n glPushMatrix()\n glTranslatef(lx, ly, lz)\n glDisable(GL_LIGHTING)\n glColor3f(brightness, brightness, brightness)\n glutSolidSphere(0.5, 20, 20)\n glEnable(GL_LIGHTING)\n glPopMatrix()","def setLCData(*args):\n args[0].Data.LCData.lc_data = args[1]","def flicker_lights(self):\n print 'Lights Set'","def pointLight(*args, decayRate: Union[int, bool]=0, discRadius: Union[float, bool]=0.0,\n exclusive: bool=True, intensity: Union[float, bool]=0.0, name: Union[AnyStr,\n bool]=\"\", position: Union[List[float, float, float], bool]=None, rgb:\n Union[List[float, float, float], bool]=None, rotation: Union[List[float, float,\n float], bool]=None, shadowColor: Union[List[float, float, float], bool]=None,\n shadowDither: Union[float, bool]=0.0, shadowSamples: Union[int, bool]=0,\n softShadow: bool=True, useRayTraceShadows: bool=True, q=True, query=True, e=True,\n edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def load_ltm(self, **kwargs):\r\n ltm = kwargs['ltm']\r\n\r\n self.ltm = LTM(ltm)\r\n self.ltm.label_ltm(self.hwlist)","def main():\n logging.info(\"Starting mLamp Driver\")\n\n temperature = read_temperature()\n temp_progress = interpolate_temperature(temperature)\n color = color_interpolate_map(color_map, temp_progress)\n\n logging.info(\"Temperature is: {}C, final color will be: {}\".format(temperature, color))\n\n while True:\n now = datetime.datetime.now()\n is_alarm_hour = alarm_start_hour <= now.hour <= alarm_stop_hour\n is_alarm_minute = alarm_start_minute <= now.minute <= alarm_stop_minute\n\n if is_alarm_hour and is_alarm_minute:\n time_progress = current_time() / alarm_length()\n\n final_color = color_interpolate_fade_in(color, time_progress)\n logging.debug(\"Setting color to: {}\".format(final_color))\n\n lamp_set_color(final_color)\n\n sleep(10)\n elif now.hour > alarm_stop_hour and now.minute > alarm_stop_minute:\n # don't forget to turn the lamps off when the time comes\n lamp_set_color((0, 0, 0))\n break\n else:\n sleep(60)\n\n logging.info(\"Stopping mLamp Driver\")","def multi_gaussian_lens_light(self, kwargs_lens_light, n_comp=20):\n r_h = self.half_light_radius_lens(kwargs_lens_light)\n r_array = np.logspace(-3, 2, 200) * r_h * 2\n #r_array = np.logspace(-2, 1, 50) * r_h\n flux_r = self._lens_light_internal(r_array, np.zeros_like(r_array), kwargs_lens_light)\n amplitudes, sigmas, norm = mge.mge_1d(r_array, flux_r, N=n_comp)\n return amplitudes, sigmas","def setMyColorTable(lr,lg,lb):\n dislin.myvlt(lr,lg,lb,len(lr))","def set_shape_params(self, params):\n self.alpha = params[0]\n self.beta = params[1]\n self.gamma = params[2]\n self.c500 = params[3]\n self.P0 = params[4]","def __init__(self, l=1, sigmaf=1, sigman=1e-6, bounds=None, parameters=['l', 'sigmaf', 'sigman']):\n\n self.l = l\n self.sigmaf = sigmaf\n self.sigman = sigman\n self.parameters = parameters\n if bounds is not None:\n self.bounds = bounds\n else:\n self.bounds = []\n for param in self.parameters:\n self.bounds.append(default_bounds[param])","def update_multiple_parameters(self, detuning=None, lamb_dicke=None,\n base_rabi=None):\n if detuning is not None:\n self.__detuning = detuning\n if lamb_dicke is not None:\n self.__lamb_dicke = lamb_dicke\n if base_rabi is not None:\n self.__base_rabi = base_rabi\n if detuning is None and lamb_dicke is None and base_rabi is None:\n return\n self.__update_prefactors()","def __init__(self, l=1, sigmaf=1, sigman=1e-6, bounds=None, parameters=['l', 'sigmaf', 'sigman']):\n self.l = l\n self.sigmaf = sigmaf\n self.sigman = sigman\n self.parameters = parameters\n if bounds is not None:\n self.bounds = bounds\n else:\n self.bounds = []\n for param in self.parameters:\n self.bounds.append(default_bounds[param])","def lamp_set_color(color):\n addresses = lamp_addresses\n\n r = hex(color[0])[2:].zfill(2)\n g = hex(color[1])[2:].zfill(2)\n b = hex(color[2])[2:].zfill(2)\n\n # the 01 here at the beginning of the message means that\n # the lamp will hold the color even when the connection is lost\n value = \"01\" + r + g + b\n\n for address in addresses:\n command = \"gatttool -b {} -t random --char-write --handle=0x0011 --value={}\".format(address, value)\n logging.debug(\"Sending command to RFduino: \" + command)\n os.system(command)","def setHsl ( self, h, s = 0.0, l = 0.0 ):\n self.setHsla( h, s, l )","def __init__(self, L_values=None, scatteringRadius=None, **kwargs):\n index = 0\n for attr in self.optAttrList:\n setattr(self, attr, kwargs.get(attr))\n self.L_values = L_values or []\n self.scatteringRadius = scatteringRadius\n if self.scatteringRadius: self.scatteringRadius.setAncestor( self )","def log_xlnet_params(local_dict):\n params = [\"DATA_FOLDER\",\"XLNET_CACHE_DIR\",\"LANGUAGE\",\"MAX_SEQ_LENGTH\",\"BATCH_SIZE\",\"NUM_GPUS\",\n \"NUM_EPOCHS\",\"TRAIN_SIZE\",\"LABEL_COL\",\"TEXT_COL\",\"LEARNING_RATE\",\"WEIGHT_DECAY\",\n \"ADAM_EPSILON\",\"WARMUP_STEPS\",\"DEBUG\"]\n for i in params:\n log_param(i,local_dict[i])\n return","def __init__(self, l=1, sigmaf=1.0, sigman=1e-6, bounds=None, parameters=['l', 'sigmaf',\n 'sigman']):\n self.l = l\n self.sigmaf = sigmaf\n self.sigman = sigman\n self.parameters = parameters\n if bounds is not None:\n self.bounds = bounds\n else:\n self.bounds = []\n for param in self.parameters:\n self.bounds.append(default_bounds[param])","def __init__(\n self,\n lca_layer: LCALayer,\n num_lca_dim: int,\n num_simulations: int = 10000,\n num_time_steps: int = 3000,\n ):\n\n super().__init__()\n\n self.lca_layer = lca_layer\n self.num_lca_dim = num_lca_dim\n self.num_simulations = num_simulations\n self.num_time_steps = num_time_steps","def export_lights(lamps, file, scene, global_matrix, tab_write):\n\n from .render import write_matrix, tab_write\n\n # Incremented after each lamp export to declare its target\n # currently used for Fresnel diffuse shader as their slope vector:\n global exported_lights_count\n # Get all lamps and keep their count in a global variable\n for exported_lights_count, ob in enumerate(lamps, start=1):\n lamp = ob.data\n\n matrix = global_matrix @ ob.matrix_world\n\n # Color is no longer modified by energy\n # any way to directly get bpy_prop_array as tuple?\n color = tuple(lamp.color)\n\n tab_write(file, \"light_source {\\n\")\n tab_write(file, \"< 0,0,0 >\\n\")\n tab_write(file, \"color srgb<%.3g, %.3g, %.3g>\\n\" % color)\n\n if lamp.type == \"POINT\":\n pass\n elif lamp.type == \"SPOT\":\n tab_write(file, \"spotlight\\n\")\n\n # Falloff is the main radius from the centre line\n tab_write(file, \"falloff %.2f\\n\" % (degrees(lamp.spot_size) / 2.0)) # 1 TO 179 FOR BOTH\n tab_write(\n file, \"radius %.6f\\n\" % ((degrees(lamp.spot_size) / 2.0) * (1.0 - lamp.spot_blend))\n )\n\n # Blender does not have a tightness equivalent, 0 is most like blender default.\n tab_write(file, \"tightness 0\\n\") # 0:10f\n\n tab_write(file, \"point_at <0, 0, -1>\\n\")\n if lamp.pov.use_halo:\n tab_write(file, \"looks_like{\\n\")\n tab_write(file, \"sphere{<0,0,0>,%.6f\\n\" % lamp.distance)\n tab_write(file, \"hollow\\n\")\n tab_write(file, \"material{\\n\")\n tab_write(file, \"texture{\\n\")\n tab_write(file, \"pigment{rgbf<1,1,1,%.4f>}\\n\" % (lamp.pov.halo_intensity * 5.0))\n tab_write(file, \"}\\n\")\n tab_write(file, \"interior{\\n\")\n tab_write(file, \"media{\\n\")\n tab_write(file, \"emission 1\\n\")\n tab_write(file, \"scattering {1, 0.5}\\n\")\n tab_write(file, \"density{\\n\")\n tab_write(file, \"spherical\\n\")\n tab_write(file, \"color_map{\\n\")\n tab_write(file, \"[0.0 rgb <0,0,0>]\\n\")\n tab_write(file, \"[0.5 rgb <1,1,1>]\\n\")\n tab_write(file, \"[1.0 rgb <1,1,1>]\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n tab_write(file, \"}\\n\")\n elif lamp.type == \"SUN\":\n tab_write(file, \"parallel\\n\")\n tab_write(file, \"point_at <0, 0, -1>\\n\") # *must* be after 'parallel'\n\n elif lamp.type == \"AREA\":\n tab_write(file, \"fade_distance %.6f\\n\" % (lamp.distance / 2.0))\n # Area lights have no falloff type, so always use blenders lamp quad equivalent\n # for those?\n tab_write(file, \"fade_power %d\\n\" % 2)\n size_x = lamp.size\n samples_x = lamp.pov.shadow_ray_samples_x\n if lamp.shape == \"SQUARE\":\n size_y = size_x\n samples_y = samples_x\n else:\n size_y = lamp.size_y\n samples_y = lamp.pov.shadow_ray_samples_y\n\n tab_write(\n file,\n \"area_light <%.6f,0,0>,<0,%.6f,0> %d, %d\\n\"\n % (size_x, size_y, samples_x, samples_y),\n )\n tab_write(file, \"area_illumination\\n\")\n if lamp.pov.shadow_ray_sample_method == \"CONSTANT_JITTERED\":\n if lamp.pov.use_jitter:\n tab_write(file, \"jitter\\n\")\n else:\n tab_write(file, \"adaptive 1\\n\")\n tab_write(file, \"jitter\\n\")\n\n # No shadow checked either at global or light level:\n if not scene.pov.use_shadows or (lamp.pov.shadow_method == \"NOSHADOW\"):\n tab_write(file, \"shadowless\\n\")\n\n # Sun shouldn't be attenuated. Area lights have no falloff attribute so they\n # are put to type 2 attenuation a little higher above.\n if lamp.type not in {\"SUN\", \"AREA\"}:\n if lamp.falloff_type == \"INVERSE_SQUARE\":\n tab_write(file, \"fade_distance %.6f\\n\" % (sqrt(lamp.distance / 2.0)))\n tab_write(file, \"fade_power %d\\n\" % 2) # Use blenders lamp quad equivalent\n elif lamp.falloff_type == \"INVERSE_LINEAR\":\n tab_write(file, \"fade_distance %.6f\\n\" % (lamp.distance / 2.0))\n tab_write(file, \"fade_power %d\\n\" % 1) # Use blenders lamp linear\n elif lamp.falloff_type == \"CONSTANT\":\n tab_write(file, \"fade_distance %.6f\\n\" % (lamp.distance / 2.0))\n tab_write(file, \"fade_power %d\\n\" % 3)\n # Use blenders lamp constant equivalent no attenuation.\n # Using Custom curve for fade power 3 for now.\n elif lamp.falloff_type == \"CUSTOM_CURVE\":\n tab_write(file, \"fade_power %d\\n\" % 4)\n\n write_matrix(file, matrix)\n\n tab_write(file, \"}\\n\")\n\n # v(A,B) rotates vector A about origin by vector B.\n file.write(\n \"#declare lampTarget%s= vrotate(<%.4g,%.4g,%.4g>,<%.4g,%.4g,%.4g>);\\n\"\n % (\n exported_lights_count,\n -ob.location.x,\n -ob.location.y,\n -ob.location.z,\n ob.rotation_euler.x,\n ob.rotation_euler.y,\n ob.rotation_euler.z,\n )\n )","def experiment_linear_l1(_):\n # Attack epsilon is manually set according to the norm of the min-norm\n # solution found using cvxpy for d/n=10. That is max-margin=1/min-norm.\n # Min linf-norm solution found (norm=0.0422)\n # Min l2-norm solution found (norm=0.3411)\n # Min l1-norm solution found (norm=1.8497)\n # Min l4-norm solution found (norm=0.0002)\n # Min l1.5-norm solution found (norm=0.5274)\n return experiment_linear_lp(\n adv_norm_type='l1',\n dual_norm_type='linf',\n baseline_norm_types=['l2'],\n attack_step_dir='grad_max')","def test_pass_through_lcoe_args():\n year = 2012\n rev2_points = slice(0, 3)\n res_file = os.path.join(TESTDATADIR, 'wtk/ri_100_wtk_{}.h5'.format(year))\n sam_files = os.path.join(TESTDATADIR, 'SAM/i_windpower_lcoe.json')\n\n output_request = ('cf_mean',\n 'lcoe_fcr',\n 'capital_cost',\n 'fixed_charge_rate',\n 'variable_operating_cost',\n 'fixed_operating_cost')\n\n # run reV 2.0 generation\n gen = Gen.reV_run(tech='windpower', points=rev2_points,\n sam_files=sam_files, res_file=res_file, max_workers=1,\n sites_per_worker=1, fout=None,\n output_request=output_request)\n\n checks = [x in gen.out for x in Gen.LCOE_ARGS]\n assert all(checks)\n assert 'lcoe_fcr' in gen.out\n assert 'cf_mean' in gen.out","def lms(options):\r\n settings = getattr(options, 'settings', None)\r\n port = getattr(options, 'port', None)\r\n fast = getattr(options, 'fast', False)\r\n run_server('lms', settings=settings, port=port, skip_assets=fast)","def __init__(self, data=None, lambtha=1.):\n if data is None:\n if lambtha <= 0:\n raise ValueError('lambtha must be a positive value')\n else:\n self.lambtha = float(lambtha)\n else:\n if not isinstance(data, list):\n raise TypeError('data must be a list')\n else:\n num_of_elements = len(data)\n if num_of_elements < 2:\n raise ValueError('data must contain multiple values')\n else:\n self.lambtha = sum(data) / num_of_elements","def set_lbda(self, lbda, derive_mag=True, negative_fluxmag=None):\n self._properties[\"lbda\"] = lbda\n if derive_mag:\n self.derive_magsamples(negative_fluxmag=negative_fluxmag)","def update_linear_kwargs(self, param, kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps):\n kwargs_lens_i, kwargs_source_i, kwargs_lens_light_i, kwargs_ps_i, kwargs_extinction_i = self.select_kwargs(\n kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, kwargs_extinction=None)\n return self._update_linear_kwargs(param, kwargs_lens_i, kwargs_source_i, kwargs_lens_light_i, kwargs_ps_i)","def set_params(**kwargs):\n\t\tif \"study\" in kwargs.keys():\n\t\t\traise TypeError(\"Got an unexpected keyword argument: 'study'\")\n\t\telse:\n\t\t\tfor i in range(len(_RECOGNIZED_ELEMENTS_)):\n\t\t\t\t__settings[_RECOGNIZED_ELEMENTS_[i]] = __fractional(\n\t\t\t\t\t_RECOGNIZED_ELEMENTS_[i], study = \"LC18\", **kwargs)[0]","def run_slam(src_dir, log_dir, idx, split):\n slam = slam_t(resolution=0.05, Q=np.diag([2e-4,2e-4,1e-4]))\n slam.read_data(src_dir, idx, split)\n T = len(slam.lidar) \n \n \n \n # again initialize the map to enable calculation of the observation logp in\n # future steps, this time we want to be more careful and initialize with the\n # correct lidar scan. First find the time t0 around which we have both LiDAR\n # data and joint data \n \n t0 = max(slam.find_joint_t_idx_from_lidar(0), 0) \n \n odo = [] \n for t in range(t0+1, T): \n odo.append(slam.lidar[t][\"xyth\"]) \n odo = np.array(odo).T\n odo_grid = slam.map.grid_cell_from_xy(odo[0], odo[1])\n \n #initialize one particle \n xyth = slam.lidar[t0]['xyth']\n xyth[2] = slam.lidar[t0]['rpy'][2]\n logging.debug('> Initializing 1 particle at: {}'.format(xyth))\n slam.init_particles(n=1,p=xyth.reshape((3,1)),w=np.array([1]))\n slam.observation_step(t=t0) \n #intialize 100 particls \n\n logging.info('> Particles\\n: {}'.format(slam.p))\n logging.info('> Weights: {}'.format(slam.w))\n slam.init_particles(n=100,p=np.zeros((3,100), dtype=np.float64), w=np.full((100, ), 1./100)) \n\n color_dict = {\n \"gray\": np.array([.5, .5, .5]), \n \"white\": np.array([1., 1., 1.]),\n \"black\": np.array([0., 0., 0.])\n }\n \n #Run the SLAM\n max_particles = [] \n color_map = np.zeros((slam.map.szx, slam.map.szy, 3)) \n for t in tqdm.tqdm(range(t0+1,T)): \n slam.dynamics_step(t)\n max_particle = slam.observation_step(t) \n max_particle_grid = slam.map.grid_cell_from_xy(np.array(max_particle[0]).reshape(1, 1), np.array(max_particle[1]).reshape(1, 1)) \n max_particles.append(np.squeeze(max_particle_grid)) \n color_map[slam.map.num_obs_per_cell == 0] = color_dict[\"gray\"]\n color_map[slam.map.num_obs_per_cell > 0] = color_dict[\"white\"]\n color_map[slam.map.cells == 1] = color_dict[\"black\"]\n #plot every thousand iterations \n if t % 1000 == 0:\n plt.figure(figsize=(20, 20)) \n plt.imshow(color_map)\n plot_particles = np.array(max_particles).T \n plt.scatter(x=odo_grid[1, t0+1:t], y=odo_grid[0,t0+1:t], c='b', s=5)\n plt.scatter(x=plot_particles[1], y=plot_particles[0], c='r', s=5)\n plt.draw()\n plt.pause(0.0001) \n\n max_particles = np.array(max_particles).T \n\n fig = plt.figure(figsize=(20, 20)); plt.clf(); \n plt.imshow(color_map) \n plt.scatter(x=max_particles[1], y=max_particles[0], c='r', s=5) \n plt.scatter(x=odo_grid[1], y=odo_grid[0], c='b', s=5) \n plt.title('Particle Filter Occupancy Map')\n logging.info('> Saving plot in '+os.path.join(log_dir, 'slam_full%s_%02d.jpg'%(split, idx)))\n plt.savefig(os.path.join(log_dir, \"slam_output_\" + str(idx) + \".jpg\"))","def set_landscape_params(landscape, params):\n if landscape == \"L\":\n Lowland.set_params(params)\n elif landscape == \"H\":\n Highland.set_params(params)\n else:\n raise ValueError(\"Only params in Lowland and Highland can be changed! No params set.\")","def __init__(self, hass, lj, i, name):\n self._hass = hass\n self._lj = lj\n self._index = i\n self._brightness = 0\n self._name = name\n\n lj.on_load_activated(i, self._on_load_changed)\n lj.on_load_deactivated(i, self._on_load_changed)","def set_lam_kld_l1l2(self, lam_kld_l1l2=1.0):\n zero_ary = np.zeros((1,))\n new_val = zero_ary + lam_kld_l1l2\n self.lam_kld_l1l2.set_value(to_fX(new_val))\n return","def lsits(self) -> List[LsitsParam]:\n return self._lsits","def set_laser_power(self, power: int):\n self.logger.info(f'Setting laser power to {power}')\n power = int(power)\n if power <= 1:\n self.electronics.servo = 0\n else:\n self.electronics.servo = 1\n\n self.electronics.laser_power = power\n self.config['laser']['power'] = power","def set_light_mode(self, is_lid):\n raise NotImplementedError()","def set_parameters(self, **kwargs):\n self.__multi_layer_perceptron.set_params(**kwargs)","def create_lamp(self,lamp_id,section_id, section, phase_id):\r\n \r\n self.lamps[lamp_id]=(section_id,phase_id)\r\n\r\n self.lane_groups[phase_id].append(section)\r\n \r\n return (section_id,phase_id)","def set_values(self,\n name: Optional[str] = None,\n **kwargs: any):\n\n if 'potential' in kwargs:\n assert 'potential_key' not in kwargs\n assert 'potential_id' not in kwargs\n assert 'potential_LAMMPS_key' not in kwargs\n assert 'potential_LAMMPS_id' not in kwargs\n self.potential_key = kwargs['potential'].potkey\n self.potential_id = kwargs['potential'].potid\n self.potential_LAMMPS_key = kwargs['potential'].key\n self.potential_LAMMPS_id = kwargs['potential'].id\n else:\n if 'potential_key' in kwargs:\n self.potential_key = kwargs['potential_key']\n if 'potential_id' in kwargs:\n self.potential_id = kwargs['potential_id']\n if 'potential_LAMMPS_key' in kwargs:\n self.potential_LAMMPS_key = kwargs['potential_LAMMPS_key']\n if 'potential_LAMMPS_id' in kwargs:\n self.potential_LAMMPS_id = kwargs['potential_LAMMPS_id']\n\n if name is None:\n if self.potential_LAMMPS_id is not None:\n self.name = f'props.{self.potential_LAMMPS_id}.{self.potential_key[:8]}'","def initializeParameters(self):\r\n\t\tself.input_raster.enabled = True\r\n\t\tself.approach.enabled = True\r\n\t\tself.predefined_pattern.enabled = False\r\n\t\tself.predefined_pattern.value = 'Mexican Hat wavelet'\r\n\t\tself.pattern_workspace.enabled = False\r\n\t\tself.point_matrix_size.enabled = False\r\n\t\tself.point_matrix_size.value = 3\r\n\t\tself.point_vectors.enabled = False\r\n\t\tself.mapping_field.enabled = False\r\n\t\tself.move_to_max.enabled = False\r\n\t\tself.move_to_max_distance.enabled = False\r\n\t\tself.move_to_max_distance.value = 3\r\n\t\tself.mh_iteration.enabled = False\r\n\t\tself.mh_dil_val.enabled = False\r\n\t\tself.mh_dil_val.value = 1\r\n\t\tself.mh_dil_start.value = 0.01\r\n\t\tself.mh_dil_stop.value = 1\r\n\t\tself.mh_dil_step.value = 0.1\r\n\t\tself.mh_dil_start.enabled = False\r\n\t\tself.mh_dil_stop.enabled = False\r\n\t\tself.mh_dil_step.enabled = False\r\n\t\tself.transform.enabled = False\r\n\t\tself.size_of_the_cell.enabled = False\r\n\t\tself.size_of_the_cell.value = 1\r\n\t\tself.output_sim_matrix.enabled = False\r\n\t\tself.output_table.enabled = False\r\n\t\tself.output_raster_workspace.enabled = False","def __init__(self, lr=1e-3, C=1.0, iterations=10):\n\n self.lr = lr\n self.lam = C\n self.iterations = iterations","def configure_plotcamlite():\r\n\r\n # command line argument parsing\r\n parser = ArgumentParser(\r\n prog=\"python plotcam-lite.py\",\r\n description=\"PlotCamLite (April 2021). Realtime plot monitoring system. By Rua'a Abdulmajeed for AAFC Phenom Corp\")\r\n\r\n\r\n # running on headset or not\r\n parser.add_argument(\r\n '-m', '--monitor',\r\n dest=\"monitor\",\r\n action='store_true',\r\n help=\"add this option for it to format properly on a monitor\",\r\n )\r\n\r\n # change stream resolution\r\n parser.add_argument(\r\n '-res',\r\n dest=\"res\",\r\n type=int,\r\n default=1280,\r\n choices=[1280, 640],\r\n help=\"change the stream's resolution, either 1280x720(default) or 640x480\",\r\n )\r\n\r\n # change the stream fps\r\n parser.add_argument(\r\n '-fps',\r\n dest=\"fps\",\r\n type=int,\r\n default=30,\r\n choices=[15, 30],\r\n help=\"set the stream's fps, either 15 or 30\",\r\n )\r\n\r\n # Log Level\r\n parser.add_argument(\r\n '-l', '--log',\r\n dest=\"log_level\",\r\n type=str,\r\n default=None,\r\n choices=[\"debug\", \"info\", \"warning\", \"error\"],\r\n help=\"specify level of logging, defaults to no logging\",\r\n )\r\n\r\n args = parser.parse_args()\r\n\r\n # handle monitor view \r\n pcl_config[\"monitor\"] = args.monitor\r\n if pcl_config[\"monitor\"]:\r\n pcl_config[\"main_window_ui_path\"] = os.path.join(PCL_SRC_PATH, \"resources\", \"ui\", \"PlotCamLiteUI_monitor.ui\")\r\n \r\n # handle fps\r\n pcl_config[\"stream_fps\"] = args.fps\r\n\r\n # handle resolution\r\n pcl_config[\"stream_height\"] = args.res\r\n pcl_config[\"stream_width\"] = resolution_width[pcl_config[\"stream_height\"]]\r\n\r\n # handle logging\r\n configure_logging(log_level=args.log_level, log_fpath=os.path.join(PCL_SRC_PATH, LOG_FILENAME))\r\n\r\n # create the main path directory\r\n if not os.path.exists(PCL_EXP_PATH):\r\n os.makedirs(PCL_EXP_PATH)","def reset(self, l11=None, l12=None, l13=None, l21=None, l22=None, l23=None):\n self.l11 = np.random.uniform(self.l1min, self.l1max) if l11 == None else l11\n self.l12 = np.random.uniform(self.l1min, self.l1max) if l12 == None else l12\n self.l13 = np.random.uniform(self.l1min, self.l1max) if l13 == None else l13\n self.l21 = np.random.uniform(self.l2min, self.l2max) if l21 == None else l21\n self.l22 = np.random.uniform(self.l2min, self.l2max) if l22 == None else l22\n self.l23 = np.random.uniform(self.l2min, self.l2max) if l23 == None else l23\n # after resetting tendon lengths, variables need to be updated\n self.goal = self.get_goal()\n self.done = False\n self.update_variables()","def initialize(self, n_samples=1, kl_scaling=None, *args, **kwargs):\n if kl_scaling is None:\n kl_scaling = {}\n if n_samples <= 0:\n raise ValueError(\n \"n_samples should be greater than zero: {}\".format(n_samples))\n\n self.n_samples = n_samples\n self.kl_scaling = kl_scaling\n return super(elbo_optimizer, self).initialize(*args, **kwargs)","def test_plasma_with_laser(cet_plasma, cet_param):\n # test constructor with no bubble_radius and given propagation_distance\n _ = Plasma(\n n_pe=cet_param.npe,\n laser=cet_plasma.laser,\n propagation_distance=13.56555928 * u.mm,\n )\n\n assert_allclose_units(cet_plasma.Pc, 19.7422087 * u.terawatt)\n assert_allclose_units(cet_plasma.depletion, 13.92603593 * u.mm)\n assert_allclose_units(cet_plasma.dephasing, 13.56555928 * u.mm)"],"string":"[\n \"def setParameters(self, lam=45, **ukwargs):\\n\\t\\tEvolutionStrategy1p1.setParameters(self, **ukwargs)\\n\\t\\tself.lam = lam\\n\\t\\tif ukwargs: logger.info('Unused arguments: %s' % (ukwargs))\",\n \"def setLSLimits(*args):\\n args[0].Limit.LSLimit.ls_limit = args[1]\",\n \"def setLCLimits(*args):\\n args[0].Limit.LCLimit.lc_limit = args[1]\",\n \"def all_lamps_slow():\\n HOUSE = pre_process.get_house()\\n\\n for id_num, lamp in HOUSE.lamps.items():\\n lamp.turn_on()\\n lamp.set_transition_time(500)\\n lamp.set_brigthness(254)\\n lamp.send_command()\",\n \"def get_lamp_parameters(p, header, filename=None, kind=None):\\n\\n func_name = __NAME__ + '.get_lamp_parameters()'\\n # get relevant (cass/ref) fiber position (for lamp identification)\\n gkwargs = dict(return_value=True, dtype=str)\\n if p['FIBER'] == 'C':\\n p['FIB_POS'] = spirouImage.ReadParam(p, header, 'kw_CREF', **gkwargs)\\n p['FIB_POS_ID'] = p['kw_CREF'][0]\\n elif p['FIBER'] in ['AB', 'A', 'B']:\\n p['FIB_POS'] = spirouImage.ReadParam(p, header, 'kw_CCAS', **gkwargs)\\n p['FIB_POS_ID'] = p['kw_CCAS'][0]\\n else:\\n emsg1 = ('Fiber position cannot be identified for fiber={0}'\\n .format(p['FIB_TYP']))\\n emsg2 = ' function={0}'.format(__NAME__)\\n WLOG(p, 'error', [emsg1, emsg2])\\n # set the source of fib_pos\\n p.set_sources(['FIB_POS', 'FIB_POS_ID'], func_name)\\n\\n # identify lamp\\n if kind is not None:\\n lamp = kind\\n elif filename is not None:\\n lamp = decide_on_lamp_type(p, filename=filename)\\n else:\\n lamp = decide_on_lamp_type(p, filename=p['ARG_FILE_NAMES'][0])\\n\\n # -------------------------------------------------------------------------\\n # Now set parameters in p based on lamp type\\n\\n # the lamp type\\n p['LAMP_TYPE'] = lamp\\n p.set_source('LAMP_TYPE', func_name)\\n # the lamp file\\n p['IC_LL_LINE_FILE'] = p['IC_LL_LINE_FILE_ALL'][lamp]\\n p.set_source('IC_LL_LINE_FILE', func_name)\\n # the lamp cat type\\n p['IC_CAT_TYPE'] = p['IC_CAT_TYPE_ALL'][lamp]\\n p.set_source('IC_CAT_TYPE', func_name)\\n # -------------------------------------------------------------------------\\n # finally return p\\n return p\",\n \"def lmp(self, lmp):\\n\\n self.logger.debug(\\\"In 'lmp' setter.\\\")\\n\\n self._lmp = lmp\",\n \"def lra_parameters(**kwargs):\\n pars = {'d1' : 0.1,\\n 'd2' : 2.1,\\n 'd3' : 0.9967,\\n 'd5' : 0.2,\\n 'a2' : 0.4,\\n 'c1' : 0.4,\\n 'c0' : 4,\\n 'rc' : 7,\\n 'rl' : 0.05,\\n 'ver' : 0.9,\\n 'Ker' : 0.1,\\n 'ip3' : 0.1,\\n 'noise' : False,\\n 'ICs' : [0.05,0.99]\\n }\\n\\n ## User-defined parameters\\n pars = gu.varargin(pars,**kwargs)\\n # Parameters must be floats\\n for k,item in pars.iteritems():\\n if isscalar(item):\\n pars[k] = float(item)\\n elif isinstance(item, bool):\\n pars[k] = np.intc(item)\\n else:\\n pars[k] = array(item,dtype=float)\\n return pars\",\n \"def __init__(self, lam=1.0):\\n self.lam = lam\\n\\n # these are set in fit\\n self.b = None # float\\n self.w = None # (nvars, ) array\",\n \"def configure_global_lldp_parameters(self, **kwargs):\\n pass\",\n \"def set_lam_nll(self, lam_nll=1.0):\\n zero_ary = np.zeros((1,))\\n new_lam = zero_ary + lam_nll\\n self.lam_nll.set_value(to_fX(new_lam))\\n return\",\n \"def setLinearAirDamping(*argv):\",\n \"def _iotool_lamp_commands(self, **lamps):\\n commands = []\\n for lamp, enabled in lamps.items():\\n if enabled is None:\\n continue\\n pin = self._spconfig.IOTOOL_LAMP_PINS[lamp]\\n if enabled:\\n commands.append(self._iotool.commands.set_high(pin))\\n else:\\n commands.append(self._iotool.commands.set_low(pin))\\n return commands\",\n \"def __init__(self, lms, temp=1.0, alphas=[0.7, 0.2, 0.1]):\\r\\n super().__init__(lms[0], temp)\\r\\n self.lms = lms\\r\\n self.alphas = alphas\\r\\n assert (abs(sum(alphas) - 1) < 0.0000001)\",\n \"def set_lims(self):\\n xx_min, xx_max = self.set_period_limits()\\n y_min = self.tf.rho.min()\\n y_min = max(y_min, 1e-20)\\n y_max = self.tf.rho.max()\\n y_max = max(y_max, 1e-20)\\n\\n yy_min = 10 ** (np.floor(np.log10(y_min)))\\n if (np.log10(y_min) - np.log10(yy_min)) < 0.15:\\n yy_min = 10 ** (np.log10(yy_min) - 0.3)\\n\\n yy_max = 10 ** (np.ceil(np.log10(y_max)))\\n if (np.log10(yy_max) - np.log10(y_max)) < 0.15:\\n yy_max = 10 ** (np.log10(yy_max) + 0.3)\\n\\n if abs(yy_max - yy_min) > 1:\\n lims = [xx_min, xx_max, yy_min, yy_max, 0, 90]\\n else:\\n lims = [xx_min, xx_max, 0.01, 1e4, 0, 90]\\n\\n orient = 0.0\\n return lims, orient\",\n \"def lammps(parameter, iteration, numberlist, density, chainlength):\\n # input parameters\\n var = parameter[0]\\n x = var * numberlist[0]\\n y = var * numberlist[1] * 1.732 / 2\\n z = x / 2\\n #nodeid = 55 + iteration % 5\\n M = int((x * y * z * density - 4 * numberlist[0] * numberlist[1] * int(z / 0.3)) / chainlength) \\n os.environ['var'] = str(var)\\n os.environ['iteration'] = str(iteration)\\n os.environ['M'] = str(M)\\n #os.environ['nodeid'] = str(nodeid)\\n # copy the files to modify\\n os.system(\\\"cp in.asymmetric in.asymmetric_$iteration\\\")\\n os.system(\\\"cp run_lammps.sh run_lammps_$iteration.sh\\\")\\n os.system(\\\"cp MultiBCP_hexagonal_post.py MultiBCP_hexagonal_post_$iteration.py\\\")\\n # modify relevant files\\n os.system('sed -i -e \\\"s/distance = 12/distance = $var/\\\" MultiBCP_hexagonal_post_$iteration.py')\\n os.system(\\\"python MultiBCP_hexagonal_post_$iteration.py\\\")\\n time.sleep(3)\\n os.system('sed -i -e \\\"s/3072/$M/\\\" in.asymmetric_$iteration')#modify according to the parameters\\n os.system('sed -i -e \\\"s/XN_100/XN_100_$iteration/\\\" in.asymmetric_$iteration')\\n os.system('sed -i -e \\\"s/finalasymmetric/finalasymmetric_$iteration/\\\" in.asymmetric_$iteration')\\n os.system('sed -i -e \\\"s/POSTA2B8/POSTA2B8_$iteration/\\\" run_lammps_$iteration.sh')\\n os.system('sed -i -e \\\"s/posta2b8.out/posta2b8_$iteration.out/\\\" run_lammps_$iteration.sh')\\n #os.system('sed -i -e \\\"s/node55/node$nodeid/\\\" run_lammps_$iteration.sh')\\n os.system('sed -i -e \\\"s/in.asymmetric/in.asymmetric_$iteration/\\\" run_lammps_$iteration.sh')\\n # run the simulation\\n os.system(\\\"sbatch run_lammps_$iteration.sh\\\")\\n return None\",\n \"def __init__(self,\\n L=1,\\n steer_max=0.45 * pi,\\n **kwargs\\n ):\\n super().__init__(**kwargs)\\n\\n self._l = L\\n self._steer_max = steer_max\",\n \"def setLSData(*args):\\n args[0].Data.LSData.lc_data = args[1]\",\n \"def set_parameters(self, L, r):\\n self.L = L\\n self.r = r\",\n \"def setParams(self,dim=20, nIter=5, lamb=0.05, alph=40):\\n self._dim = dim\\n self._nIter = nIter\\n self._lamb = lamb\\n self._alph = alph\",\n \"def set_lam_kld(self, lam_kld_z=1.0, lam_kld_q2p=1.0, lam_kld_p2q=1.0):\\n zero_ary = np.zeros((1,))\\n new_lam = zero_ary + lam_kld_z\\n self.lam_kld_z.set_value(to_fX(new_lam))\\n new_lam = zero_ary + lam_kld_q2p\\n self.lam_kld_q2p.set_value(to_fX(new_lam))\\n new_lam = zero_ary + lam_kld_p2q\\n self.lam_kld_p2q.set_value(to_fX(new_lam))\\n return\",\n \"def __init__(\\n self,\\n nb_samples: int,\\n clip_values: Tuple[float, float],\\n lam: Union[float, Tuple[float, float]],\\n apply_fit: bool = False,\\n apply_predict: bool = True,\\n ) -> None:\\n super().__init__(\\n apply_fit=apply_fit, apply_predict=apply_predict, nb_samples=nb_samples, clip_values=clip_values\\n )\\n\\n self.lam = lam\\n self.lam_range = (0.0, lam) if isinstance(lam, (int, float)) else lam\\n self._check_params()\",\n \"def lsits(self, lsits: List[LsitsParam]):\\n\\n self._lsits = lsits\",\n \"def initiate_lmp(self, cs_springs):\\n lmp = lammps()\\n \\n lmp.command('units metal')\\n lmp.command('atom_style full')\\n \\n large_tilt = self._check_large_tilt()\\n if large_tilt:\\n lmp.command('box tilt large')\\n\\n lmp.command('read_data {}'.format(self.file_name))\\n \\n lmp.command('group cores type {}'.format(self.type_core()))\\n if len(self.bond_types) != 0:\\n lmp.command('group shells type {}'.format(self.type_shell()))\\n\\n if cs_springs:\\n lmp.command('pair_style buck/coul/long/cs 10.0')\\n lmp.command('pair_coeff * * 0 1 0')\\n\\n lmp.command('bond_style harmonic') \\n for bond in self.bond_types:\\n lmp.command(bond.bond_string())\\n else:\\n lmp.command('pair_style buck/coul/long 10.0')\\n lmp.command('pair_coeff * * 0 1 0')\\n\\n lmp.command('kspace_style ewald 1e-6')\\n\\n #setup for minimization\\n lmp.command('min_style cg')\\n return lmp\",\n \"def _set_train_params(self,\\n lr: float = 1e-3,\\n l2norm: float = 1e-2,\\n ):\\n self.lr = lr\\n self.l2norm = l2norm\\n self.optimizer = torch.optim.Adam(\\n self.model.parameters(), lr=lr, weight_decay=l2norm)\",\n \"def _set_learning_rates(\\n self, lr_a=None, lr_alpha=None, lr_l=None, lr_labda=None, lr_c=None\\n ):\\n if lr_a:\\n self._a_train.lr.assign(lr_a)\\n if lr_alpha:\\n self._alpha_train.lr.assign(lr_alpha)\\n if self.use_lyapunov:\\n if lr_l:\\n self._l_train.lr.assign(lr_l)\\n if lr_labda:\\n self._lambda_train.lr.assign(lr_labda)\\n else:\\n if lr_c:\\n self._q_train.lr.assign(lr_c)\",\n \"def lammps(step, atomnum, boxbounds, addson = ''):\\r\\n\\r\\n line = 'ITEM: TIMESTEP\\\\n'\\r\\n line += str(step) + '\\\\n'\\r\\n\\r\\n line += 'ITEM: NUMBER OF ATOMS\\\\n'\\r\\n line += str(atomnum) + '\\\\n'\\r\\n\\r\\n line += 'ITEM: BOX BOUNDS pp pp pp\\\\n'\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[0, 0], boxbounds[0, 1])\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[1, 0], boxbounds[1, 1])\\r\\n if boxbounds.shape[0] == 3:\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[2, 0], boxbounds[2, 1])\\r\\n else:\\r\\n line += '%.6f %.6f\\\\n' %(-0.5, 0.5)\\r\\n\\r\\n line += 'ITEM: ATOMS id type x y z %s\\\\n' %addson\\r\\n\\r\\n return line\",\n \"def set_L(self, xlambda, Lcap=False):\\n if (Lcap):\\n xlambda /= self.get_N() - 1.\\n self.set_par('XLAMBDA_0', float(xlambda))\",\n \"def default_parameters():\\n prm = Parameters('lvad_model')\\n\\n prm.add('lvad_volume', 66.0)\\n\\n prm.add('alpha_slope', 0.0091)\\n prm.add('alpha_intercept', 1.4)\\n\\n prm.add('beta_slope', -0.19)\\n prm.add('beta_intercept', -1.9)\\n\\n prm.add('frequency', float())\\n\\n return prm\",\n \"def setLeds(number: int, red: int, green: int, blue: int):\\n pass\",\n \"def init_lp(data, **kwargs):\\r\\n d = []\\r\\n CL = []; CT = []\\r\\n rhoL = []; rhoT = []\\r\\n alphaL = []; alphaT = []\\r\\n omega = kwargs.get('omega', 0)\\r\\n # layers\\r\\n for layer in data['layers'].values():\\r\\n d.append(layer[1])\\r\\n mat_name = layer[0]\\r\\n if mat_name=='meta':\\r\\n metaparam = layer[2:]\\r\\n prop = mat.properties(mat_name, omega/2/np.pi, *metaparam)\\r\\n # prop = [u[0] for u in prop] # avoid array (1,)\\r\\n else:\\r\\n prop = mat.properties(mat_name, omega/2/np.pi)\\r\\n # prop = [ u[0] for u in prop if u!=[] ] # avoid array (1,)\\r\\n if prop==[]:\\r\\n return\\r\\n CL.append(prop[0])\\r\\n CT.append(prop[1])\\r\\n rhoL.append(prop[2])\\r\\n rhoT.append(prop[3])\\r\\n alphaL.append(prop[4])\\r\\n alphaT.append(prop[5])\\r\\n lp = (d, CL, CT, rhoL, rhoT, alphaL, alphaT)\\r\\n mat_name = data['halfspace_left']\\r\\n prop = mat.properties(mat_name, omega/2/np.pi)\\r\\n # prop = [u[0] for u in prop] # avoid array (1,)\\r\\n [ lp[i+1].insert(0, prop[i]) for i in range(6) ]\\r\\n mat_name = data['halfspace_right']\\r\\n prop = mat.properties(mat_name, omega/2/np.pi)\\r\\n # prop = [u[0] for u in prop] # avoid array (1,)\\r\\n [ lp[i+1].append(prop[i]) for i in range(6) ]\\r\\n return lp\",\n \"def _add_lamp_outlets(self):\\r\\n lst = self.model.get_all_lamp_outlets()\\r\\n\\r\\n for itm in lst:\\r\\n self._add_lamp_outlet(itm)\",\n \"def join_lens_with_light_loose(kwargs_lens,kwargs_lens_light,prior_list):\\n \\n logL = 0\\n \\n if not kwargs_lens: \\n pass\\n elif not kwargs_lens_light:\\n pass\\n else:\\n for i in range(len(prior_list)):\\n light_index, lens_index, param, sigma = prior_list[i]\\n \\n model_val = kwargs_lens[lens_index][param] \\n mean_val = kwargs_lens_light[light_index][param]\\n \\n dist = (model_val - mean_val)**2 / sigma ** 2 / 2\\n logL -= np.sum(dist)\\n \\n# print('prior: {}_lens \\\\n lens_val: {} \\\\n light value: {} \\\\n sigma: {}'.format(param,model_val,mean_val,sigma))\\n \\n return logL\",\n \"def setParameters(self, A_l=0.9, A_u=1.0, r_l=0.001, r_u=0.1, tao_1=0.1, tao_2=0.1, **ukwargs):\\n\\t\\tAdaptiveBatAlgorithm.setParameters(self, **ukwargs)\\n\\t\\tself.A_l, self.A_u, self.r_l, self.r_u, self.tao_1, self.tao_2 = A_l, A_u, r_l, r_u, tao_1, tao_2\",\n \"def __init__(self, *args, **kwargs):\\n super(LinlLis, self).__init__(\\n ('linl', Bits(maxlen=4)),\\n ('lis', Bits(maxlen=4)),\\n *args, **kwargs\\n )\",\n \"def set_params(self, **kwargs):\\n\\n kw_keys = list(kwargs)\\n\\n if 'alpha' in kw_keys:\\n self.alpha = kwargs['alpha']\\n\\n if 'beta' in kw_keys:\\n self.beta = kwargs['beta']\\n\\n if 'gamma' in kw_keys: \\n \\tself.gamma = kwargs['gamma']\\n\\n if 'epsilon' in kw_keys:\\n self.epsilon = kwargs['epsilon']\\n \\n self.nact = self.highbound-self.lowbound\\n self.actions = np.arange(self.nact)\",\n \"def setLaserPower(self,wavelength, power, job, seq=1):\\n self.emptyCMDlist()\\n\\n c = \\\"/cli:python /app:matrix /sys:1 /cmd:adjustls /seq:\\\" + str(seq) + \\\" /exp:\\\" + job\\n if int(wavelength) == 405:\\n c += \\\" /lsq:uv /lid:405\\\"\\n else:\\n c += \\\" /lsq:vis /lid:\\\" + str(wavelength)\\n c+= \\\" /tar:laser /value:\\\" + str(float(power))\\n self.addtoCMDlist(c)\\n self.sendCMDlist()\",\n \"def __init__(self, l_smooth = LS):\\n self.l_smooth = l_smooth\",\n \"def __call__(self, lam=1.0, size=None, **kwargs):\\n return super().__call__(lam, size=size, **kwargs)\",\n \"def amps(self, amp: NumType):\\n self._amp = amp\",\n \"def mle_parameters(self, start=None, random_seed=None):\\n\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n\\n if start is None:\\n start = self.sample_parameters_posterior(1)[0, :]\\n\\n bounds = self.get_bounds_parameters\\n\\n objective_function = self.objective_llh\\n grad_function = self.grad_llh\\n\\n optimization = Optimization(\\n LBFGS_NAME,\\n objective_function,\\n bounds,\\n grad_function,\\n minimize=False)\\n\\n return optimization.optimize(start)\",\n \"def set_lam_l2w(self, lam_l2w=1e-3):\\n zero_ary = np.zeros((1,))\\n new_lam = zero_ary + lam_l2w\\n self.lam_l2w.set_value(to_fX(new_lam))\\n return\",\n \"def setLightingOptions(lightID, val, otype):\\n odict = {'ambient':'AMBIENT','diffuse':'DIFFUSE','specular':'SPECULAR',\\n 'constant':'CONSTANT','linear':'LINEAR','quadratic':'QUADRATIC'}\\n dislin.litopt(lightID, val, odict[otype])\",\n \"def setHsla ( self, h, s = 0.0, l = 0.0, a = 1.0 ):\\n #self.reset()\\n\\n # Check if argument is list\\n if isinstance(h, list):\\n s = h[1]\\n l = h[2]\\n if len(h) == 4: # Alpha in the list\\n a = h[3]\\n h = h[0]\\n\\n # If any component is int ( 0 - 255 ) convert to float ( 0 - 1)\\n hsla = [ h, s, l, a ]\\n for i in range(len(hsla)):\\n if isinstance( hsla[i], int ):\\n hsla[i] = hsla[i] / 360.0 if i == 0 else hsla[i] / 100.0\\n\\n self.h = hsla[0]\\n self.s = hsla[1]\\n self.l = hsla[2]\\n self.a = hsla[3]\\n self.hsl = [ hsla[0], hsla[1], hsla[2] ]\\n self.hsla = [ hsla[0], hsla[1], hsla[2], hsla[3] ]\\n\\n self.updateFromHsl()\",\n \"def set_parameters(self,params):\\n K3Supervisor.set_parameters(self,params)\\n self.blending.set_parameters(self.parameters)\",\n \"def setLum ( self, newlum ):\\n if isinstance( newlum, int ):\\n newlum /= 100\\n if newlum > 1.0:\\n newlum = 1.0\\n if newlum < 0.0:\\n newlum = 0.0\\n self.l = newlum\\n self.hsl[2] = newlum\\n self.hsla[2] = newlum\\n self.updateFromHsl()\",\n \"def ISM_lums(line,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n GR = glo.global_results()\\n\\n L_tot = getattr(GR,'L_%s_sun' % line)\\n L_H2 = getattr(GR,'L_%s_H2_sun' % line)\\n L_HI = getattr(GR,'L_%s_HI_sun' % line)\\n L_HII = getattr(GR,'L_%s_HII_sun' % line)\\n fig, ax = plt.subplots(figsize=(8, 6 ),facecolor='w')\\n x=ax.hist(np.log10(L_tot[L_tot > 0]),bins=100,alpha=0.6,label='tot',color='grey')\\n x=ax.hist(np.log10(L_H2[L_H2 > 0]),bins=100,alpha=0.6,label='H2',color='r')\\n x=ax.hist(np.log10(L_HI[L_HI > 0]),bins=100,alpha=0.8,label='HI',color='orange')\\n x=ax.hist(np.log10(L_HII[L_HII > 0]),bins=100,alpha=0.5,label='HII',color='b')\\n ax.set_xlabel(getlabel('l'+line))\\n ax.set_ylabel('Number of galaxies')\\n plt.legend()\\n if p.savefig:\\n plt.savefig(p.d_plot + 'luminosity/ISM_lums_%s.png' % line)\",\n \"def param_init_lstm(options, params, prefix='lstm'):\\n W = numpy.concatenate([ortho_weight(options['dim_proj']),\\n ortho_weight(options['dim_proj']),\\n ortho_weight(options['dim_proj']),\\n ortho_weight(options['dim_proj'])], axis=1)\\n params[_p(prefix, 'W')] = W\\n U = numpy.concatenate([ortho_weight(options['dim_proj']),\\n ortho_weight(options['dim_proj']),\\n ortho_weight(options['dim_proj']),\\n ortho_weight(options['dim_proj'])], axis=1)\\n params[_p(prefix, 'U')] = U\\n b = numpy.zeros((4 * options['dim_proj'],))\\n params[_p(prefix, 'b')] = b.astype(config.floatX)\\n\\n return params\",\n \"def modify_lvars(self, *args):\\n return _ida_hexrays.user_lvar_modifier_t_modify_lvars(self, *args)\",\n \"def __init__(self, maxsteps=None, lrate=None, eps=None, verbose=None):\\r\\n\\r\\n self.maxsteps= maxsteps\\r\\n self.lrate = lrate\\r\\n self.nochange= eps\\r\\n\\tself.verbose = verbose\",\n \"def _set_leg_params(self):\\n self.p = 0.01600\\n self.q = 0.00000\\n self.r = 0.02000\\n self.c = 0.01811\\n self.u = 0.00000\\n self.v = 0.00000\\n self.e = -0.06000\\n self.h = -0.02820\\n self.s = 0.02200\\n self.d1 = 0.0\\n self.d2 = 0.0\\n self.d3 = 0.0\\n self.stability = 0.0\",\n \"def lr_setter(optimizer, epoch, args, bl=False):\\n\\n lr = args.lr\\n if bl:\\n lr = args.lrbl * (0.1 ** (epoch // (args.epochb * 0.5)))\\n else:\\n if args.cos:\\n lr *= ((0.01 + math.cos(0.5 * (math.pi * epoch / args.epochs))) / 1.01)\\n else:\\n if epoch >= args.epochs_decay[0]:\\n lr *= 0.1\\n if epoch >= args.epochs_decay[1]:\\n lr *= 0.1\\n for param_group in optimizer.param_groups:\\n param_group['lr'] = lr\",\n \"def get_lamp_specs(self):\\n return {lamp: self._LAMP_SPECS[lamp] for lamp in self._available_lamps}\",\n \"def _define_SLACS_fit_params(self):\\n\\t\\t# Fit params from R_eff\\n\\t\\tself.a = -0.41\\n\\t\\tself.b = 0.39\\n\\t\\t#self.delta_a = 0.12\\n\\t\\t#self.delta_b = 0.10\\n\\t\\tself.intrinsic_scatter = 0.14\\n\\t\\t# Fit params from vel_disp\\n\\t\\tself.a_v = 0.07\\n\\t\\tself.b_v = -0.12\\n\\t\\tself.int_v = 0.17\",\n \"def lammps_parameter_alloy(self, alloy, i=1, j=2):\\n\\n if not isinstance(i, int) or i <= 0:\\n raise TypeError('i must be an integer > 0')\\n if not isinstance(j, int) or j <= i:\\n raise TypeError('j must be an integer > i')\\n\\n contents = f\\\"zbl({i},{j}) = 0\\\\n\\\"\\n contents += f\\\"nn2({i},{j}) = 1\\\\n\\\"\\n contents += f\\\"Ec({i},{j}) = {alloy.Ec:.8g}\\\\n\\\"\\n contents += f\\\"re({i},{j}) = {alloy.Re:.8g}\\\\n\\\"\\n contents += f\\\"alpha({i},{j}) = {alloy.alpha:.15g}\\\\n\\\"\\n contents += f\\\"attrac({i},{j}) = {alloy['d+']:.6g}\\\\n\\\"\\n contents += f\\\"repuls({i},{j}) = {alloy['d-']:.6g}\\\\n\\\"\\n\\n contents += f\\\"Cmin({i},{i},{j}) = {alloy.Cmin_iji:.15g}\\\\n\\\"\\n contents += f\\\"Cmin({j},{j},{i}) = {alloy.Cmin_jij:.15g}\\\\n\\\"\\n contents += f\\\"Cmin({i},{j},{i}) = {alloy.Cmin_iij:.15g}\\\\n\\\"\\n contents += f\\\"Cmin({i},{j},{j}) = {alloy.Cmin_ijj:.15g}\\\\n\\\"\\n contents += f\\\"Cmin({j},{i},{i}) = {alloy.Cmin_iij:.15g}\\\\n\\\"\\n contents += f\\\"Cmin({j},{i},{j}) = {alloy.Cmin_ijj:.15g}\\\\n\\\"\\n\\n contents += f\\\"Cmax({i},{i},{j}) = {alloy.Cmax_iji:.15g}\\\\n\\\"\\n contents += f\\\"Cmax({j},{j},{i}) = {alloy.Cmax_jij:.15g}\\\\n\\\"\\n contents += f\\\"Cmax({i},{j},{i}) = {alloy.Cmax_iij:.15g}\\\\n\\\"\\n contents += f\\\"Cmax({i},{j},{j}) = {alloy.Cmax_ijj:.15g}\\\\n\\\"\\n contents += f\\\"Cmax({j},{i},{i}) = {alloy.Cmax_iij:.15g}\\\\n\\\"\\n contents += f\\\"Cmax({j},{i},{j}) = {alloy.Cmax_ijj:.15g}\\\\n\\\"\\n\\n contents += f\\\"lattce({i},{j}) = '{alloy.lat}'\\\\n\\\"\\n\\n return contents\",\n \"def lj(string):\\n\\n\\tljparams = dict({\\n\\t\\t\\t\\t\\t'lat0' : 5.269,\\t\\t# Lattice constant for argon at 0 K in angstroms\\n\\t\\t\\t\\t\\t'lat20' : 5.315,\\t# Lattice constant for argon at 20 K in angstroms\\n\\t\\t\\t\\t\\t'lat35' : 5.355,\\t# Lattice constant for argon at 35 K in angstroms\\n\\t\\t\\t\\t\\t'lat50' : 5.401,\\t# Lattice constant for argon at 50 K in angstroms\\n\\t\\t\\t\\t\\t'lat65' : 5.455,\\t# Lattice constant for argon at 65 K in angstroms\\n\\t\\t\\t\\t\\t'lat80' : 5.527,\\t# Lattice constant for argon at 80 K in angstroms\\n\\t\\t\\t\\t\\t'epsilon' : 1.67e-21,\\t# Epsilon constant for argon in joules\\n\\t\\t\\t\\t\\t'sigma' : 3.40e-10,\\t# Sigma constant for argon in meters\\n\\t\\t\\t\\t\\t'mass' : 6.63e-26,\\t# Mass constant for argon in kilograms\\n\\t\\t\\t\\t\\t'tau' : 2.14e-12\\t# Tau constant for argon in seconds\\n\\t\\t\\t\\t\\t})\\t\\n\\n\\ttry:\\n\\t\\treturn ljparams[string]\\n\\texcept KeyError, e:\\n\\t\\tprint \\\"KeyError: %s is not a valid key for ntpy.param.lj().\\\" % e\\n\\t\\traise\",\n \"def push_state(self, **lamp_parameters):\\n # Also note that we do not filter out identical states from being pushed.\\n # Since the enabled state can be fiddled with IOTool, there is good reason\\n # for pushing an enabled state identical to the current one, so that it\\n # will be restored after any such fiddling.\\n old_state = {}\\n for prop, value in lamp_parameters.items():\\n getter, setter = self._get_getter_setter(prop)\\n old_state[prop] = getter()\\n setter(value)\\n self._state_stack.append(old_state)\",\n \"def __init__(self,\\r\\n lightpos=(10, -10, 20),\\r\\n lightcol=(1.0, 1.0, 1.0),\\r\\n lightamb=(0.1, 0.1, 0.2)):\\r\\n super(Light, self).__init__()\\r\\n self.lightpos = lightpos\\r\\n self.lightcol = lightcol\\r\\n self.lightamb = lightamb\",\n \"def setMaterialParameters(val, ptype):\\n pdict = {'ambient':'AMBIENT','diffuse':'DIFFUSE','specular':'SPECULAR',\\n 'exponent':'EXPONENT'}\\n dislin.matopt(val, pdict[ptype])\",\n \"def place_headlamp_light():\\n\\n lx = 1.0\\n ly = light_height\\n lz = 2.0\\n #light_position = [lx, ly, lz, 1.0]\\n light_position = [0.0, 0.0, 0.0, 1]\\n light_ambient = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\\n light_diffuse = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\\n light_specular = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\\n light_direction = [1.0, -1.0, 1.0, 0.0] # Light points down\\n # glViewport(0, 0, win_width, win_height)\\n # glMatrixMode(GL_PROJECTION)\\n # glLoadIdentity()\\n # gluPerspective(40.0, float(win_width) / float(win_height), 0.01, 100.0)\\n #\\n # glMatrixMode(GL_MODELVIEW)\\n # glLoadIdentity()\\n # glPushMatrix()\\n glLightfv(GL_LIGHT4, GL_POSITION, light_position)\\n\\n\\n\\n #glLightfv(GL_LIGHT4, GL_POSITION, (GLfloat * 4)(0.0, 0.0, 0.0, 1))\\n glLightfv(GL_LIGHT4, GL_AMBIENT, light_ambient)\\n glLightfv(GL_LIGHT4, GL_DIFFUSE, light_diffuse)\\n glLightfv(GL_LIGHT4, GL_SPECULAR, light_specular)\\n\\n # Constant attenuation (for distance, etc.)\\n # Only works for fixed light locations! Otherwise disabled\\n # glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 2.0)\\n # glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.0)\\n # glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0)\\n\\n glLightf(GL_LIGHT4, GL_CONSTANT_ATTENUATION, 3.0)\\n glLightf(GL_LIGHT4, GL_LINEAR_ATTENUATION, 0.0)\\n glLightf(GL_LIGHT4, GL_QUADRATIC_ATTENUATION, 0.0)\\n\\n # Create a spotlight effect (none at the moment)\\n if headlamp_is_on:\\n glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 30.0)\\n glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 0.0)\\n glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, light_direction)\\n else:\\n glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 180.0)\\n glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 0.0)\\n\\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\\n # Try GL_TRUE - but then watch what happens when light is low\\n\\n glEnable(GL_LIGHT4)\\n\\n # This part draws a SELF-COLORED sphere (in spot where light is!)\\n glPushMatrix()\\n glTranslatef(lx, ly, lz)\\n glDisable(GL_LIGHTING)\\n glColor3f(brightness, brightness, brightness)\\n glutSolidSphere(0.5, 20, 20)\\n glEnable(GL_LIGHTING)\\n glPopMatrix()\",\n \"def setLCData(*args):\\n args[0].Data.LCData.lc_data = args[1]\",\n \"def flicker_lights(self):\\n print 'Lights Set'\",\n \"def pointLight(*args, decayRate: Union[int, bool]=0, discRadius: Union[float, bool]=0.0,\\n exclusive: bool=True, intensity: Union[float, bool]=0.0, name: Union[AnyStr,\\n bool]=\\\"\\\", position: Union[List[float, float, float], bool]=None, rgb:\\n Union[List[float, float, float], bool]=None, rotation: Union[List[float, float,\\n float], bool]=None, shadowColor: Union[List[float, float, float], bool]=None,\\n shadowDither: Union[float, bool]=0.0, shadowSamples: Union[int, bool]=0,\\n softShadow: bool=True, useRayTraceShadows: bool=True, q=True, query=True, e=True,\\n edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def load_ltm(self, **kwargs):\\r\\n ltm = kwargs['ltm']\\r\\n\\r\\n self.ltm = LTM(ltm)\\r\\n self.ltm.label_ltm(self.hwlist)\",\n \"def main():\\n logging.info(\\\"Starting mLamp Driver\\\")\\n\\n temperature = read_temperature()\\n temp_progress = interpolate_temperature(temperature)\\n color = color_interpolate_map(color_map, temp_progress)\\n\\n logging.info(\\\"Temperature is: {}C, final color will be: {}\\\".format(temperature, color))\\n\\n while True:\\n now = datetime.datetime.now()\\n is_alarm_hour = alarm_start_hour <= now.hour <= alarm_stop_hour\\n is_alarm_minute = alarm_start_minute <= now.minute <= alarm_stop_minute\\n\\n if is_alarm_hour and is_alarm_minute:\\n time_progress = current_time() / alarm_length()\\n\\n final_color = color_interpolate_fade_in(color, time_progress)\\n logging.debug(\\\"Setting color to: {}\\\".format(final_color))\\n\\n lamp_set_color(final_color)\\n\\n sleep(10)\\n elif now.hour > alarm_stop_hour and now.minute > alarm_stop_minute:\\n # don't forget to turn the lamps off when the time comes\\n lamp_set_color((0, 0, 0))\\n break\\n else:\\n sleep(60)\\n\\n logging.info(\\\"Stopping mLamp Driver\\\")\",\n \"def multi_gaussian_lens_light(self, kwargs_lens_light, n_comp=20):\\n r_h = self.half_light_radius_lens(kwargs_lens_light)\\n r_array = np.logspace(-3, 2, 200) * r_h * 2\\n #r_array = np.logspace(-2, 1, 50) * r_h\\n flux_r = self._lens_light_internal(r_array, np.zeros_like(r_array), kwargs_lens_light)\\n amplitudes, sigmas, norm = mge.mge_1d(r_array, flux_r, N=n_comp)\\n return amplitudes, sigmas\",\n \"def setMyColorTable(lr,lg,lb):\\n dislin.myvlt(lr,lg,lb,len(lr))\",\n \"def set_shape_params(self, params):\\n self.alpha = params[0]\\n self.beta = params[1]\\n self.gamma = params[2]\\n self.c500 = params[3]\\n self.P0 = params[4]\",\n \"def __init__(self, l=1, sigmaf=1, sigman=1e-6, bounds=None, parameters=['l', 'sigmaf', 'sigman']):\\n\\n self.l = l\\n self.sigmaf = sigmaf\\n self.sigman = sigman\\n self.parameters = parameters\\n if bounds is not None:\\n self.bounds = bounds\\n else:\\n self.bounds = []\\n for param in self.parameters:\\n self.bounds.append(default_bounds[param])\",\n \"def update_multiple_parameters(self, detuning=None, lamb_dicke=None,\\n base_rabi=None):\\n if detuning is not None:\\n self.__detuning = detuning\\n if lamb_dicke is not None:\\n self.__lamb_dicke = lamb_dicke\\n if base_rabi is not None:\\n self.__base_rabi = base_rabi\\n if detuning is None and lamb_dicke is None and base_rabi is None:\\n return\\n self.__update_prefactors()\",\n \"def __init__(self, l=1, sigmaf=1, sigman=1e-6, bounds=None, parameters=['l', 'sigmaf', 'sigman']):\\n self.l = l\\n self.sigmaf = sigmaf\\n self.sigman = sigman\\n self.parameters = parameters\\n if bounds is not None:\\n self.bounds = bounds\\n else:\\n self.bounds = []\\n for param in self.parameters:\\n self.bounds.append(default_bounds[param])\",\n \"def lamp_set_color(color):\\n addresses = lamp_addresses\\n\\n r = hex(color[0])[2:].zfill(2)\\n g = hex(color[1])[2:].zfill(2)\\n b = hex(color[2])[2:].zfill(2)\\n\\n # the 01 here at the beginning of the message means that\\n # the lamp will hold the color even when the connection is lost\\n value = \\\"01\\\" + r + g + b\\n\\n for address in addresses:\\n command = \\\"gatttool -b {} -t random --char-write --handle=0x0011 --value={}\\\".format(address, value)\\n logging.debug(\\\"Sending command to RFduino: \\\" + command)\\n os.system(command)\",\n \"def setHsl ( self, h, s = 0.0, l = 0.0 ):\\n self.setHsla( h, s, l )\",\n \"def __init__(self, L_values=None, scatteringRadius=None, **kwargs):\\n index = 0\\n for attr in self.optAttrList:\\n setattr(self, attr, kwargs.get(attr))\\n self.L_values = L_values or []\\n self.scatteringRadius = scatteringRadius\\n if self.scatteringRadius: self.scatteringRadius.setAncestor( self )\",\n \"def log_xlnet_params(local_dict):\\n params = [\\\"DATA_FOLDER\\\",\\\"XLNET_CACHE_DIR\\\",\\\"LANGUAGE\\\",\\\"MAX_SEQ_LENGTH\\\",\\\"BATCH_SIZE\\\",\\\"NUM_GPUS\\\",\\n \\\"NUM_EPOCHS\\\",\\\"TRAIN_SIZE\\\",\\\"LABEL_COL\\\",\\\"TEXT_COL\\\",\\\"LEARNING_RATE\\\",\\\"WEIGHT_DECAY\\\",\\n \\\"ADAM_EPSILON\\\",\\\"WARMUP_STEPS\\\",\\\"DEBUG\\\"]\\n for i in params:\\n log_param(i,local_dict[i])\\n return\",\n \"def __init__(self, l=1, sigmaf=1.0, sigman=1e-6, bounds=None, parameters=['l', 'sigmaf',\\n 'sigman']):\\n self.l = l\\n self.sigmaf = sigmaf\\n self.sigman = sigman\\n self.parameters = parameters\\n if bounds is not None:\\n self.bounds = bounds\\n else:\\n self.bounds = []\\n for param in self.parameters:\\n self.bounds.append(default_bounds[param])\",\n \"def __init__(\\n self,\\n lca_layer: LCALayer,\\n num_lca_dim: int,\\n num_simulations: int = 10000,\\n num_time_steps: int = 3000,\\n ):\\n\\n super().__init__()\\n\\n self.lca_layer = lca_layer\\n self.num_lca_dim = num_lca_dim\\n self.num_simulations = num_simulations\\n self.num_time_steps = num_time_steps\",\n \"def export_lights(lamps, file, scene, global_matrix, tab_write):\\n\\n from .render import write_matrix, tab_write\\n\\n # Incremented after each lamp export to declare its target\\n # currently used for Fresnel diffuse shader as their slope vector:\\n global exported_lights_count\\n # Get all lamps and keep their count in a global variable\\n for exported_lights_count, ob in enumerate(lamps, start=1):\\n lamp = ob.data\\n\\n matrix = global_matrix @ ob.matrix_world\\n\\n # Color is no longer modified by energy\\n # any way to directly get bpy_prop_array as tuple?\\n color = tuple(lamp.color)\\n\\n tab_write(file, \\\"light_source {\\\\n\\\")\\n tab_write(file, \\\"< 0,0,0 >\\\\n\\\")\\n tab_write(file, \\\"color srgb<%.3g, %.3g, %.3g>\\\\n\\\" % color)\\n\\n if lamp.type == \\\"POINT\\\":\\n pass\\n elif lamp.type == \\\"SPOT\\\":\\n tab_write(file, \\\"spotlight\\\\n\\\")\\n\\n # Falloff is the main radius from the centre line\\n tab_write(file, \\\"falloff %.2f\\\\n\\\" % (degrees(lamp.spot_size) / 2.0)) # 1 TO 179 FOR BOTH\\n tab_write(\\n file, \\\"radius %.6f\\\\n\\\" % ((degrees(lamp.spot_size) / 2.0) * (1.0 - lamp.spot_blend))\\n )\\n\\n # Blender does not have a tightness equivalent, 0 is most like blender default.\\n tab_write(file, \\\"tightness 0\\\\n\\\") # 0:10f\\n\\n tab_write(file, \\\"point_at <0, 0, -1>\\\\n\\\")\\n if lamp.pov.use_halo:\\n tab_write(file, \\\"looks_like{\\\\n\\\")\\n tab_write(file, \\\"sphere{<0,0,0>,%.6f\\\\n\\\" % lamp.distance)\\n tab_write(file, \\\"hollow\\\\n\\\")\\n tab_write(file, \\\"material{\\\\n\\\")\\n tab_write(file, \\\"texture{\\\\n\\\")\\n tab_write(file, \\\"pigment{rgbf<1,1,1,%.4f>}\\\\n\\\" % (lamp.pov.halo_intensity * 5.0))\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"interior{\\\\n\\\")\\n tab_write(file, \\\"media{\\\\n\\\")\\n tab_write(file, \\\"emission 1\\\\n\\\")\\n tab_write(file, \\\"scattering {1, 0.5}\\\\n\\\")\\n tab_write(file, \\\"density{\\\\n\\\")\\n tab_write(file, \\\"spherical\\\\n\\\")\\n tab_write(file, \\\"color_map{\\\\n\\\")\\n tab_write(file, \\\"[0.0 rgb <0,0,0>]\\\\n\\\")\\n tab_write(file, \\\"[0.5 rgb <1,1,1>]\\\\n\\\")\\n tab_write(file, \\\"[1.0 rgb <1,1,1>]\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n tab_write(file, \\\"}\\\\n\\\")\\n elif lamp.type == \\\"SUN\\\":\\n tab_write(file, \\\"parallel\\\\n\\\")\\n tab_write(file, \\\"point_at <0, 0, -1>\\\\n\\\") # *must* be after 'parallel'\\n\\n elif lamp.type == \\\"AREA\\\":\\n tab_write(file, \\\"fade_distance %.6f\\\\n\\\" % (lamp.distance / 2.0))\\n # Area lights have no falloff type, so always use blenders lamp quad equivalent\\n # for those?\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 2)\\n size_x = lamp.size\\n samples_x = lamp.pov.shadow_ray_samples_x\\n if lamp.shape == \\\"SQUARE\\\":\\n size_y = size_x\\n samples_y = samples_x\\n else:\\n size_y = lamp.size_y\\n samples_y = lamp.pov.shadow_ray_samples_y\\n\\n tab_write(\\n file,\\n \\\"area_light <%.6f,0,0>,<0,%.6f,0> %d, %d\\\\n\\\"\\n % (size_x, size_y, samples_x, samples_y),\\n )\\n tab_write(file, \\\"area_illumination\\\\n\\\")\\n if lamp.pov.shadow_ray_sample_method == \\\"CONSTANT_JITTERED\\\":\\n if lamp.pov.use_jitter:\\n tab_write(file, \\\"jitter\\\\n\\\")\\n else:\\n tab_write(file, \\\"adaptive 1\\\\n\\\")\\n tab_write(file, \\\"jitter\\\\n\\\")\\n\\n # No shadow checked either at global or light level:\\n if not scene.pov.use_shadows or (lamp.pov.shadow_method == \\\"NOSHADOW\\\"):\\n tab_write(file, \\\"shadowless\\\\n\\\")\\n\\n # Sun shouldn't be attenuated. Area lights have no falloff attribute so they\\n # are put to type 2 attenuation a little higher above.\\n if lamp.type not in {\\\"SUN\\\", \\\"AREA\\\"}:\\n if lamp.falloff_type == \\\"INVERSE_SQUARE\\\":\\n tab_write(file, \\\"fade_distance %.6f\\\\n\\\" % (sqrt(lamp.distance / 2.0)))\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 2) # Use blenders lamp quad equivalent\\n elif lamp.falloff_type == \\\"INVERSE_LINEAR\\\":\\n tab_write(file, \\\"fade_distance %.6f\\\\n\\\" % (lamp.distance / 2.0))\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 1) # Use blenders lamp linear\\n elif lamp.falloff_type == \\\"CONSTANT\\\":\\n tab_write(file, \\\"fade_distance %.6f\\\\n\\\" % (lamp.distance / 2.0))\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 3)\\n # Use blenders lamp constant equivalent no attenuation.\\n # Using Custom curve for fade power 3 for now.\\n elif lamp.falloff_type == \\\"CUSTOM_CURVE\\\":\\n tab_write(file, \\\"fade_power %d\\\\n\\\" % 4)\\n\\n write_matrix(file, matrix)\\n\\n tab_write(file, \\\"}\\\\n\\\")\\n\\n # v(A,B) rotates vector A about origin by vector B.\\n file.write(\\n \\\"#declare lampTarget%s= vrotate(<%.4g,%.4g,%.4g>,<%.4g,%.4g,%.4g>);\\\\n\\\"\\n % (\\n exported_lights_count,\\n -ob.location.x,\\n -ob.location.y,\\n -ob.location.z,\\n ob.rotation_euler.x,\\n ob.rotation_euler.y,\\n ob.rotation_euler.z,\\n )\\n )\",\n \"def experiment_linear_l1(_):\\n # Attack epsilon is manually set according to the norm of the min-norm\\n # solution found using cvxpy for d/n=10. That is max-margin=1/min-norm.\\n # Min linf-norm solution found (norm=0.0422)\\n # Min l2-norm solution found (norm=0.3411)\\n # Min l1-norm solution found (norm=1.8497)\\n # Min l4-norm solution found (norm=0.0002)\\n # Min l1.5-norm solution found (norm=0.5274)\\n return experiment_linear_lp(\\n adv_norm_type='l1',\\n dual_norm_type='linf',\\n baseline_norm_types=['l2'],\\n attack_step_dir='grad_max')\",\n \"def test_pass_through_lcoe_args():\\n year = 2012\\n rev2_points = slice(0, 3)\\n res_file = os.path.join(TESTDATADIR, 'wtk/ri_100_wtk_{}.h5'.format(year))\\n sam_files = os.path.join(TESTDATADIR, 'SAM/i_windpower_lcoe.json')\\n\\n output_request = ('cf_mean',\\n 'lcoe_fcr',\\n 'capital_cost',\\n 'fixed_charge_rate',\\n 'variable_operating_cost',\\n 'fixed_operating_cost')\\n\\n # run reV 2.0 generation\\n gen = Gen.reV_run(tech='windpower', points=rev2_points,\\n sam_files=sam_files, res_file=res_file, max_workers=1,\\n sites_per_worker=1, fout=None,\\n output_request=output_request)\\n\\n checks = [x in gen.out for x in Gen.LCOE_ARGS]\\n assert all(checks)\\n assert 'lcoe_fcr' in gen.out\\n assert 'cf_mean' in gen.out\",\n \"def lms(options):\\r\\n settings = getattr(options, 'settings', None)\\r\\n port = getattr(options, 'port', None)\\r\\n fast = getattr(options, 'fast', False)\\r\\n run_server('lms', settings=settings, port=port, skip_assets=fast)\",\n \"def __init__(self, data=None, lambtha=1.):\\n if data is None:\\n if lambtha <= 0:\\n raise ValueError('lambtha must be a positive value')\\n else:\\n self.lambtha = float(lambtha)\\n else:\\n if not isinstance(data, list):\\n raise TypeError('data must be a list')\\n else:\\n num_of_elements = len(data)\\n if num_of_elements < 2:\\n raise ValueError('data must contain multiple values')\\n else:\\n self.lambtha = sum(data) / num_of_elements\",\n \"def set_lbda(self, lbda, derive_mag=True, negative_fluxmag=None):\\n self._properties[\\\"lbda\\\"] = lbda\\n if derive_mag:\\n self.derive_magsamples(negative_fluxmag=negative_fluxmag)\",\n \"def update_linear_kwargs(self, param, kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps):\\n kwargs_lens_i, kwargs_source_i, kwargs_lens_light_i, kwargs_ps_i, kwargs_extinction_i = self.select_kwargs(\\n kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, kwargs_extinction=None)\\n return self._update_linear_kwargs(param, kwargs_lens_i, kwargs_source_i, kwargs_lens_light_i, kwargs_ps_i)\",\n \"def set_params(**kwargs):\\n\\t\\tif \\\"study\\\" in kwargs.keys():\\n\\t\\t\\traise TypeError(\\\"Got an unexpected keyword argument: 'study'\\\")\\n\\t\\telse:\\n\\t\\t\\tfor i in range(len(_RECOGNIZED_ELEMENTS_)):\\n\\t\\t\\t\\t__settings[_RECOGNIZED_ELEMENTS_[i]] = __fractional(\\n\\t\\t\\t\\t\\t_RECOGNIZED_ELEMENTS_[i], study = \\\"LC18\\\", **kwargs)[0]\",\n \"def run_slam(src_dir, log_dir, idx, split):\\n slam = slam_t(resolution=0.05, Q=np.diag([2e-4,2e-4,1e-4]))\\n slam.read_data(src_dir, idx, split)\\n T = len(slam.lidar) \\n \\n \\n \\n # again initialize the map to enable calculation of the observation logp in\\n # future steps, this time we want to be more careful and initialize with the\\n # correct lidar scan. First find the time t0 around which we have both LiDAR\\n # data and joint data \\n \\n t0 = max(slam.find_joint_t_idx_from_lidar(0), 0) \\n \\n odo = [] \\n for t in range(t0+1, T): \\n odo.append(slam.lidar[t][\\\"xyth\\\"]) \\n odo = np.array(odo).T\\n odo_grid = slam.map.grid_cell_from_xy(odo[0], odo[1])\\n \\n #initialize one particle \\n xyth = slam.lidar[t0]['xyth']\\n xyth[2] = slam.lidar[t0]['rpy'][2]\\n logging.debug('> Initializing 1 particle at: {}'.format(xyth))\\n slam.init_particles(n=1,p=xyth.reshape((3,1)),w=np.array([1]))\\n slam.observation_step(t=t0) \\n #intialize 100 particls \\n\\n logging.info('> Particles\\\\n: {}'.format(slam.p))\\n logging.info('> Weights: {}'.format(slam.w))\\n slam.init_particles(n=100,p=np.zeros((3,100), dtype=np.float64), w=np.full((100, ), 1./100)) \\n\\n color_dict = {\\n \\\"gray\\\": np.array([.5, .5, .5]), \\n \\\"white\\\": np.array([1., 1., 1.]),\\n \\\"black\\\": np.array([0., 0., 0.])\\n }\\n \\n #Run the SLAM\\n max_particles = [] \\n color_map = np.zeros((slam.map.szx, slam.map.szy, 3)) \\n for t in tqdm.tqdm(range(t0+1,T)): \\n slam.dynamics_step(t)\\n max_particle = slam.observation_step(t) \\n max_particle_grid = slam.map.grid_cell_from_xy(np.array(max_particle[0]).reshape(1, 1), np.array(max_particle[1]).reshape(1, 1)) \\n max_particles.append(np.squeeze(max_particle_grid)) \\n color_map[slam.map.num_obs_per_cell == 0] = color_dict[\\\"gray\\\"]\\n color_map[slam.map.num_obs_per_cell > 0] = color_dict[\\\"white\\\"]\\n color_map[slam.map.cells == 1] = color_dict[\\\"black\\\"]\\n #plot every thousand iterations \\n if t % 1000 == 0:\\n plt.figure(figsize=(20, 20)) \\n plt.imshow(color_map)\\n plot_particles = np.array(max_particles).T \\n plt.scatter(x=odo_grid[1, t0+1:t], y=odo_grid[0,t0+1:t], c='b', s=5)\\n plt.scatter(x=plot_particles[1], y=plot_particles[0], c='r', s=5)\\n plt.draw()\\n plt.pause(0.0001) \\n\\n max_particles = np.array(max_particles).T \\n\\n fig = plt.figure(figsize=(20, 20)); plt.clf(); \\n plt.imshow(color_map) \\n plt.scatter(x=max_particles[1], y=max_particles[0], c='r', s=5) \\n plt.scatter(x=odo_grid[1], y=odo_grid[0], c='b', s=5) \\n plt.title('Particle Filter Occupancy Map')\\n logging.info('> Saving plot in '+os.path.join(log_dir, 'slam_full%s_%02d.jpg'%(split, idx)))\\n plt.savefig(os.path.join(log_dir, \\\"slam_output_\\\" + str(idx) + \\\".jpg\\\"))\",\n \"def set_landscape_params(landscape, params):\\n if landscape == \\\"L\\\":\\n Lowland.set_params(params)\\n elif landscape == \\\"H\\\":\\n Highland.set_params(params)\\n else:\\n raise ValueError(\\\"Only params in Lowland and Highland can be changed! No params set.\\\")\",\n \"def __init__(self, hass, lj, i, name):\\n self._hass = hass\\n self._lj = lj\\n self._index = i\\n self._brightness = 0\\n self._name = name\\n\\n lj.on_load_activated(i, self._on_load_changed)\\n lj.on_load_deactivated(i, self._on_load_changed)\",\n \"def set_lam_kld_l1l2(self, lam_kld_l1l2=1.0):\\n zero_ary = np.zeros((1,))\\n new_val = zero_ary + lam_kld_l1l2\\n self.lam_kld_l1l2.set_value(to_fX(new_val))\\n return\",\n \"def lsits(self) -> List[LsitsParam]:\\n return self._lsits\",\n \"def set_laser_power(self, power: int):\\n self.logger.info(f'Setting laser power to {power}')\\n power = int(power)\\n if power <= 1:\\n self.electronics.servo = 0\\n else:\\n self.electronics.servo = 1\\n\\n self.electronics.laser_power = power\\n self.config['laser']['power'] = power\",\n \"def set_light_mode(self, is_lid):\\n raise NotImplementedError()\",\n \"def set_parameters(self, **kwargs):\\n self.__multi_layer_perceptron.set_params(**kwargs)\",\n \"def create_lamp(self,lamp_id,section_id, section, phase_id):\\r\\n \\r\\n self.lamps[lamp_id]=(section_id,phase_id)\\r\\n\\r\\n self.lane_groups[phase_id].append(section)\\r\\n \\r\\n return (section_id,phase_id)\",\n \"def set_values(self,\\n name: Optional[str] = None,\\n **kwargs: any):\\n\\n if 'potential' in kwargs:\\n assert 'potential_key' not in kwargs\\n assert 'potential_id' not in kwargs\\n assert 'potential_LAMMPS_key' not in kwargs\\n assert 'potential_LAMMPS_id' not in kwargs\\n self.potential_key = kwargs['potential'].potkey\\n self.potential_id = kwargs['potential'].potid\\n self.potential_LAMMPS_key = kwargs['potential'].key\\n self.potential_LAMMPS_id = kwargs['potential'].id\\n else:\\n if 'potential_key' in kwargs:\\n self.potential_key = kwargs['potential_key']\\n if 'potential_id' in kwargs:\\n self.potential_id = kwargs['potential_id']\\n if 'potential_LAMMPS_key' in kwargs:\\n self.potential_LAMMPS_key = kwargs['potential_LAMMPS_key']\\n if 'potential_LAMMPS_id' in kwargs:\\n self.potential_LAMMPS_id = kwargs['potential_LAMMPS_id']\\n\\n if name is None:\\n if self.potential_LAMMPS_id is not None:\\n self.name = f'props.{self.potential_LAMMPS_id}.{self.potential_key[:8]}'\",\n \"def initializeParameters(self):\\r\\n\\t\\tself.input_raster.enabled = True\\r\\n\\t\\tself.approach.enabled = True\\r\\n\\t\\tself.predefined_pattern.enabled = False\\r\\n\\t\\tself.predefined_pattern.value = 'Mexican Hat wavelet'\\r\\n\\t\\tself.pattern_workspace.enabled = False\\r\\n\\t\\tself.point_matrix_size.enabled = False\\r\\n\\t\\tself.point_matrix_size.value = 3\\r\\n\\t\\tself.point_vectors.enabled = False\\r\\n\\t\\tself.mapping_field.enabled = False\\r\\n\\t\\tself.move_to_max.enabled = False\\r\\n\\t\\tself.move_to_max_distance.enabled = False\\r\\n\\t\\tself.move_to_max_distance.value = 3\\r\\n\\t\\tself.mh_iteration.enabled = False\\r\\n\\t\\tself.mh_dil_val.enabled = False\\r\\n\\t\\tself.mh_dil_val.value = 1\\r\\n\\t\\tself.mh_dil_start.value = 0.01\\r\\n\\t\\tself.mh_dil_stop.value = 1\\r\\n\\t\\tself.mh_dil_step.value = 0.1\\r\\n\\t\\tself.mh_dil_start.enabled = False\\r\\n\\t\\tself.mh_dil_stop.enabled = False\\r\\n\\t\\tself.mh_dil_step.enabled = False\\r\\n\\t\\tself.transform.enabled = False\\r\\n\\t\\tself.size_of_the_cell.enabled = False\\r\\n\\t\\tself.size_of_the_cell.value = 1\\r\\n\\t\\tself.output_sim_matrix.enabled = False\\r\\n\\t\\tself.output_table.enabled = False\\r\\n\\t\\tself.output_raster_workspace.enabled = False\",\n \"def __init__(self, lr=1e-3, C=1.0, iterations=10):\\n\\n self.lr = lr\\n self.lam = C\\n self.iterations = iterations\",\n \"def configure_plotcamlite():\\r\\n\\r\\n # command line argument parsing\\r\\n parser = ArgumentParser(\\r\\n prog=\\\"python plotcam-lite.py\\\",\\r\\n description=\\\"PlotCamLite (April 2021). Realtime plot monitoring system. By Rua'a Abdulmajeed for AAFC Phenom Corp\\\")\\r\\n\\r\\n\\r\\n # running on headset or not\\r\\n parser.add_argument(\\r\\n '-m', '--monitor',\\r\\n dest=\\\"monitor\\\",\\r\\n action='store_true',\\r\\n help=\\\"add this option for it to format properly on a monitor\\\",\\r\\n )\\r\\n\\r\\n # change stream resolution\\r\\n parser.add_argument(\\r\\n '-res',\\r\\n dest=\\\"res\\\",\\r\\n type=int,\\r\\n default=1280,\\r\\n choices=[1280, 640],\\r\\n help=\\\"change the stream's resolution, either 1280x720(default) or 640x480\\\",\\r\\n )\\r\\n\\r\\n # change the stream fps\\r\\n parser.add_argument(\\r\\n '-fps',\\r\\n dest=\\\"fps\\\",\\r\\n type=int,\\r\\n default=30,\\r\\n choices=[15, 30],\\r\\n help=\\\"set the stream's fps, either 15 or 30\\\",\\r\\n )\\r\\n\\r\\n # Log Level\\r\\n parser.add_argument(\\r\\n '-l', '--log',\\r\\n dest=\\\"log_level\\\",\\r\\n type=str,\\r\\n default=None,\\r\\n choices=[\\\"debug\\\", \\\"info\\\", \\\"warning\\\", \\\"error\\\"],\\r\\n help=\\\"specify level of logging, defaults to no logging\\\",\\r\\n )\\r\\n\\r\\n args = parser.parse_args()\\r\\n\\r\\n # handle monitor view \\r\\n pcl_config[\\\"monitor\\\"] = args.monitor\\r\\n if pcl_config[\\\"monitor\\\"]:\\r\\n pcl_config[\\\"main_window_ui_path\\\"] = os.path.join(PCL_SRC_PATH, \\\"resources\\\", \\\"ui\\\", \\\"PlotCamLiteUI_monitor.ui\\\")\\r\\n \\r\\n # handle fps\\r\\n pcl_config[\\\"stream_fps\\\"] = args.fps\\r\\n\\r\\n # handle resolution\\r\\n pcl_config[\\\"stream_height\\\"] = args.res\\r\\n pcl_config[\\\"stream_width\\\"] = resolution_width[pcl_config[\\\"stream_height\\\"]]\\r\\n\\r\\n # handle logging\\r\\n configure_logging(log_level=args.log_level, log_fpath=os.path.join(PCL_SRC_PATH, LOG_FILENAME))\\r\\n\\r\\n # create the main path directory\\r\\n if not os.path.exists(PCL_EXP_PATH):\\r\\n os.makedirs(PCL_EXP_PATH)\",\n \"def reset(self, l11=None, l12=None, l13=None, l21=None, l22=None, l23=None):\\n self.l11 = np.random.uniform(self.l1min, self.l1max) if l11 == None else l11\\n self.l12 = np.random.uniform(self.l1min, self.l1max) if l12 == None else l12\\n self.l13 = np.random.uniform(self.l1min, self.l1max) if l13 == None else l13\\n self.l21 = np.random.uniform(self.l2min, self.l2max) if l21 == None else l21\\n self.l22 = np.random.uniform(self.l2min, self.l2max) if l22 == None else l22\\n self.l23 = np.random.uniform(self.l2min, self.l2max) if l23 == None else l23\\n # after resetting tendon lengths, variables need to be updated\\n self.goal = self.get_goal()\\n self.done = False\\n self.update_variables()\",\n \"def initialize(self, n_samples=1, kl_scaling=None, *args, **kwargs):\\n if kl_scaling is None:\\n kl_scaling = {}\\n if n_samples <= 0:\\n raise ValueError(\\n \\\"n_samples should be greater than zero: {}\\\".format(n_samples))\\n\\n self.n_samples = n_samples\\n self.kl_scaling = kl_scaling\\n return super(elbo_optimizer, self).initialize(*args, **kwargs)\",\n \"def test_plasma_with_laser(cet_plasma, cet_param):\\n # test constructor with no bubble_radius and given propagation_distance\\n _ = Plasma(\\n n_pe=cet_param.npe,\\n laser=cet_plasma.laser,\\n propagation_distance=13.56555928 * u.mm,\\n )\\n\\n assert_allclose_units(cet_plasma.Pc, 19.7422087 * u.terawatt)\\n assert_allclose_units(cet_plasma.depletion, 13.92603593 * u.mm)\\n assert_allclose_units(cet_plasma.dephasing, 13.56555928 * u.mm)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6750617","0.64525014","0.60727084","0.60697347","0.5997909","0.58803946","0.57326317","0.57204014","0.56676894","0.5609716","0.56088686","0.5593763","0.5560277","0.5505796","0.5471875","0.54498017","0.5446686","0.54387254","0.543406","0.5431726","0.54065436","0.5382543","0.5337909","0.5310714","0.5290918","0.52745044","0.5271817","0.5255404","0.5252665","0.52376324","0.5225115","0.5175354","0.517013","0.5149188","0.5132235","0.5130627","0.5128313","0.51194364","0.5114164","0.5111462","0.5071508","0.506353","0.5058675","0.5050866","0.50477904","0.50388986","0.50110906","0.5008012","0.49925542","0.49657157","0.4959208","0.49585912","0.49566066","0.495287","0.4948162","0.4938445","0.49290967","0.49219826","0.4914461","0.4913795","0.48981777","0.48959658","0.48790178","0.486751","0.48615566","0.4849718","0.48360795","0.4821727","0.48196253","0.48169082","0.48162907","0.48154926","0.48048204","0.48038682","0.48026457","0.47934663","0.47918248","0.47900406","0.4789349","0.47889605","0.47805503","0.47637543","0.4763597","0.47598317","0.47585148","0.47471693","0.47457668","0.47422355","0.47405344","0.47394305","0.47378927","0.4724259","0.47136283","0.46966428","0.46965638","0.4683966","0.46705535","0.466487","0.46637207","0.46628004"],"string":"[\n \"0.6750617\",\n \"0.64525014\",\n \"0.60727084\",\n \"0.60697347\",\n \"0.5997909\",\n \"0.58803946\",\n \"0.57326317\",\n \"0.57204014\",\n \"0.56676894\",\n \"0.5609716\",\n \"0.56088686\",\n \"0.5593763\",\n \"0.5560277\",\n \"0.5505796\",\n \"0.5471875\",\n \"0.54498017\",\n \"0.5446686\",\n \"0.54387254\",\n \"0.543406\",\n \"0.5431726\",\n \"0.54065436\",\n \"0.5382543\",\n \"0.5337909\",\n \"0.5310714\",\n \"0.5290918\",\n \"0.52745044\",\n \"0.5271817\",\n \"0.5255404\",\n \"0.5252665\",\n \"0.52376324\",\n \"0.5225115\",\n \"0.5175354\",\n \"0.517013\",\n \"0.5149188\",\n \"0.5132235\",\n \"0.5130627\",\n \"0.5128313\",\n \"0.51194364\",\n \"0.5114164\",\n \"0.5111462\",\n \"0.5071508\",\n \"0.506353\",\n \"0.5058675\",\n \"0.5050866\",\n \"0.50477904\",\n \"0.50388986\",\n \"0.50110906\",\n \"0.5008012\",\n \"0.49925542\",\n \"0.49657157\",\n \"0.4959208\",\n \"0.49585912\",\n \"0.49566066\",\n \"0.495287\",\n \"0.4948162\",\n \"0.4938445\",\n \"0.49290967\",\n \"0.49219826\",\n \"0.4914461\",\n \"0.4913795\",\n \"0.48981777\",\n \"0.48959658\",\n \"0.48790178\",\n \"0.486751\",\n \"0.48615566\",\n \"0.4849718\",\n \"0.48360795\",\n \"0.4821727\",\n \"0.48196253\",\n \"0.48169082\",\n \"0.48162907\",\n \"0.48154926\",\n \"0.48048204\",\n \"0.48038682\",\n \"0.48026457\",\n \"0.47934663\",\n \"0.47918248\",\n \"0.47900406\",\n \"0.4789349\",\n \"0.47889605\",\n \"0.47805503\",\n \"0.47637543\",\n \"0.4763597\",\n \"0.47598317\",\n \"0.47585148\",\n \"0.47471693\",\n \"0.47457668\",\n \"0.47422355\",\n \"0.47405344\",\n \"0.47394305\",\n \"0.47378927\",\n \"0.4724259\",\n \"0.47136283\",\n \"0.46966428\",\n \"0.46965638\",\n \"0.4683966\",\n \"0.46705535\",\n \"0.466487\",\n \"0.46637207\",\n \"0.46628004\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7872269"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":815,"numItemsPerPage":100,"numTotalItems":95772,"offset":81500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjE3NjE5NywianRpIjoiNTE1ZmQwMDktNTRkNi00OWJlLWEyMDktYzU5YzFmOTY4YjI1Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYxNzk3OTcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.cq5mblInlr_uBhoaw_iSYIQulfz3HNtCooLMPEhLFi58Qh8avp1lsw0ZK2uY3VSzqU7xSMxi5pCmqPhVVp5vBA","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 |
|---|---|---|---|---|---|---|
Test the failure of the function for returning the desired residue data container. The function tested is pipe_control.mol_res_spin.return_residue(). | def test_return_residue_pipe_fail(self):
# Try to get a residue from a missing data pipe.
self.assertRaises(RelaxNoPipeError, mol_res_spin.return_residue, selection=':2', pipe='new') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_return_residue(self):\n\n # Ask for a few residues.\n res1 = mol_res_spin.return_residue(':1')\n res2 = mol_res_spin.return_residue(selection=':2')\n res4 = mol_res_spin.return_residue(selection=':4', pipe='orig')\n res5 = mol_res_spin.return_residue(selection='#RNA:-5',... | [
"0.8170825",
"0.738827",
"0.7088673",
"0.6640738",
"0.64614236",
"0.6410077",
"0.6326799",
"0.628192",
"0.6172335",
"0.6162224",
"0.61231905",
"0.60759443",
"0.6006672",
"0.59830487",
"0.5976972",
"0.588619",
"0.58454573",
"0.5789694",
"0.56599325",
"0.55045515",
"0.5500338",... | 0.748504 | 1 |
Test the function for returning the desired residue data container. The function tested is pipe_control.mol_res_spin.return_single_residue_info(). | def test_return_single_residue_info(self):
# Ask for a few residues.
res1 = mol_res_spin.return_single_residue_info('1')
res2 = mol_res_spin.return_single_residue_info('2,Glu')
res4 = mol_res_spin.return_single_residue_info('Pro,4')
res5 = mol_res_spin.return_single_residue_info... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_return_residue(self):\n\n # Ask for a few residues.\n res1 = mol_res_spin.return_residue(':1')\n res2 = mol_res_spin.return_residue(selection=':2')\n res4 = mol_res_spin.return_residue(selection=':4', pipe='orig')\n res5 = mol_res_spin.return_residue(selection='#RNA:-5',... | [
"0.7970382",
"0.7181199",
"0.6772322",
"0.61946106",
"0.618991",
"0.60239536",
"0.59026784",
"0.5900764",
"0.5900667",
"0.5892051",
"0.57719076",
"0.5698098",
"0.56888527",
"0.5679066",
"0.5602712",
"0.55790323",
"0.55473787",
"0.55005234",
"0.5484408",
"0.544164",
"0.542363"... | 0.8470204 | 0 |
Test the failure of the function for returning the desired residue data container. The function tested is pipe_control.mol_res_spin.return_single_residue_info(). | def test_return_single_residue_info_fail(self):
# Ask for a few residues.
self.assertRaises(RelaxError, mol_res_spin.return_single_residue_info, '1,2')
self.assertRaises(RelaxError, mol_res_spin.return_single_residue_info, '1,Glu,Pro')
self.assertRaises(RelaxError, mol_res_spin.return_s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_return_single_residue_info(self):\n\n # Ask for a few residues.\n res1 = mol_res_spin.return_single_residue_info('1')\n res2 = mol_res_spin.return_single_residue_info('2,Glu')\n res4 = mol_res_spin.return_single_residue_info('Pro,4')\n res5 = mol_res_spin.return_single_r... | [
"0.79661804",
"0.7835014",
"0.69599706",
"0.63726276",
"0.6243398",
"0.61490476",
"0.60890734",
"0.6079709",
"0.5994329",
"0.59389675",
"0.5879574",
"0.5872051",
"0.57941824",
"0.5751928",
"0.57405704",
"0.5738197",
"0.5649554",
"0.5574121",
"0.5553376",
"0.55352575",
"0.5525... | 0.7993023 | 0 |
Test the function for returning the desired spin data container. The function tested is pipe_control.mol_res_spin.return_spin(). | def test_return_spin(self):
# Ask for a few spins.
spin1 = mol_res_spin.return_spin('#Ap4Aase:1')
spin2 = mol_res_spin.return_spin(spin_id='#Ap4Aase:2')
spin3 = mol_res_spin.return_spin(spin_id='#Ap4Aase:4', pipe='orig')
spin4 = mol_res_spin.return_spin(spin_id='#RNA:-5@N5', pip... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_return_spin_pipe_fail(self):\n\n # Try to get a spin from a missing data pipe.\n self.assertRaises(RelaxNoPipeError, mol_res_spin.return_spin, spin_id=':2', pipe='new')",
"def test_return_molecule(self):\n\n # Ask for a few molecules.\n mol1 = mol_res_spin.return_molecule('#A... | [
"0.6254745",
"0.62498236",
"0.62125456",
"0.6161361",
"0.6015934",
"0.597637",
"0.58106077",
"0.57989025",
"0.57807255",
"0.5775557",
"0.57453865",
"0.5677636",
"0.56534547",
"0.5535556",
"0.55239886",
"0.53587866",
"0.5336745",
"0.5311502",
"0.52942914",
"0.5217297",
"0.5215... | 0.8249369 | 0 |
Test the failure of the function for returning the desired spin data container. The function tested is pipe_control.mol_res_spin.return_spin(). | def test_return_spin_pipe_fail(self):
# Try to get a spin from a missing data pipe.
self.assertRaises(RelaxNoPipeError, mol_res_spin.return_spin, spin_id=':2', pipe='new') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_return_spin(self):\n\n # Ask for a few spins.\n spin1 = mol_res_spin.return_spin('#Ap4Aase:1')\n spin2 = mol_res_spin.return_spin(spin_id='#Ap4Aase:2')\n spin3 = mol_res_spin.return_spin(spin_id='#Ap4Aase:4', pipe='orig')\n spin4 = mol_res_spin.return_spin(spin_id='#RNA:... | [
"0.78494513",
"0.66188395",
"0.6351322",
"0.63377",
"0.63215846",
"0.62711096",
"0.6125446",
"0.6110812",
"0.59731114",
"0.5921803",
"0.589555",
"0.5886584",
"0.572914",
"0.5577149",
"0.5547649",
"0.550307",
"0.5490488",
"0.5437511",
"0.5385294",
"0.5323193",
"0.52905536",
... | 0.7464118 | 1 |
Test the proper operation of the spin loop with spin selection. The function tested is pipe_control.mol_res_spin.spin_loop(). | def test_spin_loop(self):
# Spin data.
select = [1, 0]
# Loop over the spins.
i = 0
for spin in mol_res_spin.spin_loop('@N5'):
# Test the selection.
self.assertEqual(spin.select, select[i])
# Test the spin names.
self.assertEqual... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_spin_loop_no_selection(self):\n\n # Spin data.\n select = [0, 1, 0, 0, 1, 1, 0, 1]\n name = ['NH', 'NH', None, 'C8', 'N5', 'C8', 'N5', '2H']\n\n # Loop over the spins.\n i = 0\n for spin in mol_res_spin.spin_loop():\n # Test the selection.\n ... | [
"0.76839185",
"0.7019713",
"0.68919516",
"0.68854254",
"0.65529144",
"0.6440893",
"0.6163988",
"0.59719443",
"0.5952859",
"0.59403336",
"0.5869492",
"0.5838458",
"0.5775429",
"0.5759338",
"0.569917",
"0.56271356",
"0.5577104",
"0.55301183",
"0.549381",
"0.54663414",
"0.538889... | 0.8171222 | 0 |
Test the proper operation of the spin loop with spin selection '|'. The function tested is pipe_control.mol_res_spin.spin_loop(). | def test_spin_loop_multiatom(self):
# Spin data.
select = [0, 1, 1, 0]
name = ['NH', 'NH', 'N5', 'N5']
# Loop over the spins.
i = 0
for spin in mol_res_spin.spin_loop('@NH|@N5'):
# Test the selection.
self.assertEqual(spin.select, select[i])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_spin_loop(self):\n\n # Spin data.\n select = [1, 0]\n\n # Loop over the spins.\n i = 0\n for spin in mol_res_spin.spin_loop('@N5'):\n # Test the selection.\n self.assertEqual(spin.select, select[i])\n\n # Test the spin names.\n ... | [
"0.79278994",
"0.73636407",
"0.73381263",
"0.7112621",
"0.6873909",
"0.64583564",
"0.638243",
"0.6248901",
"0.5991681",
"0.5833193",
"0.5816119",
"0.5754139",
"0.57313025",
"0.5710049",
"0.56814057",
"0.560137",
"0.5573722",
"0.5518391",
"0.54985505",
"0.5454692",
"0.542185",... | 0.6567738 | 5 |
Test the proper operation of the spin loop when no data is present. The function tested is pipe_control.mol_res_spin.spin_loop(). | def test_spin_loop_no_data(self):
# Reset relax.
reset()
# Add a data pipe to the data store.
ds.add(pipe_name='orig', pipe_type='mf')
# Loop over the spins.
i = 0
for spin in mol_res_spin.spin_loop():
i = i + 1
# Test loop length.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_spin_loop_no_pipe(self):\n\n # Reset relax.\n reset()\n\n # Function for the problem of catching an error in a generator function.\n def fail_test():\n for spin in mol_res_spin.spin_loop():\n pass\n\n # Test for the no pipe error.\n self.... | [
"0.7811089",
"0.7292637",
"0.7291406",
"0.7091763",
"0.6846889",
"0.6789092",
"0.6699432",
"0.66825855",
"0.66130304",
"0.63301605",
"0.61651087",
"0.6073626",
"0.5983543",
"0.5924072",
"0.5917373",
"0.591516",
"0.58277524",
"0.5808656",
"0.5755179",
"0.5706209",
"0.56306875"... | 0.87055194 | 0 |
Test the proper operation of the spin loop when no data pipe is present. The function tested is pipe_control.mol_res_spin.spin_loop(). | def test_spin_loop_no_pipe(self):
# Reset relax.
reset()
# Function for the problem of catching an error in a generator function.
def fail_test():
for spin in mol_res_spin.spin_loop():
pass
# Test for the no pipe error.
self.assertRaises(Rel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_spin_loop_no_data(self):\n\n # Reset relax.\n reset()\n\n # Add a data pipe to the data store.\n ds.add(pipe_name='orig', pipe_type='mf')\n\n # Loop over the spins.\n i = 0\n for spin in mol_res_spin.spin_loop():\n i = i + 1\n\n # Test loo... | [
"0.8414788",
"0.7601054",
"0.7113457",
"0.7043407",
"0.7001332",
"0.673422",
"0.66587317",
"0.653782",
"0.64508295",
"0.6446371",
"0.62323546",
"0.5766039",
"0.5760466",
"0.57546294",
"0.5717464",
"0.5711903",
"0.57100135",
"0.5633577",
"0.5567761",
"0.55639905",
"0.55532223"... | 0.83668333 | 1 |
Test the proper operation of the spin loop when no selection is present. The function tested is pipe_control.mol_res_spin.spin_loop(). | def test_spin_loop_no_selection(self):
# Spin data.
select = [0, 1, 0, 0, 1, 1, 0, 1]
name = ['NH', 'NH', None, 'C8', 'N5', 'C8', 'N5', '2H']
# Loop over the spins.
i = 0
for spin in mol_res_spin.spin_loop():
# Test the selection.
self.assertEqua... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_spin_loop(self):\n\n # Spin data.\n select = [1, 0]\n\n # Loop over the spins.\n i = 0\n for spin in mol_res_spin.spin_loop('@N5'):\n # Test the selection.\n self.assertEqual(spin.select, select[i])\n\n # Test the spin names.\n ... | [
"0.75004387",
"0.7467984",
"0.7230426",
"0.6575248",
"0.64682966",
"0.6366928",
"0.629157",
"0.61815935",
"0.59252053",
"0.59217304",
"0.59209067",
"0.5756598",
"0.569629",
"0.5623459",
"0.55442035",
"0.5533466",
"0.5505412",
"0.5480573",
"0.547112",
"0.5420042",
"0.53915197"... | 0.8127604 | 0 |
Test the proper operation of the spin loop with wildcard spin selection ''. The function tested is pipe_control.mol_res_spin.spin_loop(). | def test_spin_loop_wildcard(self):
# Spin data.
select = [0, 1, 1, 0]
name = ['NH', 'NH', 'N5', 'N5']
# Loop over the spins.
i = 0
for spin in mol_res_spin.spin_loop('@N*'):
# Test the selection.
self.assertEqual(spin.select, select[i])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_spin_loop(self):\n\n # Spin data.\n select = [1, 0]\n\n # Loop over the spins.\n i = 0\n for spin in mol_res_spin.spin_loop('@N5'):\n # Test the selection.\n self.assertEqual(spin.select, select[i])\n\n # Test the spin names.\n ... | [
"0.76207334",
"0.74092525",
"0.6786517",
"0.67461604",
"0.6667878",
"0.6086697",
"0.6002766",
"0.5998333",
"0.5985406",
"0.58735466",
"0.58593804",
"0.5647808",
"0.5585266",
"0.5514325",
"0.550792",
"0.54545707",
"0.543505",
"0.54324937",
"0.5399342",
"0.5395513",
"0.53469473... | 0.8172461 | 0 |
Test boolean and in molresspin selections. | def test_boolean_and_selection(self):
# The selection loop:
sel = list(mol_res_spin.residue_loop("#Ap4Aase:4 & :Pro"))
# Test:
self.assertEqual(len(sel), 1)
for res in sel:
self.assert_(res.name == "Pro" and res.num == 4) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_boolean_complex_selection(self):\n\n # The residue selection loop.\n sel = list(mol_res_spin.residue_loop(\"#Ap4Aase:4 & :Pro | #RNA\"))\n\n # Residue names and numbers.\n names = ['Pro', None, None]\n numbers = [4, -5, -4]\n\n # The residues.\n self.assert... | [
"0.70032185",
"0.6886894",
"0.6886894",
"0.62776476",
"0.62746215",
"0.62711465",
"0.61798936",
"0.6083441",
"0.5987472",
"0.59555334",
"0.59517634",
"0.5910961",
"0.585857",
"0.58579606",
"0.5849827",
"0.58383787",
"0.58287346",
"0.5822584",
"0.5805983",
"0.57605493",
"0.575... | 0.7390658 | 0 |
Test complex boolean molresspin selections. | def test_boolean_complex_selection(self):
# The residue selection loop.
sel = list(mol_res_spin.residue_loop("#Ap4Aase:4 & :Pro | #RNA"))
# Residue names and numbers.
names = ['Pro', None, None]
numbers = [4, -5, -4]
# The residues.
self.assertEqual(len(sel), 3... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_boolean_and_selection(self):\n\n # The selection loop:\n sel = list(mol_res_spin.residue_loop(\"#Ap4Aase:4 & :Pro\"))\n\n # Test:\n self.assertEqual(len(sel), 1)\n for res in sel:\n self.assert_(res.name == \"Pro\" and res.num == 4)",
"def boolean_func(exper... | [
"0.66458935",
"0.64277714",
"0.62511396",
"0.6227797",
"0.61286384",
"0.5731911",
"0.5731911",
"0.5623282",
"0.5538769",
"0.5524149",
"0.54843676",
"0.5470526",
"0.54597956",
"0.53990823",
"0.53824186",
"0.5378115",
"0.53747463",
"0.5374542",
"0.5369208",
"0.5353589",
"0.5331... | 0.77207905 | 0 |
Test complex boolean molresspin selections with parenthesis. | def fixme_test_boolean_parenthesis_selection(self):
# The selection loop:
sel = list(mol_res_spin.residue_loop("(#Ap4Aase & :Pro) | (#RNA & :-4)"))
# Test:
self.assertEqual(len(sel), 2)
for res in sel:
self.assert_(res.num in [-4, 4]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_boolean_complex_selection(self):\n\n # The residue selection loop.\n sel = list(mol_res_spin.residue_loop(\"#Ap4Aase:4 & :Pro | #RNA\"))\n\n # Residue names and numbers.\n names = ['Pro', None, None]\n numbers = [4, -5, -4]\n\n # The residues.\n self.assert... | [
"0.72196627",
"0.622446",
"0.617506",
"0.6151499",
"0.6054697",
"0.5972477",
"0.595188",
"0.59008986",
"0.5731449",
"0.571927",
"0.56771934",
"0.5491429",
"0.54325634",
"0.5403343",
"0.537575",
"0.5369136",
"0.53508174",
"0.5343714",
"0.53357446",
"0.53322315",
"0.53228456",
... | 0.65406233 | 1 |
Return the list of accessibility services | def get_accessibility_services(self):
result = []
services = self.find_tags("service")
for s in services:
for action in s.findall("./intent-filter/action"):
if "android.accessibilityservice.AccessibilityService" in action.attrib.values():
result.ap... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def available_services(self) -> list[str]:\r\n return self.services",
"def get_services(self):\r\n return get_service_list()",
"def list_services(ctx):\n pass",
"def getServices(self):\n pass",
"def services(self):\n return self.agent.http.get(\n lambda x: ... | [
"0.68534184",
"0.6790268",
"0.67288893",
"0.6717567",
"0.6657605",
"0.6592076",
"0.6433918",
"0.6382641",
"0.6368458",
"0.633186",
"0.6297952",
"0.628866",
"0.627553",
"0.62480915",
"0.6243383",
"0.62318575",
"0.61614",
"0.61078346",
"0.6070793",
"0.60232335",
"0.5990591",
... | 0.8399575 | 0 |
Return the list of accessibility services | def get_administrator_receivers(self):
result = []
services = self.find_tags("receiver")
for s in services:
for action in s.findall("./intent-filter/action"):
if "android.app.action.DEVICE_ADMIN_ENABLED" in action.attrib.values():
result.append(s.a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_accessibility_services(self):\n result = []\n services = self.find_tags(\"service\")\n for s in services:\n for action in s.findall(\"./intent-filter/action\"):\n if \"android.accessibilityservice.AccessibilityService\" in action.attrib.values():\n ... | [
"0.8399575",
"0.68534184",
"0.6790268",
"0.67288893",
"0.6717567",
"0.6657605",
"0.6592076",
"0.6433918",
"0.6382641",
"0.6368458",
"0.633186",
"0.6297952",
"0.628866",
"0.627553",
"0.62480915",
"0.6243383",
"0.62318575",
"0.61614",
"0.61078346",
"0.6070793",
"0.60232335",
... | 0.0 | -1 |
Return courier_type field as a representation. | def to_representation(self, instance):
return instance.courier_type | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_complex_type(self):\n import numpy\n return numpy.complex128",
"def type(self):\n if self._type is None:\n self._type = repr(self.t)\n return self._type",
"def get_dtype(col):\n dtype = col.dtype\n\n if isinstance(dtype, CategoricalDtype):\n col = col... | [
"0.6486205",
"0.615645",
"0.6019429",
"0.60141975",
"0.60050386",
"0.5982129",
"0.59765273",
"0.59747857",
"0.5848326",
"0.58467203",
"0.5842888",
"0.5832162",
"0.58162147",
"0.578082",
"0.57736826",
"0.57470566",
"0.56982577",
"0.56823003",
"0.5671127",
"0.5664471",
"0.56587... | 0.5860837 | 8 |
Return region field as a representation. | def to_representation(self, instance):
return instance.region | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def region(self):\n # type: () -> string_types\n return self._region",
"def region(self) -> str:\n return self.__region",
"def __repr__(self: RcnRegion) -> str:\n return f\"RcnRegion.{self.name}\"",
"def region(self):\n return self._region",
"def region(self):\n re... | [
"0.6821899",
"0.6763117",
"0.67216176",
"0.6716908",
"0.6716908",
"0.6671237",
"0.6656148",
"0.6619242",
"0.6594691",
"0.65667427",
"0.6521952",
"0.65041155",
"0.65041155",
"0.65041155",
"0.65041155",
"0.65041155",
"0.65041155",
"0.6379895",
"0.63188833",
"0.63188833",
"0.631... | 0.7870258 | 0 |
Save a new instance to the database. | def create(self, validated_data):
region = CourierRegions.objects.create(
courier_id=Courier.objects.get(courier_id=validated_data['courier_id']),
region=validated_data['region']
)
return region | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_to_db(self, instance: DBModelInstance) -> None:\n self.db.session.add(instance)\n self.db.session.commit()",
"def save(self):\n \n db.session.add(self)\n db.session.commit()",
"def save_to_db(self):\n db.session.add(self)\n db.session.commit()",
"de... | [
"0.82036686",
"0.8164637",
"0.8156815",
"0.8156815",
"0.8156815",
"0.8156815",
"0.81085813",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8047626",
"0.7957635",
"0.7858651",
... | 0.0 | -1 |
Save a new instance to the database. | def create(self, validated_data):
w_h = WorkingHours.objects.create(
courier_id=Courier.objects.get(courier_id=validated_data['courier_id']),
work_start=validated_data['working_hours'][:5],
work_end=validated_data['working_hours'][6:]
)
return w_h | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_to_db(self, instance: DBModelInstance) -> None:\n self.db.session.add(instance)\n self.db.session.commit()",
"def save(self):\n \n db.session.add(self)\n db.session.commit()",
"def save_to_db(self):\n db.session.add(self)\n db.session.commit()",
"de... | [
"0.82036686",
"0.8164637",
"0.8156815",
"0.8156815",
"0.8156815",
"0.8156815",
"0.81085813",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8047626",
"0.7957635",
"0.7858651",
... | 0.0 | -1 |
Save a new instance to the database. | def create(self, validated_data):
d_h = DeliveryHours.objects.create(
order_id=Order.objects.get(order_id=validated_data['order_id']),
delivery_start=validated_data['delivery_hours'][:5],
delivery_end=validated_data['delivery_hours'][6:]
)
return d_h | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_to_db(self, instance: DBModelInstance) -> None:\n self.db.session.add(instance)\n self.db.session.commit()",
"def save(self):\n \n db.session.add(self)\n db.session.commit()",
"def save_to_db(self):\n db.session.add(self)\n db.session.commit()",
"de... | [
"0.82038593",
"0.8164796",
"0.8157097",
"0.8157097",
"0.8157097",
"0.8157097",
"0.8108775",
"0.808835",
"0.808835",
"0.808835",
"0.808835",
"0.808835",
"0.808835",
"0.808835",
"0.808835",
"0.808835",
"0.808835",
"0.808835",
"0.80479497",
"0.79576",
"0.7858863",
"0.7736452",... | 0.0 | -1 |
Save new CourierRegion instances to the database. | def save_regions(validated_data):
for region in validated_data['regions']:
new_region = CourierRegionsSerializer(data={
'courier_id': validated_data['courier_id'],
'region': region
})
if not new_region.is_valid():
raise Validat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, validated_data):\n\n region = CourierRegions.objects.create(\n courier_id=Courier.objects.get(courier_id=validated_data['courier_id']),\n region=validated_data['region']\n )\n return region",
"def save(self, f):\n self.f = f\n for region i... | [
"0.64264625",
"0.5719807",
"0.56590676",
"0.54390705",
"0.54215187",
"0.5370093",
"0.53380907",
"0.53348017",
"0.530663",
"0.52896005",
"0.52896005",
"0.5281476",
"0.52535737",
"0.52535737",
"0.52535737",
"0.52535737",
"0.52434415",
"0.5241482",
"0.5241482",
"0.5241482",
"0.5... | 0.7319758 | 0 |
Save new WorkingHours instances to the database. | def save_hours(validated_data):
for w_h in validated_data['working_hours']:
new_w_h = WorkingHoursSerializer(data={
'courier_id': validated_data['courier_id'],
'working_hours': w_h
})
if not new_w_h.is_valid():
raise Validation... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_hours(validated_data):\n\n for d_h in validated_data['delivery_hours']:\n new_d_h = DeliveryHoursSerializer(data={\n 'order_id': validated_data['order_id'],\n 'delivery_hours': d_h\n })\n if not new_d_h.is_valid():\n rais... | [
"0.6595605",
"0.6511643",
"0.6050262",
"0.6011547",
"0.580755",
"0.580755",
"0.580755",
"0.580755",
"0.57043535",
"0.5699419",
"0.56891483",
"0.56619227",
"0.5596039",
"0.5595059",
"0.5548948",
"0.55391455",
"0.55391455",
"0.55391455",
"0.55391455",
"0.55391455",
"0.55391455"... | 0.7561775 | 0 |
Save a new instance to the database. | def create(self, validated_data):
new_courier = Courier(
courier_id=validated_data['courier_id'],
courier_type=validated_data['courier_type']
)
new_courier.save()
self.save_hours(validated_data)
self.save_regions(validated_data)
return new_courier | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_to_db(self, instance: DBModelInstance) -> None:\n self.db.session.add(instance)\n self.db.session.commit()",
"def save(self):\n \n db.session.add(self)\n db.session.commit()",
"def save_to_db(self):\n db.session.add(self)\n db.session.commit()",
"de... | [
"0.82036686",
"0.8164637",
"0.8156815",
"0.8156815",
"0.8156815",
"0.8156815",
"0.81085813",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8047626",
"0.7957635",
"0.7858651",
... | 0.0 | -1 |
Update an existing instance and save. | def update(self, instance, validated_data):
if 'courier_type' in validated_data.keys():
instance.courier_type = validated_data['courier_type']
instance.save()
if 'working_hours' in validated_data.keys():
WorkingHours.objects.filter(courier_id=instance.courier_id).del... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, instance, validated_data):\n pass",
"def update(self, instance, validated_data):\n # instance.id = validated_data.get('id', instance.id)\n instance.teeth = validated_data.get('teeth', instance.teeth)\n instance.species = validated_data.get('species', instance.species)... | [
"0.7564434",
"0.7265815",
"0.7263486",
"0.7191226",
"0.71909565",
"0.7151628",
"0.7142503",
"0.7063716",
"0.7056037",
"0.7051953",
"0.7051953",
"0.7031902",
"0.70192325",
"0.6981581",
"0.6978696",
"0.6973921",
"0.69628555",
"0.69628555",
"0.69569516",
"0.69452506",
"0.6883257... | 0.0 | -1 |
Raises ValidationError if the given list of regions is empty, the list otherwise. | def validate_regions(self, value):
if len(value) == 0:
raise ValidationError('List should not be empty.')
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_regions(validated_data):\n\n for region in validated_data['regions']:\n new_region = CourierRegionsSerializer(data={\n 'courier_id': validated_data['courier_id'],\n 'region': region\n })\n if not new_region.is_valid():\n ... | [
"0.58792216",
"0.58624536",
"0.58315694",
"0.58029544",
"0.5629878",
"0.560681",
"0.53393847",
"0.5311191",
"0.5308086",
"0.5301234",
"0.52908784",
"0.5228517",
"0.5227655",
"0.5113418",
"0.510784",
"0.50779873",
"0.5052461",
"0.5052382",
"0.5038692",
"0.50158596",
"0.5013641... | 0.81604916 | 0 |
Raises ValidationError if the given list of working hours is empty, the list otherwise. | def validate_working_hours(self, value):
if len(value) == 0:
raise ValidationError('List should not be empty.')
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_delivery_hours(self, value):\n\n if len(value) == 0:\n raise ValidationError('List should not be empty.')\n return value",
"def save_hours(validated_data):\n\n for w_h in validated_data['working_hours']:\n new_w_h = WorkingHoursSerializer(data={\n ... | [
"0.7269126",
"0.6866808",
"0.6861681",
"0.67966706",
"0.6211005",
"0.6202418",
"0.59814394",
"0.58779675",
"0.5871235",
"0.57033545",
"0.5618451",
"0.55920196",
"0.5522947",
"0.5502552",
"0.5354208",
"0.5335648",
"0.52977383",
"0.525785",
"0.5205049",
"0.52016556",
"0.5159868... | 0.8444958 | 0 |
Raises ValidationError if the request body contains unexpected fields. | def run_validation(self, data=empty):
# no idea why there is no such built in feature in DRF
if data is not empty:
unknown = set(data) - set(self.fields)
if unknown:
errors = ['Unknown field: {}'.format(f) for f in unknown]
raise ValidationError({... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_invalid_body_parameters(self, body):\n self._login_as_staff()\n response = self.patch_request(body)\n assert response.status_code == 400",
"def _validate(self, body):\n if not body:\n raise exception.BadRequest(\"The request contains an empty body\")\n\n if ... | [
"0.71563065",
"0.7143478",
"0.692088",
"0.6735163",
"0.6489339",
"0.64386034",
"0.64323974",
"0.6428578",
"0.6358199",
"0.63555485",
"0.6341984",
"0.6337503",
"0.62512153",
"0.6228987",
"0.6201926",
"0.61715084",
"0.6144717",
"0.6141178",
"0.6126661",
"0.61246574",
"0.6118206... | 0.58812124 | 39 |
Save new instances of DeliveryHours to the database. | def save_hours(validated_data):
for d_h in validated_data['delivery_hours']:
new_d_h = DeliveryHoursSerializer(data={
'order_id': validated_data['order_id'],
'delivery_hours': d_h
})
if not new_d_h.is_valid():
raise ValidationE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, validated_data):\n\n d_h = DeliveryHours.objects.create(\n order_id=Order.objects.get(order_id=validated_data['order_id']),\n delivery_start=validated_data['delivery_hours'][:5],\n delivery_end=validated_data['delivery_hours'][6:]\n )\n return ... | [
"0.6799848",
"0.65913475",
"0.57204527",
"0.5639961",
"0.56362647",
"0.5613045",
"0.5545568",
"0.54776233",
"0.5454978",
"0.5431331",
"0.5412394",
"0.5412394",
"0.5412394",
"0.5412394",
"0.53458804",
"0.5314343",
"0.5288774",
"0.5245218",
"0.52222604",
"0.5202509",
"0.5193683... | 0.7650199 | 0 |
Save a new instance to the database. | def create(self, validated_data):
new_order = Order(
order_id=validated_data['order_id'],
weight=validated_data['weight'],
region=validated_data['region']
)
new_order.save()
self.save_hours(validated_data)
return new_order | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_to_db(self, instance: DBModelInstance) -> None:\n self.db.session.add(instance)\n self.db.session.commit()",
"def save(self):\n \n db.session.add(self)\n db.session.commit()",
"def save_to_db(self):\n db.session.add(self)\n db.session.commit()",
"de... | [
"0.82036686",
"0.8164637",
"0.8156815",
"0.8156815",
"0.8156815",
"0.8156815",
"0.81085813",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8088127",
"0.8047626",
"0.7957635",
"0.7858651",
... | 0.0 | -1 |
Raises ValidationError if the given list of delivery hours is empty, the list otherwise. | def validate_delivery_hours(self, value):
if len(value) == 0:
raise ValidationError('List should not be empty.')
return value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_working_hours(self, value):\n\n if len(value) == 0:\n raise ValidationError('List should not be empty.')\n return value",
"def save_hours(validated_data):\n\n for d_h in validated_data['delivery_hours']:\n new_d_h = DeliveryHoursSerializer(data={\n ... | [
"0.70854056",
"0.6905043",
"0.6794095",
"0.66818875",
"0.631159",
"0.58860403",
"0.58774155",
"0.56794053",
"0.5401232",
"0.53009903",
"0.52992254",
"0.5283572",
"0.52385384",
"0.52176595",
"0.51481444",
"0.5120775",
"0.5075307",
"0.506215",
"0.505264",
"0.5031269",
"0.501651... | 0.83690053 | 0 |
Raises ValidationError if the request body contains unexpected fields. | def run_validation(self, data=empty):
if data is not empty:
unknown = set(data) - set(self.fields)
if unknown:
errors = ['Unknown field: {}'.format(f) for f in unknown]
raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})
return supe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_invalid_body_parameters(self, body):\n self._login_as_staff()\n response = self.patch_request(body)\n assert response.status_code == 400",
"def _validate(self, body):\n if not body:\n raise exception.BadRequest(\"The request contains an empty body\")\n\n if ... | [
"0.71563065",
"0.7143478",
"0.692088",
"0.6735163",
"0.6489339",
"0.64386034",
"0.64323974",
"0.6428578",
"0.6358199",
"0.63555485",
"0.6341984",
"0.6337503",
"0.62512153",
"0.6228987",
"0.6201926",
"0.61715084",
"0.6144717",
"0.6141178",
"0.6126661",
"0.61246574",
"0.6118206... | 0.55053574 | 92 |
Assign orders to a given courier. | def create(self, validated_data):
courier_obj = validated_data['courier_id']
assigned_orders = Order.objects.filter(courier_id=courier_obj, complete_time__isnull=True)
if assigned_orders.exists(): # if current delivery is not over, return uncompleted orders
response = {
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def orders(self, orders):\n\n self._orders = orders",
"def orders(self, orders):\n\n self._orders = orders",
"def set_coefs_order(self, order):\n # Attach an epistasis model.\n self.order = order\n self.add_epistasis()\n self.epistasis.data.values = np.zeros(self.epist... | [
"0.57342046",
"0.57342046",
"0.5671593",
"0.5608808",
"0.55052537",
"0.5336174",
"0.5332351",
"0.5332351",
"0.5280335",
"0.5280335",
"0.5280028",
"0.5245321",
"0.5210045",
"0.51828367",
"0.5163213",
"0.51535404",
"0.51506305",
"0.5145227",
"0.5136289",
"0.5136289",
"0.5136289... | 0.44290462 | 74 |
Raises ValidationError if the request body contains unexpected fields. | def validate(self, attrs):
unknown = set(self.initial_data) - set(self.fields)
if unknown:
raise ValidationError('Unknown field(s): {}'.format('', ''.join(unknown)))
return attrs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_invalid_body_parameters(self, body):\n self._login_as_staff()\n response = self.patch_request(body)\n assert response.status_code == 400",
"def _validate(self, body):\n if not body:\n raise exception.BadRequest(\"The request contains an empty body\")\n\n if ... | [
"0.71563065",
"0.7143478",
"0.692088",
"0.6735163",
"0.6489339",
"0.64386034",
"0.64323974",
"0.6428578",
"0.6358199",
"0.63555485",
"0.6341984",
"0.6337503",
"0.62512153",
"0.6228987",
"0.6201926",
"0.61715084",
"0.6144717",
"0.6141178",
"0.6126661",
"0.61246574",
"0.6118206... | 0.54817533 | 100 |
Mark given order as completed and increases related courier's earning if current delivery is over. | def create(self, validated_data):
order_obj = Order.objects.get(order_id=validated_data['order_id'])
order_obj.complete_time = validated_data['complete_time']
order_obj.save()
# if current delivery is over, add earnings
if not Order.objects.filter(courier_id=order_obj.courier_i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mark_completed(self, order_id=None):\n self.status = \"paid\"\n if order_id and not self.order_id:\n self.order_id = order_id\n print(\"Order completed\")\n self.save()",
"def order_finish(self):\r\n logger.info(f'Remaining qty:{self.quantity-self.filled_quantity... | [
"0.7115944",
"0.65188056",
"0.63519084",
"0.6026853",
"0.59948623",
"0.5960341",
"0.58357316",
"0.57971895",
"0.56998575",
"0.56283593",
"0.5623195",
"0.5612759",
"0.5612759",
"0.5612759",
"0.5559784",
"0.5555224",
"0.55308384",
"0.5526902",
"0.55223775",
"0.5503282",
"0.5503... | 0.5629139 | 9 |
Raises ValidationError if order with given id does not exist, is not assigned to any courier or is already completed. | def validate_order_id(self, value):
if not Order.objects.filter(order_id=value).exists():
raise ValidationError(f'Order with id {value} does not exist.')
order_obj = Order.objects.get(order_id=value)
if order_obj.assign_time is None:
raise ValidationError(f'Order with id... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self, attrs):\n\n errors = {}\n order_obj = Order.objects.get(order_id=attrs['order_id'])\n if order_obj.courier_id.courier_id != attrs['courier_id'].courier_id:\n errors['order_id'] = f'Order with id {order_obj.order_id} is assigned to another courier.'\n unknow... | [
"0.6367057",
"0.61440265",
"0.60556054",
"0.5945867",
"0.58446044",
"0.57476765",
"0.57366914",
"0.5560988",
"0.54352444",
"0.5427547",
"0.54036677",
"0.53682196",
"0.53528076",
"0.5352244",
"0.53520465",
"0.53500265",
"0.5327493",
"0.53269213",
"0.53213036",
"0.53162146",
"0... | 0.8479572 | 0 |
Raises ValidationError of the order with the given id is assigned to another courier, specified complete_time is greater than order's assign_time or there are unexpected fields in the request body. | def validate(self, attrs):
errors = {}
order_obj = Order.objects.get(order_id=attrs['order_id'])
if order_obj.courier_id.courier_id != attrs['courier_id'].courier_id:
errors['order_id'] = f'Order with id {order_obj.order_id} is assigned to another courier.'
unknown = set(sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_order_id(self, value):\n\n if not Order.objects.filter(order_id=value).exists():\n raise ValidationError(f'Order with id {value} does not exist.')\n order_obj = Order.objects.get(order_id=value)\n if order_obj.assign_time is None:\n raise ValidationError(f'Or... | [
"0.7156292",
"0.63136715",
"0.5466236",
"0.53860146",
"0.52171755",
"0.5214629",
"0.5198121",
"0.5026115",
"0.5020451",
"0.49440423",
"0.49169457",
"0.48243418",
"0.4787714",
"0.47877014",
"0.47723362",
"0.4748931",
"0.4731741",
"0.46965528",
"0.46746913",
"0.4651812",
"0.464... | 0.69398975 | 1 |
Returns a single entry in the generated dataset. Return a bunch of random values as an example. | def row_generator(x, H, W, C):
return {'frame_id': x,
'frame_data': np.random.randint(0, 10,
dtype=np.uint8, size=(H, W, C))} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getRandom(self):\n \n return self.data[random.randint(0, len(self.data) - 1)]",
"def getRandom(self):\n return random.choice(self.data)",
"def randomRow(self):\r\n l = []\r\n for row in self.data:\r\n l.append(row)\r\n return random.choice(l)",
"def ge... | [
"0.6710937",
"0.6699718",
"0.6537949",
"0.64686054",
"0.6440445",
"0.6439815",
"0.6246304",
"0.62280905",
"0.61741596",
"0.6161315",
"0.6138543",
"0.61140835",
"0.6086445",
"0.60771036",
"0.6075611",
"0.6065098",
"0.6062155",
"0.6038981",
"0.6028018",
"0.60002375",
"0.5990621... | 0.0 | -1 |
Saves a memory, x. | def encode(self, x):
# Pad out
if len(self.memory) < self.capacity:
self.memory.append(None)
# Remember
self.memory[self.position] = x
self.position = int((self.position + 1) % self.capacity) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def savefile(self, x, o):\n self.sep('save')\n with open(o, 'w') as f:\n f.write(x)\n sys.exit('all done (%s bytes).. saved as %s' % (len(x), o))",
"def save_memory(self, filename):\n \n\n with open(filename + '/obses.npy', 'wb') as f:\n np.save(f, self.obses)... | [
"0.661321",
"0.6199178",
"0.61638105",
"0.6142827",
"0.6013084",
"0.5942242",
"0.5910202",
"0.5820138",
"0.5730391",
"0.5720858",
"0.57114774",
"0.5685187",
"0.5661498",
"0.5660701",
"0.56581867",
"0.5656959",
"0.56225663",
"0.5608321",
"0.5604391",
"0.5580106",
"0.5578358",
... | 0.609972 | 4 |
Randomly sample `n` memories | def sample(self, n):
idx = np.random.randint(0, len(self.memory), size=n)
return [self.memory[i] for i in idx] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample(n, seed= 0):\n data = list(range(n))\n while True:\n np.random.seed(seed)\n np.random.shuffle(data)\n yield from data",
"def sample(self, n):\n raise NotImplementedError",
"def sample_batch(memory, n):\n batch = rnd.sample(memory, n) # List containing tuples\n ... | [
"0.75761276",
"0.7508017",
"0.74692214",
"0.7464645",
"0.74448174",
"0.7441827",
"0.73945725",
"0.734842",
"0.71837",
"0.7161568",
"0.71080214",
"0.7107572",
"0.7095622",
"0.7086794",
"0.7068867",
"0.70568603",
"0.70141",
"0.7003059",
"0.69959825",
"0.69918495",
"0.69673544",... | 0.8171086 | 0 |
Saves a priority weight and a memory, x. | def encode(self, weight, x):
# Sanity
weight = float(weight)
if np.isclose(weight, 0.0):
raise ValueError("w must be > 0")
# Pad out
if len(self.memory) < self.capacity:
self.memory.append(None)
self.priority.append(None)
# Remember
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_weights(self, the_path):\n torch.save(self.model.state_dict(), the_path)",
"def save(self, weight_path, vocab_path, output_path, binary=False):\n w2v_save_model(weight_path.encode(\"ascii\"),\n vocab_path.encode(\"ascii\"), \n output_path.encode(... | [
"0.55070525",
"0.5479773",
"0.54729784",
"0.54729784",
"0.539775",
"0.53781176",
"0.53729707",
"0.5255315",
"0.5204153",
"0.51955986",
"0.51532245",
"0.5136106",
"0.51347286",
"0.5108663",
"0.5106836",
"0.5048806",
"0.5046801",
"0.50428057",
"0.50421166",
"0.5030649",
"0.5026... | 0.68081224 | 0 |
A wieghted sample of n memories | def sample(self, n):
# Est probs from priority weights
summed = sum(self.weight) + self.eps
self.probs = [w / summed for w in self.priority]
# Wieghted sample
return np.random.choice(self.memory, size=n, p=self.probs).tolist() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_samples(self, n_samples):",
"def generate_samples(self, n_samples):",
"def sample(self, n):\n idx = np.random.randint(0, len(self.memory), size=n)\n return [self.memory[i] for i in idx]",
"def sample(self, n):\n raise NotImplementedError",
"def sample(self, n=1):\n ... | [
"0.7382827",
"0.7382827",
"0.7142945",
"0.7120932",
"0.699244",
"0.6988327",
"0.68088275",
"0.6714524",
"0.65344375",
"0.65145004",
"0.64302224",
"0.6410242",
"0.64098626",
"0.637732",
"0.6367377",
"0.63631177",
"0.63408345",
"0.6314813",
"0.6302227",
"0.62922007",
"0.6196453... | 0.71244526 | 3 |
When we XOR elements, the ideal case to maximize the result is to have the XOR operands to have different bits for each position. An operation can remove a bit but cannot add one, so the goal is to remove all bits shared between array elements. Therefore, the solution is to perform OR on all elements. | def max_xor(A):
return reduce(lambda x, y: x | y, A) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xor(self):\n\n \"\"\" fisrt i pick element we need to xor each other and put theme in list\"\"\"\n bits_to_xor = []\n for i in self.xor_input:\n bits_to_xor.append(self.state[i])\n\n \"\"\" next xor the list elemet usin reduce with lambda func.\"\"\"\n... | [
"0.7474404",
"0.7227875",
"0.71612287",
"0.71068895",
"0.71062714",
"0.6935171",
"0.69207716",
"0.6826871",
"0.66807395",
"0.6589879",
"0.6547784",
"0.6523073",
"0.64804363",
"0.64760613",
"0.6439925",
"0.64305127",
"0.6383687",
"0.6372895",
"0.6336047",
"0.63346505",
"0.6327... | 0.72547776 | 1 |
Update values in the array, to match their corresponding type, make sure the value is legal. | def _match_val_type(vals, bounds):
vals_new = []
for i, bound in enumerate(bounds):
_type = bound['_type']
if _type == "choice":
# Find the closest integer in the array, vals_bounds
# pylint: disable=cell-var-from-loop
vals_new.append(min(bound['_value'], key... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enforce_valuecheck(cls, val):\n if val:\n cls.__setitem__ = cls._setitem \n cls.__array_wrap__ = cls._array_wrap\n else:\n cls.__setitem__ = array.__setitem__\n cls.__array_wrap__ = array.__array_wrap__",
"def _check_type(self, new_value):\n ra... | [
"0.6558256",
"0.62737715",
"0.6026674",
"0.6002651",
"0.5997339",
"0.5921652",
"0.5896006",
"0.5893438",
"0.58869845",
"0.58062476",
"0.5762819",
"0.5733526",
"0.5699823",
"0.56924605",
"0.56693536",
"0.5662141",
"0.5661952",
"0.5655517",
"0.5626991",
"0.5582663",
"0.55766344... | 0.0 | -1 |
A function to find the maximum of the acquisition function It uses a combination of random sampling (cheap) and the 'LBFGSB' optimization method. First by sampling ``num_warmup`` points at random, and then running LBFGSB from ``num_starting_points`` random starting points. | def acq_max(f_acq, gp, y_max, bounds, space, num_warmup, num_starting_points):
# Warm up with random points
x_tries = [space.random_sample()
for _ in range(int(num_warmup))]
ys = f_acq(x_tries, gp=gp, y_max=y_max)
x_max = x_tries[ys.argmax()]
max_acq = ys.max()
# Explore the pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def acq_max(ac, gp, y_max, bounds, random_state, n_warmup=100000, n_iter=250):\n\n # Warm up with random points\n x_tries = random_state.uniform(bounds[:, 0], bounds[:, 1],\n size=(n_warmup, bounds.shape[0]))\n ys = ac(x_tries, gp=gp, y_max=y_max)\n x_max = x_tries[ys.... | [
"0.62064785",
"0.58723736",
"0.58493215",
"0.5803944",
"0.5755144",
"0.56878924",
"0.5686157",
"0.56028587",
"0.55518836",
"0.5547421",
"0.553826",
"0.5501719",
"0.5482462",
"0.54465926",
"0.5444505",
"0.54270524",
"0.5395608",
"0.5392558",
"0.5367147",
"0.53619885",
"0.53508... | 0.6244207 | 0 |
Upper Confidence Bound (UCB) utility function | def _ucb(x, gp, kappa):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mean, std = gp.predict(x, return_std=True)
return mean + kappa * std | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _ucb(self, s, k):\n if self.confidence_method == 'ucb-standard':\n ucb_factor = self._ucb_standard_factor(s, k)\n return self.mu[k][s] + ucb_factor\n elif self.confidence_method == 'ucb-standard-relaxed':\n ucb_factor = self._ucb_standard_factor(s, k) - self.ucb_eps\n return self.mu[k... | [
"0.6992317",
"0.6674039",
"0.66245663",
"0.6566002",
"0.6520581",
"0.64875233",
"0.64875233",
"0.64202017",
"0.6360865",
"0.6321332",
"0.6283501",
"0.6280488",
"0.6280488",
"0.6207781",
"0.61973965",
"0.61973965",
"0.61637783",
"0.6103145",
"0.6103145",
"0.5929752",
"0.588958... | 0.60484886 | 19 |
Expected Improvement (EI) utility function | def _ei(x, gp, y_max, xi):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mean, std = gp.predict(x, return_std=True)
z = (mean - y_max - xi)/std
return (mean - y_max - xi) * norm.cdf(z) + std * norm.pdf(z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _expected_inputs():",
"def experiment3():\n raise FAKE_ERROR",
"def expected(x, y):",
"def expected(x, y):",
"def expected(x, y):",
"def test_change_provisioned_throughput_usual_case():",
"def test_create_unexpected_problem(self):\n pass",
"def _expected_inputs():\n return 1",
... | [
"0.6556199",
"0.62118715",
"0.6149419",
"0.6149419",
"0.6149419",
"0.6034302",
"0.6023946",
"0.6023345",
"0.6000466",
"0.5943699",
"0.5942267",
"0.5891634",
"0.58835393",
"0.58281875",
"0.58138615",
"0.5776068",
"0.5775869",
"0.5775869",
"0.5754015",
"0.57419175",
"0.5737303"... | 0.0 | -1 |
Possibility Of Improvement (POI) utility function | def _poi(x, gp, y_max, xi):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mean, std = gp.predict(x, return_std=True)
z = (mean - y_max - xi)/std
return norm.cdf(z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_POI(self, location_list, moore_range):\n\n for r in range(len(location_list)):\n\n x = location_list[r][0]\n y = location_list[r][1]\n\n coordinates = []\n for i in range(moore_range):\n for j in range(moore_range):\n if x+i > 0 and len(self.grid_... | [
"0.5698189",
"0.56355613",
"0.53840846",
"0.536521",
"0.53135455",
"0.52214134",
"0.52092123",
"0.52030206",
"0.51916534",
"0.5132247",
"0.51293755",
"0.50819117",
"0.5057626",
"0.5044003",
"0.5012398",
"0.50025433",
"0.5001758",
"0.49940285",
"0.49913308",
"0.497202",
"0.496... | 0.50307685 | 14 |
Set all default values and start the step counter. If you want to run multiple trials with the same game you must explicitly call reset and if you are using bbopt agents you must pass a new _name_. | def reset(self, name=None, *agents, **named_agents):
self.name = (self.name if name is None else name)
self.env = {"game": self}
self.i = 0
self.set_defaults(self.agents)
self.add_agents(*agents, **named_agents)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self, total: int, name: str = None):\n\n # Clean the run\n self.test_run = RunElements()\n\n if name is not None:\n self.test_run.name = name\n\n self.test_run.total = total\n\n # Init the start run date\n from datetime import datetime\n self.te... | [
"0.6537875",
"0.6239453",
"0.5956907",
"0.57858336",
"0.57760304",
"0.57760304",
"0.5774393",
"0.5761878",
"0.573783",
"0.57337576",
"0.572438",
"0.5703894",
"0.5703594",
"0.56340945",
"0.5619564",
"0.55742717",
"0.5537968",
"0.5514695",
"0.548379",
"0.5452598",
"0.54435635",... | 0.58080703 | 3 |
Set the defaults for the given agents. | def set_defaults(self, agents):
for a in agents:
for k, v in a.get_defaults().items():
self.env[k] = v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_agents(self, agents):\n if self.single_agent_mode:\n raise ValueError(\n \"Setting agent in single agent mode or human mode is not allowed.\"\n )\n\n self.agents = agents\n # If at least one agent needs raw data, we set self.allow_raw_data = True\n ... | [
"0.7123729",
"0.6784273",
"0.67001903",
"0.6271799",
"0.61820745",
"0.6158705",
"0.6158705",
"0.6158705",
"0.59732956",
"0.59680927",
"0.59333277",
"0.58075494",
"0.5709466",
"0.56820816",
"0.5672702",
"0.567123",
"0.56681",
"0.564538",
"0.5598141",
"0.55943185",
"0.5541246",... | 0.8821057 | 0 |
Add the given agents/variables to the game. | def add_agents(*_coconut_match_args, **_coconut_match_kwargs):
_coconut_match_check_2 = False
_coconut_match_set_name_self = _coconut_sentinel
_coconut_match_set_name_agents = _coconut_sentinel
_coconut_match_set_name__set_defaults = _coconut_sentinel
_coconut_match_set_name_name... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_variables(self, variables):\n for variable in variables:\n self.variables.append(variable)",
"def add_to_simulation(self,agent):\n self.agents[agent.name] = agent\n self.network.add_node(agent)\n \n #agent given a grid queue at initialization\n grid_qu... | [
"0.6344226",
"0.6052576",
"0.6029992",
"0.59840566",
"0.57786566",
"0.57367676",
"0.5720258",
"0.5711132",
"0.565347",
"0.5633712",
"0.56207824",
"0.5576194",
"0.5569814",
"0.55281496",
"0.55243075",
"0.5455733",
"0.54406923",
"0.5374558",
"0.536636",
"0.5339504",
"0.53347415... | 0.0 | -1 |
Create a deep copy of the game. | def copy(self):
new_game = Game(self.name, *self.agents, independent_update=self.independent_update, default_run_kwargs=self.default_run_kwargs, _set_defaults=False)
new_game.i = self.i
new_game.env = self.env_copy()
new_game.env["game"] = new_game
return new_game | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n # create a new game and adjust it\n game_copy = Game()\n game_copy.turn_number = self.turn_number\n # copy player characters\n game_copy.player1 = Class.copy_monster(self.player1)\n game_copy.player2 = Class.copy_monster(self.player2)\n # reference... | [
"0.79710436",
"0.76304597",
"0.7624862",
"0.7530829",
"0.735413",
"0.7306646",
"0.7019784",
"0.6898342",
"0.6871119",
"0.67451036",
"0.6714296",
"0.6711205",
"0.6701819",
"0.6690582",
"0.6682592",
"0.66806793",
"0.6680429",
"0.66452944",
"0.66334337",
"0.66334337",
"0.6633433... | 0.86879694 | 0 |
Create a deep copy with new agents. | def copy_with_agents(self, *agents, **named_agents):
return self.copy().add_agents(*agents, **named_agents) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n new_game = Game(self.name, *self.agents, independent_update=self.independent_update, default_run_kwargs=self.default_run_kwargs, _set_defaults=False)\n new_game.i = self.i\n new_game.env = self.env_copy()\n new_game.env[\"game\"] = new_game\n return new_game",
... | [
"0.64163107",
"0.6415633",
"0.6331236",
"0.630281",
"0.6287885",
"0.6160814",
"0.61473835",
"0.6124182",
"0.6101197",
"0.6057805",
"0.60413456",
"0.602687",
"0.5934685",
"0.59219915",
"0.5908063",
"0.588306",
"0.5876571",
"0.5862516",
"0.5856848",
"0.58544517",
"0.5850434",
... | 0.67792404 | 0 |
Equivalent to .copy().reset(args, kwargs). | def clone(self, *args, **kwargs):
return self.copy().reset(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(*args):",
"def reset(*args):",
"def reset(*args):",
"def reset(self, *args, **kwargs):",
"def reset(self, *args):\n raise NotImplementedError",
"def reset(self, *args, **kwargs):\n ...",
"def reset(self, **kwargs):\n for k, v in kwargs.items():\n setattr(self, ... | [
"0.7387241",
"0.7387241",
"0.7387241",
"0.70620394",
"0.68944395",
"0.6861086",
"0.67391557",
"0.6706456",
"0.6441948",
"0.6430577",
"0.6393383",
"0.63583297",
"0.63236713",
"0.63117933",
"0.6244504",
"0.6244504",
"0.6244504",
"0.6244504",
"0.6244504",
"0.6244504",
"0.6244504... | 0.7875659 | 0 |
Add an agent to be called at interval _period_. | def attach(self, agent, period, name=None):
if isinstance(agent, Agent):
agent = agent.clone(name=name, period=period)
else:
agent = Agent(name, agent, period=period)
self.agents.append(agent)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def newperiod(self, period):\n logger.debug(u\"{} New Period\".format(self.joueur))\n self.currentperiod = RepetitionsEXPERIENCE_NOM_COURT(period)\n self.le2mserv.gestionnaire_base.ajouter(self.currentperiod)\n self.repetitions.append(self.currentperiod)\n yield (self.remote.call... | [
"0.63139504",
"0.5614659",
"0.5556661",
"0.54355025",
"0.5423074",
"0.5197547",
"0.51729447",
"0.5061283",
"0.5061283",
"0.5060387",
"0.504039",
"0.50223863",
"0.5007248",
"0.498901",
"0.49737817",
"0.4944588",
"0.49106753",
"0.48939013",
"0.48071665",
"0.47930655",
"0.478684... | 0.64388436 | 0 |
Perform one full step of action selection. | def step(self):
updating_env = {} if self.independent_update else self.env
for a in self.agents:
if self.i % a.period == 0:
action = a(self.env)
if a.name is not None:
updating_env[a.name] = action
if self.independent_update:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_action(self):\n pass",
"def perform_step(self, action):\n pass",
"def choose_action(self):\r\n pass",
"def select_action(self, state):",
"def select_action(self, state):\n pass",
"def chooseAction(self):\n print \"nothing\"\n pass",
"def step(self, a... | [
"0.7613646",
"0.7546346",
"0.73345476",
"0.7294785",
"0.7240225",
"0.7239332",
"0.7198726",
"0.7043319",
"0.6989192",
"0.69389737",
"0.69323885",
"0.68227607",
"0.6752335",
"0.6746938",
"0.6735803",
"0.67225367",
"0.670929",
"0.670929",
"0.6681697",
"0.6654639",
"0.6606508",
... | 0.0 | -1 |
Get a copy of the environment without the game. | def env_copy(self, env=None):
new_env = (clean_env(self.env) if env is None else env)
for a in self.agents:
for copy_name, copy_func in a.copiers.items():
_coconut_match_to_1 = new_env
_coconut_match_check_3 = False
_coconut_match_set_name_val ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clone(self):\n return Environment(self.local_variables, self.local_types)",
"def get_env_copy(self):\n if self._env:\n return cloudpickle.loads(cloudpickle.dumps(self._env))\n else:\n return None",
"def snapshot():\n return Env(os.environ)",
"def copy(sel... | [
"0.7264281",
"0.6938961",
"0.673083",
"0.6677482",
"0.6186581",
"0.6186581",
"0.61851823",
"0.6149314",
"0.61143965",
"0.6102495",
"0.60619986",
"0.6061919",
"0.6012602",
"0.5948327",
"0.5925403",
"0.58771855",
"0.5873079",
"0.5869495",
"0.5811715",
"0.57918173",
"0.5769533",... | 0.573807 | 22 |
Apply all relevant copiers for the given name to val. | def copy_var(self, name, val):
return self.env_copy({name: val})[name] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply(self, nameList, ctlFunc = lambda s, d: True):\n nameMap = self.transform(nameList)\n for src, dst in nameMap.items():\n if ctlFunc(src, dst):\n os.rename(src, dst)",
"def collect(self, name_to_arr):\n raise NotImplementedError",
"def invoke(self, op):\n ... | [
"0.45778036",
"0.43417755",
"0.4304802",
"0.4294516",
"0.4207937",
"0.41862413",
"0.41281107",
"0.411962",
"0.4097238",
"0.40670815",
"0.40624136",
"0.40540287",
"0.40497252",
"0.40347156",
"0.40284804",
"0.4018405",
"0.4010493",
"0.4001985",
"0.39933982",
"0.39705566",
"0.39... | 0.0 | -1 |
Exactly base_run but includes default_run_kwargs. | def run(self, max_steps=_sentinel, stop_at_equilibrium=_sentinel, use_tqdm=_sentinel, ensure_all_agents_run=_sentinel):
run_kwargs = self.default_run_kwargs.copy()
if max_steps is not self._sentinel:
run_kwargs["max_steps"] = max_steps
if stop_at_equilibrium is not self._sentinel:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, **kwargs):",
"def run(self, **kwargs):\n pass",
"def run(self, *args, **kwargs):\n pass",
"def run(self, **kwargs: Any) -> None:\n raise NotImplementedError",
"def test_with_defaults(self, _):\n result = self.run()\n return self._handle_test_result(result)",
"def ... | [
"0.6579317",
"0.64507556",
"0.620264",
"0.617488",
"0.6113276",
"0.61063653",
"0.6086408",
"0.6086408",
"0.6072939",
"0.6067173",
"0.60145223",
"0.5965127",
"0.59395444",
"0.59364635",
"0.5894508",
"0.5872491",
"0.57461816",
"0.5694729",
"0.56878316",
"0.5639522",
"0.56390077... | 0.0 | -1 |
Run iterative action selection for _max_steps_ or until equilibrium is reached if _stop_at_equilibrium_. | def base_run(self, max_steps=None, stop_at_equilibrium=False, use_tqdm=True, ensure_all_agents_run=True):
if max_steps is None and not stop_at_equilibrium:
raise ValueError("run needs either max_steps not None or stop_at_equilibrium True")
if stop_at_equilibrium:
prev_env = self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, max_steps: Optional[int] = None):\n step_count = 0\n max_exceeded = False\n log.info(f\"Starting exploration at {hex(self.simgr.active[0].addr)}\")\n while not max_exceeded and not self.simgr.complete():\n if len(self.simgr.active) == 0:\n log.war... | [
"0.6296464",
"0.6040132",
"0.5977998",
"0.5754107",
"0.56560564",
"0.5620944",
"0.54821754",
"0.548009",
"0.54243356",
"0.5329013",
"0.5317058",
"0.52521926",
"0.52232265",
"0.5180346",
"0.5173381",
"0.514013",
"0.51346976",
"0.51335865",
"0.50885445",
"0.50440264",
"0.503641... | 0.594794 | 3 |
Gather final parameters, running every agent again if _ensure_all_agents_run_. | def finalize(self, ensure_all_agents_run=True):
self.final_step = True
try:
if ensure_all_agents_run:
for _ in range(self.max_period):
self.step()
return self.env_copy()
finally:
self.final_step = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_all_agent(self):\n for a in self.agents:\n soft_update(a.target_actor, a.actor, self.tau)\n soft_update(a.target_critic, a.critic, self.tau)\n self.num_iteration += 1",
"def _apply_params(self):\n config = self.get_startup_config()\n # Pass true to _se... | [
"0.63572925",
"0.58247304",
"0.5736279",
"0.5681283",
"0.5670931",
"0.5564711",
"0.55375224",
"0.5520162",
"0.54561305",
"0.53911257",
"0.53798974",
"0.5360203",
"0.53507215",
"0.5349996",
"0.53491586",
"0.53387153",
"0.533229",
"0.5301695",
"0.5299479",
"0.5296466",
"0.52879... | 0.66002065 | 0 |
Plot _xs_ vs. _ys_ on the given axis with automatic or custom label names and _kwargs_ passed to plot. One of _xs_ or _ys_ may be None to replace with a sequence and must otherwise be a variable name, list, or function of the env. | def plot(self, ax, xs, ys, xlabel=None, ylabel=None, label=None, alpha=0.6, **kwargs):
if xs is None and ys is None:
raise ValueError("both of xs and ys cannot be None")
if isinstance(xs, Str):
xs_list = self.env[xs]
elif callable(xs):
xs_list = xs(self.env)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot(x, y, ns, **kwargs):\n if isinstance(x, str):\n x = [x]\n if isinstance(y, str):\n y = [y]\n \n def data_lookup(arr):\n arr_data = []\n arr_label = []\n for a_ in arr:\n if isinstance(a_, str):\n arr_label.append(a_)\n ... | [
"0.67550695",
"0.6138962",
"0.6067398",
"0.6053372",
"0.59938",
"0.59759384",
"0.597428",
"0.5972828",
"0.5935644",
"0.5918692",
"0.5905465",
"0.5859092",
"0.5807438",
"0.5805799",
"0.5759312",
"0.5742589",
"0.57250696",
"0.57136345",
"0.5699154",
"0.56960934",
"0.56851363",
... | 0.7535068 | 0 |
Obtains a ready to use style_transfer model file. | def get_pretrained_model(destination):
url = "https://storage.googleapis.com/download.magenta.tensorflow.org/models/ \
arbitrary_style_transfer.tar.gz"
os.system("curl -o arbitrary_style_transfer.tar.gz {0}".format(url))
with tarfile.open("arbitrary_style_transfer.tar.gz") as tar:
if not... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_style():\n\n style = os.path.join(os.path.dirname(__file__), \"templates\", \"style.css\")\n with open(style, \"r\") as opencss:\n return opencss.read().strip()",
"def get_model_and_assets():\n\n return common.read_model('cloth_corner.xml'),common.ASSETS",
"def _get_model():\n with ope... | [
"0.5762988",
"0.56735617",
"0.5595069",
"0.55804044",
"0.5348759",
"0.5340475",
"0.5333773",
"0.5213094",
"0.52033925",
"0.5180057",
"0.51697576",
"0.51513886",
"0.5150505",
"0.5148918",
"0.5148204",
"0.5123702",
"0.510021",
"0.50826496",
"0.5067555",
"0.50636643",
"0.5043299... | 0.6710467 | 0 |
Initialize with a lightfield in np.uint8 format. Optionally pass width and height of the canvas and sensitivity to the mouse. | def __init__(self, lf, width= None, height= None, sensitivity=2):
super().__init__(size=(width, height))
# Adjustable dimensions of the canvas and mouse sensitivity
self.width = width or lf.shape[-2]
self.height = height or lf.shape[-3]
self.dim = lf.ndim
self.se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, width, height):\n self.width = width\n self.height = height\n self.pixels = []\n self.r = 255\n self.g = 0\n self.b = 0\n self.pointSize = 30\n self.vr = 255\n self.vg = 200\n self.vb = 200\n self.glclear()",
"def __i... | [
"0.57412136",
"0.5677878",
"0.5673382",
"0.5629524",
"0.55770236",
"0.54769325",
"0.54700756",
"0.5453247",
"0.5440439",
"0.5382337",
"0.53306824",
"0.5293759",
"0.5290555",
"0.52754855",
"0.5219319",
"0.5217659",
"0.52054334",
"0.5137539",
"0.51299554",
"0.51256675",
"0.5121... | 0.72030973 | 0 |
Converts lightfield to np.uint8 with a white background and no alpha channel. | def convert_lf(self, lf):
lf = np.float32(lf)
if np.max(lf) > 1:
lf = lf/256
lf = np.uint8(lf*256)
if lf.shape[-1] > 3:
lf[lf[:,:,:,:,3] == 0] = (255,255,255,0) #convert alpha to white.
lf = lf[:,:,:,:,:3]
# while lf.ndim < 6:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_uint8(f):\n from numpy import array, clip, uint8\n\n img = array(clip(f,0,255),uint8)\n return img",
"def to_uint8(image):\n\tnp.clip(image, 0, 255, out=image)\n\treturn image.astype(np.uint8)",
"def float32_to_uint8(inputs):\n return np.uint8(np.clip(np.round(inputs * 255), 0, 255))",
"de... | [
"0.68301535",
"0.66983664",
"0.65882623",
"0.64155966",
"0.594869",
"0.592428",
"0.5862508",
"0.5862508",
"0.5721261",
"0.57063997",
"0.5657134",
"0.56439483",
"0.5588113",
"0.5578203",
"0.5555673",
"0.55530274",
"0.54991704",
"0.54975706",
"0.5489271",
"0.54839927",
"0.54407... | 0.6405364 | 4 |
Creates a downsampled version of the lightfield for fast rendering when dragging | def downsample_lf(self, converted_lf):
#For simplicity, we use every xth and yth pixel, instead of more complicated downsampling methods.
DOWNSAMPLE_DIMS = (150, 150) # make output shape of each image less than these dimensions.
step_size_x = int(converted_lf.shape[2]/DOWNSAMPLE_DIMS[0])+1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, lf, width= None, height= None, sensitivity=2):\n super().__init__(size=(width, height))\n \n # Adjustable dimensions of the canvas and mouse sensitivity\n self.width = width or lf.shape[-2]\n self.height = height or lf.shape[-3]\n self.dim = lf.ndim\n ... | [
"0.6677831",
"0.5521749",
"0.5468912",
"0.5435668",
"0.5366701",
"0.53488237",
"0.5338624",
"0.53239614",
"0.53061754",
"0.52855045",
"0.52810764",
"0.5236515",
"0.5223209",
"0.52158475",
"0.5215231",
"0.5215231",
"0.5210316",
"0.51868254",
"0.5168859",
"0.515881",
"0.5132155... | 0.49122146 | 48 |
Applies cv2.resize to each image of the lightfield (6dim) | def resize_lightfield(raw_lightfield, desired_size): # -> lightfield
if raw_lightfield.ndim == 6:
n_depth, n_cols, n_rows, *_ = raw_lightfield.shape
output_lightfield = np.empty([n_depth, n_cols, n_rows] + list(desired_size)[::-1] + [3], dtype=np.uint8)
for k, depth in enumerate(raw_lightf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_image(fl):\n #print(\"processing of images\")\n print(fl)\n img = cv2.imread(fl, cv2.IMREAD_COLOR)\n resized_img = cv2.resize(img, (146, 243), interpolation=cv2.INTER_CUBIC)\n return resized_img",
"def resizeImages(img_path,size=(50,50)):\n image = cv2.imread(img_path)\n resized ... | [
"0.6966502",
"0.6862376",
"0.6512721",
"0.6415095",
"0.6333766",
"0.62988776",
"0.6276172",
"0.627098",
"0.62702346",
"0.62640584",
"0.62184846",
"0.6149587",
"0.6065171",
"0.6062927",
"0.6053445",
"0.6053445",
"0.60356414",
"0.6007041",
"0.59975797",
"0.5984891",
"0.59809804... | 0.7499734 | 0 |
Creates a mission instance and append it to self.pendingMissions. | def create_mission(self, missionType, insertMode=InsertMode.Append,
duration=-1.0, **missionParameters):
if missionType not in self.mission_types():
raise ValueError("Cannot create a " + missionType + " for this aircraft.")
with self.lock:
if self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self):\n\t\tpm = PendingMission(mission_id=self.mission_id, kingdom_id=self.kingdom_id)\n\t\tpm.save()\n\t\t\n\t\treturn pm",
"def _add(self, mission):\n\t\tif mission.url not in self.pool:\n\t\t\tself.add_child(mission)\n\t\t\tself.pool[mission.url] = mission",
"def execute_mission(self):\n\n ... | [
"0.6725539",
"0.65166247",
"0.6410594",
"0.6080763",
"0.5992849",
"0.59163344",
"0.5906432",
"0.55863726",
"0.5561548",
"0.5487413",
"0.52339923",
"0.52303076",
"0.516617",
"0.51566476",
"0.51332045",
"0.51320595",
"0.5105025",
"0.5067188",
"0.50134295",
"0.4959583",
"0.49499... | 0.6345971 | 3 |
Returns either a new id or an error if impossible. | def new_mission_id(self):
newMissionId = self.lastMissionId + 1
if newMissionId in self.missions.keys():
# This should never happen but TODO strengthen it just in case
raise RuntimeError("Id of newly created mission already exists.")
return newMissionId | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def newId():\n global lastId\n lastId += 1\n return 'id%d' % lastId",
"def generate_a_new_primary_id():\n primary_id = str(uuid())\n response = client.query(\n KeyConditionExpression=Key('id').eq(primary_id)\n )\n if response[\"Items\"] == []:\n return primary_id\n else:\n ... | [
"0.6958756",
"0.6849629",
"0.6780738",
"0.660999",
"0.6598348",
"0.6515851",
"0.6355783",
"0.6355783",
"0.631555",
"0.6308556",
"0.6261798",
"0.6250714",
"0.6224159",
"0.6199575",
"0.6197145",
"0.6174544",
"0.6174544",
"0.6174544",
"0.6174544",
"0.6174544",
"0.6174544",
"0.... | 0.63075185 | 10 |
Convenience function for converting unpickled mission into mission instances. | def reload_missions(unpickledMissions):
for missionId, params in unpickledMissions.items():
# A true file format would be nice
if missionId == 'pendingMissions':
self.pendingMissions = params
continue
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deserialize(cls, serd):\r\n return cls(*serd)",
"def from_serializable(self, _):\n\n assert False, \"Not implemented\"",
"def from_serializable(self, _):\n\n assert False, \"not implemented\"",
"def _deserialize(cls, *args):\n return cls(*args)",
"def loads(cls, data: str) -... | [
"0.53312004",
"0.53231305",
"0.5300342",
"0.5205318",
"0.516451",
"0.51606286",
"0.51114714",
"0.5066639",
"0.5066639",
"0.5059862",
"0.50490946",
"0.50444037",
"0.50308233",
"0.50265086",
"0.5026082",
"0.50245154",
"0.50166994",
"0.50164783",
"0.5004725",
"0.49910545",
"0.49... | 0.66441584 | 0 |
Return current mission of the UAV (First in the MISSION_STATUS list) | def current_mission(self):
try:
return self.missions[self.status.mission_task_list[0]]
except KeyError:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mission(self) -> Optional[Mission]:\n # XXX: This currently can be `None`\n return self._mission",
"def _select_mission(self):\n if wait_until(self.emulator.is_ui_element_on_screen, ui_element=self.mission_selector_ui):\n logger.debug(f\"Selecting Epic Quest's mission: {self.m... | [
"0.6453036",
"0.5754468",
"0.566482",
"0.5642156",
"0.5633182",
"0.55878025",
"0.55187774",
"0.54879326",
"0.5467559",
"0.5432458",
"0.5419924",
"0.5392557",
"0.5386191",
"0.5379635",
"0.53663546",
"0.53264517",
"0.53114265",
"0.5309297",
"0.5300201",
"0.52791274",
"0.5263213... | 0.7763624 | 0 |
Returns mission instances waiting to be authorized. | def get_pending_missions(self):
res = [];
for missionId in self.pendingMissions:
res.append(self.missions[missionId])
return res; | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_finished_missions(self):\n self.lock.acquire()\n result = self.__Session.query(Mission).filter_by(status=3).all()\n self.lock.release()\n return result",
"def get_pending_instances(self):\n return [instance for instance in self.instances.itervalues()... | [
"0.6458847",
"0.6429118",
"0.59033716",
"0.5839291",
"0.5772119",
"0.57523173",
"0.57442504",
"0.55812573",
"0.5453152",
"0.54161006",
"0.539817",
"0.532769",
"0.5317852",
"0.5277706",
"0.52659917",
"0.5244693",
"0.52418125",
"0.5226842",
"0.5189649",
"0.51636565",
"0.5156569... | 0.5613463 | 7 |
Effectively sends a message to the aircraft with the mission. | def authorize_mission(self, missionId):
print('Authorizing mission', missionId, 'for aircraft', self.id);
if self.pendingMissions[0] != missionId:
# Error, pendingMission is a fifo. Cannot authorized mission other
# than the first one in the list.
if missionId in self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def msg(self, message, **kwargs):\n self.crafter.msg(message, {\"type\": \"crafting\"})",
"def send_message(self, message):\n pass",
"def sendMessage(self):\n #print('sendMessage\\r')\n self.pub.publish(Twist(linear=self.linearVector, angular=self.angularVector))",
"def send(self,... | [
"0.7096539",
"0.67297244",
"0.6647759",
"0.66430813",
"0.66201043",
"0.6618148",
"0.6599953",
"0.659871",
"0.6576239",
"0.6552405",
"0.6552405",
"0.6552405",
"0.6548948",
"0.6517222",
"0.64823836",
"0.64381874",
"0.64368165",
"0.6417102",
"0.6412376",
"0.6411487",
"0.6411316"... | 0.0 | -1 |
Sends a message to aircraft to add the mission, and removes it from pending mission list. | def do_validate_mission(self, missionId):
messageInterface.send(self.missions[missionId].build_message())
# if missionReceived:
self.pendingMissions.pop(0);
if self.outputBackupFile is not None:
with open(self.outputBackupFile, "ab") as f:
pickle.dump({'pendi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute_mission(self):\n\n self.pendingMissions = []\n messageInterface.send(self.currentMission.build_message())",
"def acceptMission(self, idMission):\r\n found = False\r\n for m in self.missions:\r\n if m.getId() == int(idMission):\r\n found = True\r\n... | [
"0.6676255",
"0.62046313",
"0.6060555",
"0.58366466",
"0.57652545",
"0.54939854",
"0.537888",
"0.5328158",
"0.5274882",
"0.5273589",
"0.52374923",
"0.5200469",
"0.51825595",
"0.51492417",
"0.5086411",
"0.50716436",
"0.5057806",
"0.5052343",
"0.50415266",
"0.50088197",
"0.4995... | 0.5223407 | 11 |
Removes a mission from self.pendingMissions without sending it to the aircraft. | def reject_mission(self, missionId):
print('Rejecting mission', missionId, 'for aircraft', self.id);
self.pendingMissions.remove(missionId)
if self.outputBackupFile is not None:
with open(self.outputBackupFile, "ab") as f:
pickle.dump({'pendingMissions' : self.pending... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self, pool_name, *missions):\n\t\tpool = getattr(self, pool_name)\n\n\t\t# check mission state\n\t\tmissions = [m for m in missions if m.state not in (\"ANALYZING\", \"DOWNLOADING\")]\n\n\t\tfor mission in missions:\n\t\t\tdel pool[mission.url]\n\n\t\tself.cleanup()\n\t\tself.bubble(\"MISSION_LIST_REARR... | [
"0.6742761",
"0.6493032",
"0.62579316",
"0.6030683",
"0.59712803",
"0.5816333",
"0.57373405",
"0.56957203",
"0.55815095",
"0.5552496",
"0.5463226",
"0.54363286",
"0.5421029",
"0.5399139",
"0.5335216",
"0.5306899",
"0.52801126",
"0.5279806",
"0.5276704",
"0.5248654",
"0.523948... | 0.71302354 | 0 |
Execute last mission in self.pendingMission To be removed when a real management is implemented | def execute_mission(self):
self.pendingMissions = []
messageInterface.send(self.currentMission.build_message()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear_mission(self):\n cmds = self.vehicle.commands\n self.vehicle.commands.clear()\n self.vehicle.flush()\n\n # After clearing the mission, we MUST re-download the mission from the \n # vehicle before vehicle.commands can be used again.\n # See https://github.com/dron... | [
"0.59472746",
"0.5922551",
"0.58533317",
"0.5841672",
"0.57032734",
"0.567079",
"0.5670382",
"0.5663894",
"0.5635181",
"0.5568485",
"0.5553974",
"0.5549903",
"0.55493927",
"0.55345213",
"0.55327535",
"0.55241054",
"0.55047387",
"0.5479589",
"0.5467998",
"0.5403099",
"0.53952"... | 0.8171932 | 0 |
Recognizes faces in given image using a trained KNN classifier | def model(cp_list,cp_now):
global record
distance_threshold = 0.5
model_path = "trained_knn_model.clf"
# Load a trained KNN model (if one was passed in)
with open(model_path, 'rb') as f:
knn_clf = pickle.load(f)
for X_img in cp_list:
# Load image file and find fac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recognize_faces(x_img,\n knn_clf=None,\n model_path=None,\n distance_threshold=0.3):\n print(\"Start recognize\")\n # Making a check\n if knn_clf is None and model_path is None:\n raise Exception(\"Must supply knn classifier either though... | [
"0.77550876",
"0.75428885",
"0.7375749",
"0.7374013",
"0.7353862",
"0.73482585",
"0.7172565",
"0.715228",
"0.7131715",
"0.71167624",
"0.70770067",
"0.69371593",
"0.69186586",
"0.6877429",
"0.684402",
"0.6839461",
"0.6835812",
"0.6753209",
"0.6740097",
"0.67068845",
"0.6688762... | 0.0 | -1 |
For each connection incoming to the current neuron, multiply the activation of the source neuron by delta | def calculate_gradients(self, neuron_idx, delta):
return {idx: self.net.neurons[link.source_neuron_idx].activation * delta for (idx, link) in
self.neuron_links[neuron_idx][0]} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_weights(self):\n activation, activation_p = self.feedforward()\n # initialize delta_weights\n delta_w = np.zeros(2)\n # simultaneous calculate delta_weights\n for i, element in enumerate(self.y):\n delta_w += (activation[i]-element)*(activation_p[i])*self.X[... | [
"0.640839",
"0.636345",
"0.6313031",
"0.6273738",
"0.626916",
"0.6262535",
"0.6209291",
"0.61244166",
"0.6094532",
"0.6080038",
"0.6061869",
"0.60613334",
"0.6029066",
"0.60126704",
"0.59933007",
"0.59771097",
"0.5976843",
"0.59726787",
"0.5964418",
"0.5952827",
"0.5932576",
... | 0.60301554 | 12 |
visualisation of the input image interest points | def viz1(img, interest_points, color='r'):
x = [a[1] for a in interest_points] #blob detection x axis
y = [a[0] for a in interest_points] #blob detection y axis
s = [a[2] for a in interest_points] #blob detected at sigma
plt.imshow(img, cmap='gray') #adding the input image to plot
for x, y, s in zip(x, y, s)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_image_sequence(self):\r\n\r\n imv = pg.ImageView()\r\n\r\n imv.show()\r\n\r\n imv.setImage(self.imageData)\r\n\r\n self.layout.addWidget(imv, 0, 0)\r\n\r\n\r\n\r\n avgImage = np.mean(self.imageData, axis=0)\r\n\r\n ima = pg.ImageView()\r\n\r\n ima.setImage(... | [
"0.640478",
"0.63847405",
"0.63375556",
"0.6287032",
"0.62815773",
"0.62655914",
"0.62209034",
"0.6200891",
"0.6193365",
"0.61490846",
"0.6137267",
"0.6074347",
"0.60507184",
"0.6024846",
"0.6012585",
"0.6002759",
"0.59989774",
"0.5996514",
"0.5971851",
"0.59677815",
"0.59248... | 0.7920742 | 0 |
sum of squared differences between values in patch1, patch2 | def count_difference(patch1, patch2):
return np.sum(np.square(patch1 - patch2)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum_of_squared_errors(P1,P2):\r\n return sum(euclidean_distance_3(p1,p2) for (p1,p2) in zip(P1,P2))",
"def sum_of_squared_errors(P1,P2):\r\n return sum(euclidean_distance_2(p1,p2) for (p1,p2) in zip(P1,P2))",
"def lsumdiffsquared(x,y):\r\n sds = 0\r\n for i in range(len(x)):\r\n sds = sd... | [
"0.64779776",
"0.64131725",
"0.64053327",
"0.6281641",
"0.6239101",
"0.6176397",
"0.6149316",
"0.6146877",
"0.6091206",
"0.6080922",
"0.6026293",
"0.60062623",
"0.59793645",
"0.59259605",
"0.5902211",
"0.5887385",
"0.5883692",
"0.58622724",
"0.5851945",
"0.58446634",
"0.57766... | 0.71716875 | 0 |
calculates all differences between features in two images and looking for the best matches filters the matches with difference lower or equal to threshold | def match2(img1, img2, coordinates1, coordinates2, PATCH_SIZE):
possible_matches = pd.DataFrame(columns=['feature1', 'feature2', 'diff'])
# iteration through all the possible pairs of features from img1 and img2
for (feature1, feature2) in product(coordinates1, coordinates2):
patch1 = make_patch(feature1, PATCH_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_feature_matching(desc1: np.ndarray, desc2: np.ndarray,\n match_calculator: Callable[[list, list], float]) -> list:\n\n # Check descriptors dimensions are 2\n assert desc1.ndim == 2, \"Descriptor 1 shape is not 2\"\n assert desc2.ndim == 2, \"Descriptor 2 shape is not 2\... | [
"0.720819",
"0.71327496",
"0.7099693",
"0.669751",
"0.66654724",
"0.6653938",
"0.6580145",
"0.6480495",
"0.6446135",
"0.64119065",
"0.6407737",
"0.637686",
"0.63641155",
"0.63494474",
"0.63486856",
"0.63310766",
"0.6314357",
"0.6308354",
"0.630553",
"0.63027436",
"0.62981975"... | 0.69057393 | 3 |
returns a list of coordinates that are their best matches both lefttoright and righttoleft | def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):
#creating patches for all points from img1 and img2
coord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]
coord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]
#... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def squareSearch( self, tTopLeft, tBottomRight, function, argsList ): #by LOQ\n\t\ttPaintedList = []\n\t\tresult = None\n\t\tfor x in range(tTopLeft[0], tBottomRight[0]+1):\n\t\t\tfor y in range(tTopLeft[1], tBottomRight[1]+1, -1): # edead: added -1, not sure why it didn't work before\n\t\t\t\tresult, bPaintPlot, ... | [
"0.6306889",
"0.6269362",
"0.6245228",
"0.62230194",
"0.62059367",
"0.6058234",
"0.6048335",
"0.6038003",
"0.6031063",
"0.59902644",
"0.59875417",
"0.5977457",
"0.5977241",
"0.5971195",
"0.59408545",
"0.59291446",
"0.5883519",
"0.58814394",
"0.58705986",
"0.5866219",
"0.58502... | 0.0 | -1 |
Used to provide statistics of the feature matching | def statistics(img1_blobs, img2_blobs, matches):
statistics = {}
statistics['#Interest Points in img1'] = len(img1_blobs)
statistics['#Interest Points in img2'] = len(img2_blobs)
statistics['Accepted Matches'] = len(matches)
dissimilarity = [match[2] for match in matches]
statistics['Mean of accepted matches'] =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_statistics(self):",
"def get_feature_statistics(results):\n to_be_deleted = []\n\n for result in results:\n if len(result.subset) != 6:\n to_be_deleted.append(result)\n\n length = len(results)\n feature_labels = datapoint_features\n statistics = {}\n\n for label in... | [
"0.6867412",
"0.67033225",
"0.6672618",
"0.6593359",
"0.6573829",
"0.6451946",
"0.644889",
"0.6402578",
"0.62315124",
"0.60831827",
"0.60485744",
"0.60403514",
"0.60318154",
"0.6018085",
"0.6008345",
"0.59858763",
"0.5985413",
"0.5965936",
"0.59554505",
"0.5938314",
"0.593117... | 0.6389583 | 8 |
visualisation of the feature matches of the two input images | def viz2(img1, interest_points1, img2, interest_points2, matches, PATCH_SIZE, threshold, min_sigma, max_sigma, num_sigma):
fig = plt.figure(figsize=(10,5))
ax1 = fig.add_subplot(121)
ax2 = fig.add_subplot(122)
#adding the two images to axes
ax1.imshow(img1, cmap='gray')
ax2.imshow(img2, cmap='gray')
posi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drawMatches(img1, kp1, img2, kp2, matches):\n\n # Create a new output image that concatenates the two images together\n # (a.k.a) a montage\n rows1 = img1.shape[0]\n cols1 = img1.shape[1]\n rows2 = img2.shape[0]\n cols2 = img2.shape[1]\n\n out = np.zeros((max([rows1,rows2]),cols1+cols2,3),... | [
"0.72223604",
"0.7210352",
"0.71759593",
"0.70562077",
"0.6995943",
"0.6994183",
"0.69791126",
"0.6944235",
"0.6933909",
"0.69263995",
"0.6851522",
"0.6807834",
"0.6802697",
"0.67325956",
"0.672665",
"0.6671003",
"0.6659896",
"0.66307634",
"0.66003436",
"0.6581556",
"0.657181... | 0.6730212 | 14 |
Returns an interface generator for |interface|. Called once for each interface that is not a callback function. | def InterfaceGenerator(self,
interface,
common_prefix,
super_interface_name,
source_filter):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def interface(self):\n\n data = ['[Interface]']\n for item in INTERFACE_KEYS:\n value = getattr(self, item, None)\n if value:\n data.append(value)\n\n return '''\n'''.join(data)",
"def from_interface(cls,interface,*args,**kargs):\n conf = Configura... | [
"0.5531334",
"0.5525865",
"0.5515438",
"0.5429782",
"0.53885365",
"0.528917",
"0.5258199",
"0.5203507",
"0.51787335",
"0.5171712",
"0.5062256",
"0.50554425",
"0.5033998",
"0.50218827",
"0.50152045",
"0.49968714",
"0.49968714",
"0.49968714",
"0.49968714",
"0.49968714",
"0.4996... | 0.75885934 | 1 |
Processes an interface that is a callback function. | def ProcessCallback(self, interface, info):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _ProcessCallback(self, interface, info, file_path):\n self._dart_callback_file_paths.append(file_path)\n code = self._emitters.FileEmitter(file_path)\n\n code.Emit(self._templates.Load('callback.darttemplate'))\n code.Emit('typedef $TYPE $NAME($PARAMS);\\n',\n NAME=interface.id,\n ... | [
"0.7388945",
"0.7388945",
"0.6996998",
"0.6519538",
"0.64906186",
"0.6338862",
"0.63003725",
"0.6191194",
"0.6136016",
"0.61295897",
"0.60569656",
"0.59520614",
"0.5946387",
"0.59059787",
"0.5898366",
"0.58923596",
"0.58829063",
"0.5862582",
"0.57494104",
"0.5743533",
"0.5733... | 0.8318254 | 1 |
Generates a typedef for the callback interface. | def _ProcessCallback(self, interface, info, file_path):
self._dart_callback_file_paths.append(file_path)
code = self._emitters.FileEmitter(file_path)
code.Emit(self._templates.Load('callback.darttemplate'))
code.Emit('typedef $TYPE $NAME($PARAMS);\n',
NAME=interface.id,
TYPE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_stub(cls: Any, klass: str = None):\n name = cls.contract_event_name\n # Create a new `TypedDict' definition\n tname = f'{name}MessageData'\n type_str = f\"{tname} = TypedDict('{tname}', {cls.schema.build_annotations()})\"\n return re.sub(r\"'?(typing|zv|builtin).(\\w*)'?\", r'\\2', type_str)... | [
"0.5992075",
"0.573953",
"0.5597767",
"0.5544411",
"0.54924864",
"0.54742986",
"0.544249",
"0.5441919",
"0.5394369",
"0.5379396",
"0.5371248",
"0.53518313",
"0.5293954",
"0.52628696",
"0.5260927",
"0.5225873",
"0.52097815",
"0.5184423",
"0.5177892",
"0.5174608",
"0.51654506",... | 0.59032494 | 2 |
Generates a lib file from a template and a list of files. Additional keyword arguments are passed to the template. Typically called from self.GenerateLibraries. | def _GenerateLibFile(self, lib_template, lib_file_path, file_paths,
**template_args):
# Load template.
template = self._templates.Load(lib_template)
# Generate the .lib file.
lib_file_contents = self._emitters.FileEmitter(lib_file_path)
# Emit the list of #source directives.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(\n files: List[Path] = typer.Argument(default=None, dir_okay=False, exists=True),\n template: Optional[str] = typer.Option(\n None, '--template', help='Name of template file'\n ),\n logo: Optional[str] = typer.Option(None, '--logo', help='Name of logo file'),\n logo_width: Optional[s... | [
"0.62458265",
"0.6209271",
"0.576154",
"0.5760894",
"0.56814146",
"0.56250805",
"0.56250805",
"0.5602158",
"0.5560846",
"0.55587965",
"0.55550075",
"0.54758096",
"0.54517764",
"0.5416102",
"0.5375398",
"0.53513515",
"0.5331048",
"0.5306458",
"0.52994704",
"0.52932733",
"0.525... | 0.7688387 | 1 |
Returns a set of names (strings) for members defined in a base class. | def _BaseDefines(self, interface):
def WalkParentChain(interface):
if interface.parents:
# Only consider primary parent, secondary parents are not on the
# implementation class inheritance chain.
parent = interface.parents[0]
if generator.IsDartCollectionType(parent.type.id):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_names(cls) -> List[str]:\n return list(member_name for member_name in cls.__members__.keys())",
"def base_field_names(self):\n return self._base_field_names()",
"def get_members():",
"def __iter__(self):\n return (base.__name__ for base in self.bases)",
"def getmembers(klass, m... | [
"0.73714197",
"0.6842522",
"0.67449003",
"0.6648812",
"0.6644145",
"0.65229374",
"0.65202487",
"0.64956546",
"0.64860773",
"0.62948424",
"0.6289807",
"0.6250491",
"0.6231375",
"0.62225986",
"0.62115324",
"0.6156694",
"0.6103977",
"0.60956585",
"0.6071582",
"0.60612726",
"0.60... | 0.0 | -1 |
Handle interfaces which must be hoisted to a common JSO base class | def ProcessMixins(self, mixins):
self._mixins = mixins | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def interfaces(self):",
"def interfaces(self):",
"def target_interfaces(self):",
"def target_interfaces(self):",
"def source_interfaces(self):",
"def source_interfaces(self):",
"def __dispatch__(interface, *args, **kwds):\n # Override in subclasses.\n return None",
"def __init__(self, i... | [
"0.6795294",
"0.6795294",
"0.64289284",
"0.64289284",
"0.63053995",
"0.63053995",
"0.625303",
"0.6079358",
"0.60775906",
"0.60730344",
"0.596415",
"0.59501296",
"0.5941285",
"0.5941285",
"0.5925071",
"0.5912999",
"0.5848995",
"0.58429646",
"0.58429646",
"0.58429646",
"0.58312... | 0.0 | -1 |
(tuple of int) > list of int | def checkio(numbers_array):
return sorted(numbers_array, key=abs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_list_of_int2(self):\n pass",
"def ints(xs: Iterable) -> list[int]:\n return lmap(int, xs)",
"def enumerate(x) -> List[Tuple[int, any]]:\n pass",
"def _to_tuple(values: Union[int, Iterable[int]]) -> Tuple[int, ...]:\n try:\n return tuple(values)\n except TypeError:\n ret... | [
"0.7457348",
"0.73328656",
"0.71052635",
"0.6862712",
"0.674535",
"0.65563023",
"0.6482003",
"0.6469235",
"0.64556104",
"0.62995285",
"0.6281323",
"0.6251934",
"0.6230251",
"0.6192311",
"0.6160767",
"0.6140819",
"0.6115585",
"0.6094271",
"0.6090769",
"0.60679245",
"0.60536647... | 0.0 | -1 |
Prints integers 1 through 100 sequentially in a ten by ten grid. | def ten_by_ten():
n=1
while n<=100:
if n%10 == 0:
print n
else:
print n,
n +=1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_grid():\n print_line()\n for line in range(2):\n for post in range(4):\n print_post()\n print_line()",
"def main():\n num_label = 1\n print('Printing ten random integers...')\n for i in range(NUM_RANDOM):\n print(str(num_label) + '):' + ' ' + str(random.ra... | [
"0.6569543",
"0.65679497",
"0.65646607",
"0.6375016",
"0.6352492",
"0.63101375",
"0.63097316",
"0.6271304",
"0.62634146",
"0.62566876",
"0.6251355",
"0.6243986",
"0.61811495",
"0.61799407",
"0.6137668",
"0.6136843",
"0.6128697",
"0.61076075",
"0.6107073",
"0.6088797",
"0.6087... | 0.7224331 | 0 |
Plot only the discontinuities (threshold minjump). | def discontour(
X: ArrayLike,
Y: ArrayLike,
Z: ArrayLike,
min_jump: float | None = None,
min_contour_length: float | None = None,
color: str | None = None,
linestyle: str | None = None,
alpha: float | None = None,
ax: plt.Axes | None = None,
):
x, y, Z = _get_xy_from_meshgrid(X, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def correctOverflows(self):\n plt.figure(11)\n plt.clf()\n plt.plot(self.raw['METROLOGY_DATA'].data.field('TIME'),\n self.raw['METROLOGY_DATA'].data.field('DELTAL') )\n plt.hlines([np.median(self.raw['METROLOGY_DATA'].data.field('DELTAL')),\n np.... | [
"0.5878892",
"0.5799819",
"0.57256097",
"0.5641487",
"0.5587996",
"0.5580949",
"0.54756176",
"0.54238796",
"0.5406325",
"0.5395504",
"0.53905535",
"0.53540117",
"0.5336111",
"0.5312041",
"0.5300851",
"0.53000534",
"0.52965117",
"0.5270959",
"0.5264748",
"0.5262121",
"0.525097... | 0.5528275 | 6 |
Initiates potential matrixes. v has boundary values and initial guess of 9 everywhere else vNew is a copy of v vExact is the exact analytical solution, 10 everywhere | def initiateVMatrixes():
global v, vNew, vExact
# Initialize the grid to 0
v = np.zeros((n+1, n+1)) # matrix of v, index are i: row, j:column
# Set the boundary conditions
for i in range(1,n):
v[0,i] = 10
v[n,i] = 10
v[i,0] = 10
v[i,n] = 10
# Exact solution... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate():\n global v, vNew, n, stepsToToleranceArray\n stepsToToleranceArray = []\n for n in nArray:\n print('Currently working with n = ', n)\n initiateVMatrixes()\n step = 0\n toleranceAcqurired = False\n while not toleranceAcqurired:\n step+=1\n ... | [
"0.6296358",
"0.6104716",
"0.59339637",
"0.5927703",
"0.5892736",
"0.58395153",
"0.58070314",
"0.58070314",
"0.5806339",
"0.5777011",
"0.5720289",
"0.5665781",
"0.55881447",
"0.5543292",
"0.55227625",
"0.552212",
"0.55061567",
"0.5506091",
"0.5480284",
"0.5473143",
"0.5467505... | 0.81041306 | 0 |
One checkerrelax iteration. v[i,j] is set as the avarage of its neighbours. | def relax_checker():
checker = 2
global v, vNew, n
for check in range(0,2):
for x in range(1,n):
for y in range(1,n):
if (x*(n+1) + y) % 2 == check:
v[x,y] = (v[x-1][y] + v[x+1][y] + v[x][y-1] + v[x][y+1])*0.25 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relaxVertex(self, v):\r\n for arc in self.graph.getAdj(v):\r\n neighbour = arc.getExtremityNode()\r\n if neighbour in self.closed_set:\r\n continue\r\n self.nb_relax_edges += 1\r\n new_dist = self.dists_so_far[v] + arc.getWeight()\r\n ... | [
"0.58130586",
"0.5767384",
"0.5755898",
"0.56656975",
"0.55695224",
"0.5568701",
"0.54769075",
"0.5428179",
"0.532105",
"0.5316448",
"0.5302247",
"0.529143",
"0.5271398",
"0.5224567",
"0.52211946",
"0.52183616",
"0.5149348",
"0.5143607",
"0.51420367",
"0.512446",
"0.5123433",... | 0.64761513 | 0 |
Main calculation function that first initalizes with initiateVMatrixes() and then uses relax() until v is within tolerance. 1. Iterate for n = 5, 10 2. Iterate for the range of n in nArray | def calculate():
global v, vNew, n, stepsToToleranceArray
stepsToToleranceArray = []
for n in nArray:
print('Currently working with n = ', n)
initiateVMatrixes()
step = 0
toleranceAcqurired = False
while not toleranceAcqurired:
step+=1
relax_ch... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initiateVMatrixes():\n global v, vNew, vExact\n # Initialize the grid to 0\n v = np.zeros((n+1, n+1)) # matrix of v, index are i: row, j:column\n # Set the boundary conditions\n for i in range(1,n):\n v[0,i] = 10\n v[n,i] = 10\n v[i,0] = 10\n v[i,n] = 10\n #... | [
"0.72669476",
"0.6188595",
"0.617031",
"0.6000074",
"0.5868834",
"0.58029294",
"0.5790344",
"0.57772875",
"0.5773755",
"0.5764524",
"0.56795913",
"0.5678016",
"0.5666207",
"0.56653416",
"0.5660726",
"0.5638518",
"0.5625004",
"0.5608089",
"0.56063926",
"0.56031847",
"0.5598390... | 0.84747493 | 0 |
Set lamp intensity in the range [0, 255] | def set_intensity(self, value):
self._spectra._set_intensity(self._name, value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setLum ( self, newlum ):\n if isinstance( newlum, int ):\n newlum /= 100\n if newlum > 1.0:\n newlum = 1.0\n if newlum < 0.0:\n newlum = 0.0\n self.l = newlum\n self.hsl[2] = newlum\n self.hsla[2] = newlum\n self.updateFromHsl(... | [
"0.6964496",
"0.63056415",
"0.6125189",
"0.6003263",
"0.5950201",
"0.59406114",
"0.5883176",
"0.5873168",
"0.58662814",
"0.5791942",
"0.5753206",
"0.5749067",
"0.5714888",
"0.57111955",
"0.56980145",
"0.5697827",
"0.56953377",
"0.5693024",
"0.56886524",
"0.5638608",
"0.563401... | 0.5315991 | 64 |
Produce a sequence of IOTool commands to enable and disable given Spectra lamps. Keyword arguments must be lamp names, as specified in the scope configuration. The values specified must be True to enable that lamp, False to disable, or None to do nothing (unspecified lamps are also not altered). | def _iotool_lamp_commands(self, **lamps):
commands = []
for lamp, enabled in lamps.items():
if enabled is None:
continue
pin = self._spconfig.IOTOOL_LAMP_PINS[lamp]
if enabled:
commands.append(self._iotool.commands.set_high(pin))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lamps(self, **lamp_parameters):\n self._set_state(lamp_parameters.items())",
"def all_lamps_slow():\n HOUSE = pre_process.get_house()\n\n for id_num, lamp in HOUSE.lamps.items():\n lamp.turn_on()\n lamp.set_transition_time(500)\n lamp.set_brigthness(254)\n lamp.send_c... | [
"0.5408981",
"0.5334635",
"0.4870005",
"0.48662877",
"0.48420778",
"0.48191276",
"0.48072937",
"0.47955528",
"0.47886992",
"0.4721579",
"0.46996623",
"0.46858644",
"0.46583447",
"0.46001318",
"0.46000558",
"0.45971966",
"0.45952561",
"0.45923606",
"0.45860842",
"0.4581945",
"... | 0.7597153 | 0 |
Return a dict mapping lamp names to tuples of (peak_wavelength, bandwidth), in nm, where bandwidth is the minimum width required to contain 75% of the spectral intensity of the lamp output. | def get_lamp_specs(self):
return {lamp: self._LAMP_SPECS[lamp] for lamp in self._available_lamps} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stubb_fitlers(wave_min=350., wave_max=1050):\n throughPath = os.path.join(getPackageDir('throughputs'), 'baseline')\n bps = {}\n lsstKeys = ['u', 'y']\n bps = {}\n for key in lsstKeys:\n bp = np.loadtxt(os.path.join(throughPath, 'total_'+key+'.dat'),\n dtype=zip(['w... | [
"0.601255",
"0.5668921",
"0.56192625",
"0.5610423",
"0.5600852",
"0.5598455",
"0.5598455",
"0.55850786",
"0.5564336",
"0.548778",
"0.5483454",
"0.5475823",
"0.5408421",
"0.5390249",
"0.5387245",
"0.5372645",
"0.5349552",
"0.53355616",
"0.5279677",
"0.52596873",
"0.52552986",
... | 0.54686236 | 12 |
Set a number of lamp parameters at once using keyword arguments, e.g. spectra.lamps(red_enabled=True, red_intensity=255, blue_enabled=False) Intensity values must be in the range [0, 255]. Valid lamp names can be retrieved with get_lamp_specs(). | def lamps(self, **lamp_parameters):
self._set_state(lamp_parameters.items()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setParameters(self, lam=45, **ukwargs):\n\t\tEvolutionStrategy1p1.setParameters(self, **ukwargs)\n\t\tself.lam = lam\n\t\tif ukwargs: logger.info('Unused arguments: %s' % (ukwargs))",
"def setLSLimits(*args):\n args[0].Limit.LSLimit.ls_limit = args[1]",
"def setLCLimits(*args):\n args[0].Limit.LCLimi... | [
"0.6750617",
"0.64525014",
"0.60727084",
"0.60697347",
"0.5997909",
"0.58803946",
"0.57326317",
"0.57204014",
"0.56676894",
"0.5609716",
"0.56088686",
"0.5593763",
"0.5560277",
"0.5505796",
"0.5471875",
"0.54498017",
"0.5446686",
"0.54387254",
"0.543406",
"0.5431726",
"0.5406... | 0.7872269 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.