eps:\\n pk = -Hk @ rosen_der(xk)\\n\\n xk_next = xk + alpha * pk\\n ink = 0\\n print(xk)\\n while rosen(xk_next) > rosen(xk) + c1 * alpha * (pk.T @ rosen_der(xk)):\\n \\\"\\\"\\\" find a step size that will satisfy Armijo-Goldstein inequality. Modify alpha. \\\"\\\"\\\"\\n alpha = 0.1* alpha\\n xk_next = xk + alpha * pk\\n ink += 1\\n\\n inner_k.append(abs(int(ink)))\\n\\n xk_next = xk + alpha * pk\\n\\n sk = xk_next - xk\\n\\n yk = rosen_der(xk_next) - rosen_der(xk)\\n\\n rho = 1 / (yk.T @ sk)\\n\\n Hk = np.copy((I - rho * sk @ yk.T) @ Hk @ (I - rho * yk @ sk.T) + rho * sk @ sk.T)\\n\\n old_xk = np.copy(xk)\\n xk = np.copy(xk_next)\\n\\n alpha_vec.append(alpha)\\n f_vec.append(rosen(xk))\\n grad_vec.append(np.linalg.norm(rosen_der(xk)))\\n alpha = np.copy(alpha_original)\\n print(f_vec[-1])\\n\\n k += 1\\n\\n return xk, k, inner_k, alpha_vec, f_vec, grad_vec\",\n \"def step(self, step=None):\\n\\n self.qtime = -time.time()\\n info(\\\"\\\\n Instanton optimization STEP %d\\\" % step, verbosity.low)\\n\\n if step == 0:\\n info(\\\" @GEOP: Initializing INSTANTON\\\", verbosity.low)\\n\\n if self.beads.nbeads == 1:\\n info(\\\" @GEOP: Classical TS search\\\", verbosity.low)\\n if self.hessian_init == 'true':\\n get_hessian(self.hessian, self.gm, self.beads.q)\\n else:\\n if ((self.beads.q - self.beads.q[0]) == 0).all(): # If the coordinates in all the imaginary time slices are the same\\n info(\\\" @GEOP: We stretch the initial geometry with an 'amplitud' of %4.2f\\\" % self.delta, verbosity.low)\\n imvector = get_imvector(self.initial_hessian, self.beads.m3[0].flatten())\\n for i in range(self.beads.nbeads):\\n self.beads.q[i, :] += self.delta * np.cos(i * np.pi / float(self.beads.nbeads - 1)) * imvector[:]\\n if self.hessian_init != 'true':\\n info(\\\" @GEOP: Hessian_init isn't true but we have stretched the polymer so we are going to compute the initial hessian anyway.\\\", verbosity.low)\\n self.hessian_init = 'true'\\n else:\\n info(\\\" @GEOP: Starting from the provided geometry in the extended phase space\\\", verbosity.low)\\n if not (self.initial_hessian is None):\\n raise ValueError(\\\" You have to provided a hessian with size (3xnatoms)^2 but also geometry in the extended phase space (nbeads>1). Please check the inputs\\\\n\\\")\\n\\n if self.hessian_init == 'true':\\n info(\\\" @GEOP: We are computing the initial hessian\\\", verbosity.low)\\n get_hessian(self.hessian, self.gm, self.beads.q)\\n\\n # Update positions and forces\\n self.old_x[:] = self.beads.q\\n self.old_u[:] = self.forces.pots\\n self.old_f[:] = self.forces.f\\n\\n if type(self.im.f) == type(None):\\n self.im(self.beads.q, ret=False) # Init instanton mapper\\n\\n if (self.old_x == np.zeros((self.beads.nbeads, 3 * self.beads.natoms), float)).all():\\n self.old_x[:] = self.beads.q\\n if self.exit:\\n softexit.trigger(\\\"Geometry optimization converged. Exiting simulation\\\")\\n\\n if len(self.fixatoms) > 0:\\n for dqb in self.old_f:\\n dqb[self.fixatoms * 3] = 0.0\\n dqb[self.fixatoms * 3 + 1] = 0.0\\n dqb[self.fixatoms * 3 + 2] = 0.0\\n\\n # Do one step. Update hessian for the new position. Update the position and force inside the mapper.\\n Instanton(self.old_x, self.old_f, self.im.f, self.hessian, self.hessian_update, self.hessian_asr, self.im, self.gm, self.big_step, self.opt, self.mode)\\n\\n # Update positions and forces\\n self.beads.q = self.gm.dbeads.q\\n self.forces.transfer_forces(self.gm.dforces) # This forces the update of the forces\\n\\n # Print current instanton geometry and hessian\\n if (self.save > 0 and np.mod(step, self.save) == 0) or self.exit:\\n print_instanton_geo(self.prefix, step, self.im.dbeads.nbeads, self.im.dbeads.natoms, self.im.dbeads.names,\\n self.im.dbeads.q, self.old_u, self.cell, self.energy_shift)\\n print_instanton_hess(self.prefix, step, self.hessian)\\n\\n # Exit simulation step\\n d_x_max = np.amax(np.absolute(np.subtract(self.beads.q, self.old_x)))\\n self.exit = self.exitstep(self.forces.pot, self.old_u.sum(), d_x_max, self.exit, step)\\n\\n # Update positions and forces\\n self.old_x[:] = self.beads.q\\n self.old_u[:] = self.forces.pots\\n self.old_f[:] = self.forces.f\",\n \"def gravg(f, seismic):\\n\\n fk = seismic.KneeFrequency\\n a = seismic.LowFrequencyLevel\\n gamma = seismic.Gamma\\n rho = seismic.Rho\\n # factor to account for correlation between masses\\n # and the height of the mirror above the ground\\n beta = seismic.Beta\\n h = seismic.TestMassHeight\\n c_rayleigh = seismic.RayleighWaveSpeed\\n\\n if 'Omicron' in seismic:\\n omicron = seismic.Omicron\\n else:\\n omicron = 1\\n\\n # a sort of theta function (Fermi distr.)\\n coeff = 3**(-gamma*f)/(3**(-gamma*f) + 3**(-gamma*fk))\\n\\n # modelization of seismic noise (vertical)\\n ground = a*coeff + a*(1-coeff)*(fk/f)**2\\n if 'Site' in seismic and seismic.Site == 'LLO':\\n ground = a*coeff*(fk/f) + a*(1-coeff)*(fk/f)**2\\n\\n # effective GG spring frequency, with G gravitational\\n fgg = sqrt(const.G * rho) / (2*pi)\\n\\n # fixed numerical factors, 5/9/06, PF\\n n = (beta*2*pi*(fgg**2/f**2)*ground)**2\\n\\n # The following two terms are corrections due to Jan Harms\\n # https://git.ligo.org/rana-adhikari/CryogenicLIGO/issues/45\\n # (1) projection of NN force onto the direction of the arm\\n n = n * 1/2\\n # (2) exponential cutoff at frequency (seismic speed)/(test mass height)\\n n = n * exp(-4*pi*f*h/c_rayleigh)\\n\\n # Feedforward cancellation\\n n /= (omicron**2)\\n\\n return n\",\n \"def reassignedSmethod(fx,nh=2**7-1,tstep=2**4,nfbins=2**9,df=1.0,alpha=4,\\r\\n thresh=.01,L=5): \\r\\n \\r\\n# if type(fx) is list:\\r\\n# fx=np.array(fx)\\r\\n# try:\\r\\n# fn,fm=fx.shape\\r\\n# if fm>fn:\\r\\n# fm,fn=fx.shape\\r\\n# except ValueError:\\r\\n# fn=len(fx)\\r\\n# fm=1\\r\\n# if fm>1:\\r\\n# print 'computing cross spectra'\\r\\n# #compute the analytic signal of function f and dctrend\\r\\n# #fa=sps.hilbert(dctrend(fx[0]))\\r\\n# #fb=sps.hilbert(dctrend(fx[1]))\\r\\n# fa=fx[0]\\r\\n# fb=fx[1]\\r\\n# fa=fa.reshape(fn)\\r\\n# fb=fb.reshape(fn)\\r\\n# else:\\r\\n# fa=fx\\r\\n# fa=fa.reshape(fn)\\r\\n# fb=fa.copy()\\r\\n\\r\\n \\r\\n nx=len(fx) \\r\\n \\r\\n #compute gaussian window\\r\\n h=gausswin(nh,alpha=alpha)\\r\\n #h=np.hanning(nh)\\r\\n lh=(nh-1)/2\\r\\n \\r\\n #compute ramp window\\r\\n th=h*np.arange(start=-lh,stop=lh+1,step=1)\\r\\n \\r\\n #compute derivative of window\\r\\n dh=dwindow(h)\\r\\n \\r\\n #make a time list of indexes\\r\\n tlst=np.arange(start=0,stop=nx,step=tstep)\\r\\n nt=len(tlst)\\r\\n \\r\\n #make frequency list for plotting\\r\\n flst=np.fft.fftfreq(nfbins,1./df)[:nfbins/2]\\r\\n \\r\\n #initialize some time-frequency arrays\\r\\n tfh=np.zeros((nfbins,nt),dtype='complex128')\\r\\n tfth=np.zeros((nfbins,nt),dtype='complex128')\\r\\n tfdh=np.zeros((nfbins,nt),dtype='complex128')\\r\\n \\r\\n #compute components for reassignment\\r\\n for ii,tt in enumerate(tlst):\\r\\n #create a time shift list\\r\\n tau=np.arange(start=-min([np.round(nx/2.),lh,tt-1]),\\r\\n stop=min([np.round(nx/2.),lh,nx-tt-1])+1)\\r\\n #compute the frequency spots to be calculated\\r\\n ff=np.remainder(nfbins+tau,nfbins)\\r\\n #make lists of data points for each window calculation\\r\\n xlst=tt+tau\\r\\n hlst=lh+tau\\r\\n normh=np.sqrt(np.sum(abs(h[hlst])**2))\\r\\n tfh[ff,ii]=fx[xlst]*h[hlst].conj()/normh\\r\\n tfth[ff,ii]=fx[xlst]*th[hlst].conj()/normh\\r\\n tfdh[ff,ii]=fx[xlst]*dh[hlst].conj()/normh\\r\\n \\r\\n #compute Fourier Transform\\r\\n spech=np.fft.fft(tfh,axis=0)\\r\\n specth=np.fft.fft(tfth,axis=0)\\r\\n specdh=np.fft.fft(tfdh,axis=0)\\r\\n \\r\\n #get only positive frequencies\\r\\n spech=spech[nfbins/2:,:]\\r\\n specth=specth[nfbins/2:,:]\\r\\n specdh=specdh[nfbins/2:,:]\\r\\n \\r\\n #check to make sure no spurious zeros floating around\\r\\n szf=np.where(abs(spech)<1.E-6)\\r\\n spech[szf]=0.0+0.0j\\r\\n zerofind=np.nonzero(abs(spech))\\r\\n twspec=np.zeros((nfbins/2,nt),dtype='float')\\r\\n dwspec=np.zeros((nfbins/2,nt),dtype='float')\\r\\n twspec[zerofind]=np.round(np.real(specth[zerofind]/spech[zerofind]))\\r\\n dwspec[zerofind]=np.round(np.imag((nfbins/2.)*specdh[zerofind]/\\r\\n spech[zerofind])/(np.pi))\\r\\n \\r\\n #get shape of spectrogram\\r\\n nf,nt=spech.shape\\r\\n \\r\\n #-----calculate s-method-----\\r\\n Llst=np.arange(start=-L/2+1,stop=L/2+1,step=1,dtype='int')\\r\\n\\r\\n #make and empty array of zeros\\r\\n sm=np.zeros_like(spech)\\r\\n \\r\\n #put values where L cannot be value of L, near top and bottom\\r\\n sm[0:L/2,:]=abs(spech[0:L/2,:])**2\\r\\n sm[-L/2:,:]=abs(spech[-L/2:,:])**2\\r\\n\\r\\n #calculate s-method\\r\\n for ff in range(L/2,nf-L/2-1):\\r\\n sm[ff,:]=2*np.real(np.sum(spech[ff+Llst,:]*spech[ff-Llst,:].conj(),\\r\\n axis=0))/L\\r\\n \\r\\n #------compute reassignment----- \\r\\n\\r\\n \\r\\n rtfarray=np.zeros((nfbins/2,nt))\\r\\n \\r\\n threshold=thresh*np.max(abs(sm))\\r\\n \\r\\n for nn in range(nt):\\r\\n for kk in range(nf):\\r\\n if abs(spech[kk,nn])>threshold:\\r\\n #get center of gravity index in time direction from spectrogram \\r\\n nhat=int(nn+twspec[kk,nn])\\r\\n nhat=int(min([max([nhat,1]),nt-1]))\\r\\n #get center of gravity index in frequency direction from spec\\r\\n khat=int(kk-dwspec[kk,nn])\\r\\n khat=int(np.remainder(np.remainder(khat-1,nfbins/2)+nfbins/2,\\r\\n nfbins/2))\\r\\n rtfarray[khat,nhat]=rtfarray[khat,nhat]+abs(sm[kk,nn])\\r\\n else:\\r\\n rtfarray[kk,nn]=rtfarray[kk,nn]+sm[kk,nn]\\r\\n\\r\\n #place values where L cannot be L \\r\\n rtfarray[:L/2,:]=abs(sm[:L/2,:])\\r\\n rtfarray[-L/2:,:]=abs(sm[-L/2:,:])\\r\\n \\r\\n tz=np.where(rtfarray==0)\\r\\n rtfarray[tz]=1.0\\r\\n \\r\\n tz=np.where(sm==0.0)\\r\\n sm[tz]=1.0 \\r\\n \\r\\n #scale\\r\\n rtfarray=abs(rtfarray)\\r\\n \\r\\n return rtfarray,tlst,flst,sm\",\n \"def refine(self, g, tick, known_inputs):\\n d = self._fetch_refiner_data(known_inputs)\\n \\n def refiner_data_local(input_values): \\n list_file=input_values[self.iterator_port]\\n input_list=self._load_list_from_file(list_file)\\n self.adjust_graph(g, tick, input_list)\\n \\n def on_failure(reason):\\n failure=Failure(ValueError(\\\"Exception occurred while refining tick %s. Reason: %s \\\\n\\\"%(tick, reason.getTraceback())))\\n d.errback(failure) \\n \\n d.addCallback(refiner_data_local)\\n d.addErrback(on_failure)\\n return d\",\n \"def refinemesh(prev_legs, state0_chaser, n_s):\\n scored_points = np.array([])\\n for leg in prev_legs:\\n scored_point = [*leg.dv, leg.t_leg, leg.score]\\n scored_points = np.append(scored_points, scored_point)\\n scored_points = scored_points.reshape(len(prev_legs), 5)\\n tri = Delaunay(scored_points[:, 0:4], qhull_options='QJ')\\n m_max = max(scored_points[:, 4]) # Maximum trajectory score of all simplices of the triangulation\\n if m_max == 0:\\n print('algorithm.py: m_max = 0 because all leg scores are 0!!!')\\n m_max = 1 # to avoid raising the dividing by 0 error if all leg scores are 0\\n g_max = 1\\n for q in tri.simplices:\\n smplx_scores = scored_points[:, 4][q] # scores of the points defining the simplex\\n aux = mean(smplx_scores)\\n if g_max < aux:\\n g_max = aux\\n\\n simplices_scored = []\\n for q in tri.simplices:\\n smplx_score = compute_simplexscore(q, scored_points, m_max, g_max)\\n # simp_scored = [smplx_score, q_vec]\\n simplices_scored.append([smplx_score, q])\\n sorted_simp_scores = sorted(simplices_scored, reverse=True) # ranks the simplices based on score\\n new_samples = samplewithinbestsimplices(sorted_simp_scores, tri.points, n_s)\\n\\n new_legs = []\\n for s in new_samples:\\n leg = Leg(s[0:3], s[3], state0_chaser)\\n new_legs.append(leg)\\n\\n return new_legs\",\n \"def example(self, s, d, s_len, d_len, snr):\\n\\t\\ts, d, x, n_frames = self.mix(s, d, s_len, d_len, snr)\\n\\t\\ts_STMS, _ = self.polar_analysis(s)\\n\\t\\td_STMS, _ = self.polar_analysis(d)\\n\\t\\tx_STMS, _ = self.polar_analysis(x)\\n\\t\\txi = self.xi(s_STMS, d_STMS) # instantaneous a priori SNR.\\n\\t\\tgamma = self.gamma(x_STMS, d_STMS) # instantaneous a posteriori SNR.\\n\\t\\tG = gfunc(xi=xi, gamma=gamma, gtype=self.gain)\\n\\t\\t# IRM = tf.math.sqrt(tf.math.truediv(xi, tf.math.add(xi, self.one)))\\n\\t\\treturn x_STMS, G, n_frames\",\n \"def example():\\n Optimizer = BFGS(f, g)\\n startPoint = 100 * numpy.ones(2);\\n res = Optimizer.optimize(startPoint,\\n epsilon=1e-5,\\n maxIterations=10)\\n print res\\n pass\",\n \"def force ( r, e ):\\n from math import isclose\\n\\n # Parameters of the Gay-Berne potential \\n # \\n # The key parameters are \\n # mu, nu ................ the exponents \\n # kappa and kappa' ....... the anisotropies \\n # kappa is the ratio of intermolecular separations \\n # sigma_e / sigma_s i.e. end-to-end / side-by-side \\n # kappa' is the ratio of well depths \\n # epsilon_s / epsilon_e i.e. side-by-side / end-to-end \\n # The derived parameters are chi and chi' \\n # chi = (kappa**2 - 1) / (kappa**2+1) \\n # chi' = (z - 1) / (z + 1)\\n # where z = (kappa') ** ( 1 / mu ) \\n # \\n # For convenience kappa' is spelt xappa, chi' is spelt xhi\\n # We choose units such that sigma_s = 1.0 and epsilon_0 = 1.0\\n # Two of the following three varieties should be commented out\\n\\n # Original Gay-Berne-deMiguel potential [J. Chem. Phys, 74, 3316; Mol. Phys. 74, 405 (1991)]\\n mu, nu, kappa, xappa = 2, 1, 3.0, 5.0\\n\\n # # Luckhurst-Phippen potential [Liq. Cryst., 8, 451 (1990)]\\n # mu, nu, kappa, xappa = 1, 2, 3.0, 5.0\\n\\n # # Berardi-Zannoni potential [J. Chem. Soc. Faraday Trans., 89, 4069 (1993)]\\n # mu, nu, kappa, xappa = 1, 3, 3.0, 5.0\\n\\n # Derived parameters\\n chi = (kappa**2 - 1.0) / (kappa**2+1.0)\\n xhi = (xappa**(1.0/mu) - 1.0) / (xappa**(1.0/mu) + 1.0)\\n\\n # Cutoff distance; normally we would use a larger value\\n r_cut = 4.0\\n \\n assert r.shape == (n,3), 'Incorrect shape of r'\\n assert e.shape == (n,3), 'Incorrect shape of e'\\n\\n # Notation to match appendix\\n i = 0\\n j = 1\\n\\n ei = e[i,:]\\n ej = e[j,:]\\n assert isclose(np.sum(ei**2),1.0), 'Non-unit vector {} {} {}'.format(*ei)\\n assert isclose(np.sum(ej**2),1.0), 'Non-unit vector {} {} {}'.format(*ej)\\n\\n rij = r[i,:] - r[j,:]\\n rij_mag = np.sqrt( np.sum(rij**2) ) # Magnitude of separation vector\\n sij = rij / rij_mag # Unit vector\\n ci = np.dot( ei, sij )\\n cj = np.dot( ej, sij )\\n cij = np.dot( ei, ej )\\n cp = ci + cj\\n cm = ci - cj\\n\\n # Sigma formula\\n cpchi = cp/(1.0+chi*cij)\\n cmchi = cm/(1.0-chi*cij)\\n sigma = 1.0/np.sqrt(1.0-0.5*chi*(cp*cpchi+cm*cmchi))\\n\\n # Epsilon formula\\n eps1 = 1.0/np.sqrt(1.0-(chi*cij)**2) # Depends on chi, not xhi\\n cpxhi = cp/(1.0+xhi*cij)\\n cmxhi = cm/(1.0-xhi*cij)\\n eps2 = 1.0-0.5*xhi*(cp*cpxhi+cm*cmxhi) # Depends on xhi\\n epsilon = (eps1**nu) * (eps2**mu)\\n\\n # Potential at rij\\n rho = rij_mag - sigma + 1.0\\n rho6 = 1.0 / rho**6\\n rho12 = rho6**2\\n rhoterm = 4.0*(rho12 - rho6) # Needed for forces and torques\\n drhoterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for forces and torques\\n pot = epsilon*rhoterm\\n\\n # Potential at r_cut\\n rho = r_cut - sigma + 1.0\\n rho6 = 1.0 / rho**6\\n rho12 = rho6**2\\n cutterm = 4.0*(rho12 - rho6) # Needed for cutoff forces and torques\\n dcutterm = -24.0 * (2.0 * rho12 - rho6) / rho # Needed for cutoff forces and torques\\n pot = pot - epsilon * cutterm\\n\\n # Derivatives of sigma\\n prefac = 0.5*chi*sigma**3\\n dsig_dci = prefac*(cpchi+cmchi)\\n dsig_dcj = prefac*(cpchi-cmchi)\\n prefac = prefac*(0.5*chi)\\n dsig_dcij = -prefac*(cpchi**2-cmchi**2)\\n\\n # Derivatives of epsilon\\n prefac = -mu*xhi*(eps1**nu)*eps2**(mu-1)\\n deps_dci = prefac*(cpxhi+cmxhi)\\n deps_dcj = prefac*(cpxhi-cmxhi)\\n prefac = prefac*(0.5*xhi)\\n deps_dcij = -prefac*(cpxhi**2-cmxhi**2) # From derivative of eps2\\n deps_dcij = deps_dcij + nu*(chi**2)*(eps1**(nu+2))*(eps2**mu)*cij # From derivative of eps1\\n\\n # Derivatives of potential\\n dpot_drij = epsilon * drhoterm\\n dpot_dci = rhoterm * deps_dci - epsilon * drhoterm * dsig_dci\\n dpot_dcj = rhoterm * deps_dcj - epsilon * drhoterm * dsig_dcj\\n dpot_dcij = rhoterm * deps_dcij - epsilon * drhoterm * dsig_dcij\\n\\n # Standard formula for forces and torque gradients\\n fij = -dpot_drij*sij - dpot_dci*(ei-ci*sij)/rij_mag - dpot_dcj*(ej-cj*sij)/rij_mag\\n gi = dpot_dci*sij + dpot_dcij*ej\\n gj = dpot_dcj*sij + dpot_dcij*ei\\n\\n # Derivatives of potential at cutoff\\n dpot_drij = epsilon * dcutterm\\n dpot_dci = cutterm * deps_dci - epsilon * dcutterm * dsig_dci\\n dpot_dcj = cutterm * deps_dcj - epsilon * dcutterm * dsig_dcj\\n dpot_dcij = cutterm * deps_dcij - epsilon * dcutterm * dsig_dcij\\n\\n # Standard formula for forces and torque gradients (without dpot_drij term)\\n fij = fij + dpot_dci*(ei-ci*sij)/rij_mag + dpot_dcj*(ej-cj*sij)/rij_mag\\n gi = gi - ( dpot_dci*sij + dpot_dcij*ej ) \\n gj = gj - ( dpot_dcj*sij + dpot_dcij*ei ) \\n\\n # Final forces and torques\\n f = np.empty_like(r)\\n t = np.empty_like(r)\\n f[i,:] = fij\\n f[j,:] = -fij\\n t[i,:] = -np.cross(ei,gi)\\n t[j,:] = -np.cross(ej,gj)\\n\\n return pot, f, t\",\n \"def fock_ueg(sys, G):\\n nbsf = sys.nbasis\\n nq = len(sys.qvecs)\\n assert nq == len(sys.vqvec)\\n\\n Fock = numpy.zeros((2, nbsf, nbsf), dtype=numpy.complex128)\\n Gkpq = numpy.zeros((2, nq), dtype=numpy.complex128)\\n Gpmq = numpy.zeros((2, nq), dtype=numpy.complex128)\\n\\n for s in [0, 1]:\\n coulomb_greens_function(nq, sys.ikpq_i, sys.ikpq_kpq,\\n sys.ipmq_i, sys.ipmq_pmq,\\n Gkpq[s], Gpmq[s], G[s])\\n\\n J = build_J_opt(nq, sys.vqvec, sys.vol, sys.nbasis,\\n sys.ikpq_i, sys.ikpq_kpq, sys.ipmq_i, sys.ipmq_pmq,\\n Gkpq, Gpmq)\\n\\n K = build_K_opt(nq, sys.vqvec, sys.vol, sys.nbasis,\\n sys.ikpq_i, sys.ikpq_kpq, sys.ipmq_i, sys.ipmq_pmq,\\n G)\\n\\n for s in [0, 1]:\\n Fock[s] = sys.H1[s] + J[s] + K[s]\\n\\n return Fock\",\n \"def set_gain_factor(self, s_gen_shape):\\n g = 1.\\n self.tc.set_gain_factor(g)\\n\\n Ips, _ = self.tc.RFS(\\n np.ones(s_gen_shape).astype('float32'),\\n np.zeros((1, self.n_t)).astype('float32'),\\n np.zeros((1, self.n_t)).astype('float32'))\\n g = (1. / Ips.max()).astype('float32')\\n self.tc.set_gain_factor(g)\",\n \"def gVI(g,rBC,lBC,time,npts):\\n #Important coeffcients\\n global gamma\\n gamma = g\\n global alpha\\n alpha = (gamma+1)/(gamma-1)\\n global beta\\n beta = (2*gamma)/(gamma-1)\\n global epsilon\\n epsilon = (2*gamma)/(gamma+1)\\n #Boundary conditions\\n global lbc\\n lbc = lBC\\n global rbc\\n rbc = rBC\\n #Time\\n global t\\n t = time\\n #points\\n global numPts\\n numPts = npts\\n #Speed of sound for states 1 and 5\\n global cL\\n cL = np.sqrt(gamma*lbc[0]/lbc[1])\\n global cR\\n cR = np.sqrt(gamma*rbc[0]/rbc[1])\",\n \"def newton_raphson(f,x0,iterations): \\n current = x0\\n fdash = differentiate_polynomial(f)\\n print(fdash)\\n for i in range(iterations): \\n current = current - evaluate_polynomial(f,current)/evaluate_polynomial(fdash,current)\\n return current\",\n \"def step(self, closure=None):\\n orig_loss,err,pred = closure()\\n loss = orig_loss\\n\\n group = self.param_groups[0]\\n lr = group['lr']\\n decay_lr = group['decay_lr']\\n max_iter = group['max_iter']\\n reg = group['reg']\\n backtrack = group['backtrack']\\n bt_alpha = group['bt_alpha']\\n bt_beta = group['bt_beta']\\n sketch_size = group['sketch_size']\\n tolerance = group['tolerance']\\n\\n #import pdb; pdb.set_trace()\\n n = err.shape[0] #batch size\\n #If sketching the jacobian, randomly select [sketch_size] samples\\n \\n if sketch_size is not None:\\n idx = torch.randperm(n)[:sketch_size]\\n else:\\n idx = torch.arange(n) #Don't sketch, use all samples\\n \\n w0 = nn.utils.parameters_to_vector(self._params) #weight parameters in vector form\\n \\n #Compute Gauss-Newton vector product \\n grad, ggnvp = _make_ggnvp(err,self._params,w0,n,reg,idx) #return gradient in vector form + ggnvp function\\n #Solve for the Conjugate Gradient Direction\\n dw, cost_log = _conjugate_gradient(ggnvp, grad, max_iter, tolerance)\\n\\n #Perform backtracking line search\\n val = loss + 0.5 * reg * torch.norm(w0)**2\\n fprime = -1*dw @ grad\\n \\n self.grad_update += 1\\n if backtrack > 0:\\n t = lr\\n\\n #TODO: If using backtracking, get new loss with (w0 - t*dw) as network parameters\\n bts = 0\\n alpha = bt_alpha\\n beta = bt_beta \\n while (loss + 0.5 * reg * torch.norm(w0 - t*dw)**2 > val + alpha * t * fprime):\\n t = beta * t\\n bts += 1\\n if bts > backtrack:\\n print('Maximum backtracking reached, accuracy not guaranteed')\\n break\\n elif decay_lr: #decay lr\\n t = lr/np.maximum(1, self.grad_update-10)\\n else: #use lr step-size\\n t = lr\\n\\n print('step size: {}'.format(t))\\n\\n #Update the model parameters\\n self._add_grad(-t, dw)\\n \\n return val, pred\",\n \"def __call__(cls, image):\\n\\n logger.info('Gain Correcting Image')\\n\\n saturate = 0.\\n gains = []\\n for amp in decaminfo.amps:\\n sec = section2slice(image['DATASEC' + amp])\\n gain = image['GAIN' + amp]\\n gains.append(gain)\\n image.data[sec] *= gain\\n\\n # Adjust the weight or variance image if present:\\n if image.weight is not None:\\n image.weight[sec] *= 1. / (gain * gain)\\n if image.variance is not None:\\n image.variance[sec] *= gain * gain\\n\\n # Adjust keywords\\n image['GAIN' + amp] = image['GAIN' + amp] / gain\\n image['SATURAT' + amp] = image['SATURAT' + amp] * gain\\n saturate = max(saturate, image['SATURAT' + amp])\\n # Scale the SKYVAR if it's already here\\n kw = 'SKYVAR' + amp\\n if kw in image.header.keys():\\n image[kw] = image[kw] * gain * gain\\n # The FLATMED will keep track of rescalings *after* gain:\\n image['FLATMED' + amp] = 1.\\n\\n # The SATURATE keyword is assigned to maximum of the two amps.\\n image['SATURATE'] = saturate\\n\\n # Some other keywords that we will adjust crudely with mean gain\\n # if they are present:\\n gain = np.mean(gains)\\n for kw in ('SKYBRITE', 'SKYSIGMA'):\\n if kw in image.header.keys():\\n image[kw] = image[kw] * gain\\n\\n # One other keyword to adjust:\\n image['BUNIT'] = 'electrons'\\n\\n logger.debug('Finished applying Gain Correction')\\n ret_code = 0\\n return ret_code\",\n \"def g1_iteration(complexsymmetric: bool, mol, atom, coord, nelec,\\n g0_ghf = None):\\n\\n if g0_ghf is None:\\n m = scf.RHF(mol)\\n m.verbose = 0\\n m.kernel()\\n g0_rhf = m.mo_coeff\\n g0 = rhf_to_ghf(g0_rhf, nelec)\\n else:\\n g0 = g0_ghf\\n\\n x = g0\\n s0 = mol.intor(\\\"int1e_ovlp\\\")\\n s0 = np.kron(np.identity(2), s0)\\n s1 = get_s1(mol, atom, coord)\\n p0 = get_p0(g0, complexsymmetric, nelec)\\n hcore0 = get_hcore0(mol)\\n pi0 = get_pi0(mol)\\n f0 = get_f0(hcore0, pi0, p0)\\n\\n hcore1 = get_hcore1(mol, atom, coord)\\n pi1 = get_pi1(mol, atom, coord)\\n\\n if not complexsymmetric:\\n\\n p0_x = np.linalg.multi_dot([x.T.conj(), p0, x])\\n s1_x = np.linalg.multi_dot([x.T.conj(), s1, x])\\n f0_x = np.linalg.multi_dot([x.T.conj(), f0, x])\\n pi0_x = np.einsum(\\\"pi,ijkl,jr,kq,sl->prqs\\\",\\n x.T.conj(), pi0, x, x, x.T.conj(),\\n optimize = 'optimal')\\n\\n hcore1_x = np.linalg.multi_dot([x.T.conj(), hcore1, x])\\n pi1_x = np.einsum(\\\"pi,ijkl,jr,kq,sl->prqs\\\",\\n x.T.conj(), pi1, x, x, x.T.conj(),\\n optimize = 'optimal')\\n\\n else:\\n\\n p0_x = np.linalg.multi_dot([x.T, p0, x])\\n s1_x = np.linalg.multi_dot([x.T, s1, x])\\n f0_x = np.linalg.multi_dot([x.T, f0, x])\\n pi0_x = np.einsum(\\\"pi,ijkl,jr,kq,sl->prqs\\\",\\n x.T, pi0, x, x, x.T,\\n optimize = 'optimal')\\n\\n hcore1_x = np.linalg.multi_dot([x.T, hcore1, x])\\n pi1_x = np.einsum(\\\"pi,ijkl,jr,kq,sl->prqs\\\",\\n x.T, pi1, x, x, x.T,\\n optimize = 'optimal')\\n\\n\\n eta0, g0_x = np.linalg.eig(f0_x)\\n index = np.argsort(eta0)\\n eta0 = eta0[index]\\n g0_x = g0_x[:, index] #Order g0 columns according to eigenvalues\\n\\n\\n g1_x_guess = np.zeros_like(g0)\\n g1_x = g1_x_guess\\n iter_num = 0\\n delta_g1_x = 1\\n\\n while delta_g1_x > 1e-14:\\n\\n iter_num += 1\\n p1_x = get_p1(g0_x, g1_x, complexsymmetric, nelec)\\n f1_x = get_f1(pi0_x, p0_x, hcore1_x, pi1_x, p1_x)\\n\\n g1_x_last = g1_x\\n g1_x = get_g1_x(f1_x, s1_x, eta0, nelec)\\n delta_g1_x = np.max(np.abs(g1_x - g1_x_last))\\n\\n g1 = np.dot(x, g1_x)\\n\\n return g1\",\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 compute_gains(self, t, add_noise=True):\\n #get the basis funtion at a time step\\n basis, Dbasis = self.get_basis(t)\\n\\n if t < self._time_steps-1:\\n basis_t_dt, _ = self.get_basis(t+1)\\n else:\\n basis_t_dt = np.zeros_like(basis)\\n\\n\\n #part 1 equation 46\\n B_pseudo = np.linalg.pinv(self._B)\\n\\n #equation 12 for t\\n Sigma_t = np.dot(np.dot(basis, self._sigma_W), basis.T)\\n\\n #equation 12 for t+dt\\n Sigma_t_dt = np.dot(np.dot(basis_t_dt, self._sigma_W), basis_t_dt.T)\\n\\n #Cross correlation between t, t+dt, Equation 49\\n Ct = np.dot(np.dot(basis, self._sigma_W), basis_t_dt.T)\\n\\n #System noise Equation 51\\n Sigma_s = (1./self._dt)* ( Sigma_t_dt - np.dot( np.dot( Ct.T, np.linalg.inv(Sigma_t) ), Ct) )\\n\\n #control noise Equation 52\\n Sigma_u = np.dot(np.dot(B_pseudo, Sigma_s), B_pseudo.T)\\n\\n #part 2 equation 46\\n tmp1 = np.dot(np.dot(Dbasis, self._sigma_W), basis.T)\\n\\n #part 3 equation 46\\n tmp2 = np.dot(self._A, Sigma_t) + 0.5*Sigma_s\\n\\n #compute feedback gain; complete equation 46\\n K = np.dot( np.dot(B_pseudo, (tmp1-tmp2) ), np.linalg.inv(Sigma_t))\\n\\n #part 1 equation 48\\n tmp3 = np.dot(Dbasis, self._mean_W)\\n\\n #part 2 equation 48\\n tmp4 = np.dot( (self._A + np.dot(self._B, K)), np.dot(basis, self._mean_W) )\\n\\n #compute feedforward gain; complete equation 48\\n k = np.dot(B_pseudo, (tmp3-tmp4))\\n\\n return K, k, Sigma_u\",\n \"def integrateGRayFlux(self, emin, emax, t_sec, g11, m_neV, bfield = 'jansson12', esteps = 100, eflux = False):\\n EMeV_array = np.logspace(np.log10(emin), np.log10(emax), esteps)\\n\\n dna_dedt = self.AvgALPflux(EMeV_array, t_sec, g11) # alps / MeV / s \\n pag = self.Pag(EMeV_array, g11, m_neV, bfield = bfield) # conversion prob\\n dng_dedt = dna_dedt * pag # gamma rays / MeV / s \\n flux = dng_dedt * self.fluxconstant # gamma rays / MeV / s / cm^2\\n\\n if eflux:\\n return simps(flux * EMeV_array * EMeV_array, np.log(EMeV_array))\\n else:\\n return simps(flux * EMeV_array, np.log(EMeV_array))\",\n \"def optg(self,maxIters=900):\\n mu = self.clone()\\n optimizer = {'uff': AllChem.UFFOptimizeMolecule, \\\\\\n 'mmff94':AllChem.MMFFOptimizeMolecule }[ self.forcefield.lower() ]\\n if optimizer(mu, maxIters=maxIters, ignoreInterfragInteractions=False):\\n print('FF OPTG failed')\\n #c = mu.GetConformer()\\n #if self.forcefield in ['mmff94',]:\\n # mp = AllChem.MMFFGetMoleculeProperties(mu)\\n # ff = AllChem.MMFFGetMoleculeForceField(mu, mp, \\\\\\n # ignoreInterfragInteractions=False)\\n #else:\\n # ff = AllChem.UFFGetMoleculeForceField(mu, \\\\\\n # ignoreInterfragInteractions=False)\\n #ff.Minimize(maxIts=maxIters)\\n coords_u = get_coords( mu )\\n self.coords = coords_u\\n self.update_coords(coords_u)\\n #self.energy = ff.CalcEnergy()\\n self.m = mu\\n self.atoms = cc.atoms(self.zs, coords_u)\\n self.iFFOpt = True\\n self._ds = ssd.squareform( ssd.pdist(self.coords) )\\n\\n obj = NBody(mu, wH=F, key='ia')\\n dangs = obj.dangs\\n #angs = obj.angs\\n iokg = True\\n #if not hasattr(self, 'dangs0'):\\n # raise Exception('you need to call optg_c() first??')\\n for k in dangs:\\n if abs(self.dangs0[k] - dangs[k]) > 60.:\\n iokg = False\\n break\\n self.iokg = iokg\",\n \"def _optimization_closure(self, iteration, step):\\n aug = self._get_augmentation(iteration)\\n if iteration == self.num_iter_per_step - 1:\\n reg_noise_std = 0\\n aug = 0\\n else:\\n reg_noise_std = (1 / 1000.) * (iteration // 400)\\n # creates left_net_inputs and right_net_inputs by adding small noise\\n clean_nets_inputs = [clean_net_input[aug] + (clean_net_input[aug].clone().normal_() * reg_noise_std)\\n for clean_net_input in self.clean_nets_inputs]\\n watermark_net_input = self.watermark_net_input[aug] # + (self.watermark_net_input[aug].clone().normal_() * reg_noise_std)\\n mask_net_input = self.mask_net_input[aug]\\n # applies the nets\\n self.clean_nets_outputs = [clean_net(clean_net_input) for clean_net, clean_net_input\\n in zip(self.clean_nets, clean_nets_inputs)]\\n self.watermark_net_output = self.watermark_net(watermark_net_input)\\n self.mask_net_output = self.mask_net(mask_net_input)\\n self.total_loss = 0\\n self.blur = 0\\n\\n self.total_loss += sum(self.l1_loss(self.watermark_net_output * self.mask_net_output +\\n clean_net_output * (1 - self.mask_net_output), image_torch[aug])\\n for clean_net_output, image_torch in zip(self.clean_nets_outputs, self.images_torch))\\n self.total_loss.backward(retain_graph=True)\",\n \"def _cg_solve(self, x, data, iters, lambd, tol):\\n b = np.zeros(\\n (\\n self.image_dim,\\n self.image_dim\\n ),\\n self.DTYPE\\n )\\n Ax = np.zeros(\\n (\\n self.image_dim,\\n self.image_dim\\n ),\\n self.DTYPE\\n )\\n\\n b = self.operator_rhs(data)\\n residual = b\\n p = residual\\n delta = np.linalg.norm(residual) ** 2 / np.linalg.norm(b) ** 2\\n self.res.append(delta)\\n print(\\\"Initial Residuum: \\\", delta)\\n\\n for i in range(iters):\\n Ax = self.operator_lhs(p)\\n Ax = Ax + lambd * p\\n alpha = np.vdot(residual, residual)/(np.vdot(p, Ax))\\n x[i + 1] = x[i] + alpha * p\\n residual_new = residual - alpha * Ax\\n delta = np.linalg.norm(residual_new) ** 2 / np.linalg.norm(b) ** 2\\n self.res.append(delta)\\n if delta < tol:\\n print(\\\"\\\\nConverged after %i iterations to %1.3e.\\\" %\\n (i+1, delta))\\n x[0] = b\\n return x[:i+1, ...]\\n if not np.mod(i, 1):\\n print(\\\"Residuum at iter %i : %1.3e\\\" % (i+1, delta), end='\\\\r')\\n\\n beta = (np.vdot(residual_new, residual_new) /\\n np.vdot(residual, residual))\\n p = residual_new + beta * p\\n (residual, residual_new) = (residual_new, residual)\\n x[0] = b\\n return x\",\n \"def wasserstein_g_update(loss, optimizer, var_list=None, global_step=None, name='g_update'):\\n # grads = optimizer.compute_gradients(loss, var_list=var_list)\\n # return optimizer.apply_gradients(grads, global_step=global_step, name=name)\\n\\n return optimizer.minimize(loss, global_step=global_step, var_list=var_list, name=name)\",\n \"def projection_derivatives(self, ifo, vals_dict, waveform_generator, i_params, releps=1e-4):\\n \\n vals = list(vals_dict.values())\\n keys = vals_dict.keys()\\n\\n\\n # set steps\\n if isinstance(releps, float):\\n eps = np.abs(vals) * releps\\n eps[eps == 0.] = releps # if any values are zero set eps to releps\\n elif isinstance(releps, (list, np.ndarray)):\\n if len(releps) != len(vals):\\n raise ValueError(\\\"Problem with input relative step sizes\\\")\\n eps = np.multiply(np.abs(vals), releps)\\n eps[eps == 0.] = np.array(releps)[eps == 0.]\\n else:\\n raise RuntimeError(\\\"Relative step sizes are not a recognised type!\\\")\\n\\n ## waveform as function of parameters\\n def waveform(parameters):\\n polarizations = waveform_generator.frequency_domain_strain(parameters)\\n return ifo.get_detector_response(polarizations, parameters)\\n \\n i = i_params[0]\\n\\n # initial parameter diffs\\n leps = eps[i]\\n\\n # get central finite difference\\n fvals = np.copy(vals)\\n bvals = np.copy(vals)\\n\\n # central difference\\n fvals[i] += 0.5 * leps # change forwards distance to half eps\\n bvals[i] -= 0.5 * leps # change backwards distance to half eps\\n\\n fvals_dict = dict(zip(keys, fvals))\\n bvals_dict = dict(zip(keys, bvals))\\n\\n grads = (waveform(fvals_dict) - waveform(bvals_dict)) / leps\\n \\n if len(i_params)>1:\\n for i in i_params[1:]:\\n # initial parameter diffs\\n leps = eps[i]\\n\\n # get central finite difference\\n fvals = np.copy(vals)\\n bvals = np.copy(vals)\\n\\n # central difference\\n fvals[i] += 0.5 * leps # change forwards distance to half eps\\n bvals[i] -= 0.5 * leps # change backwards distance to half eps\\n\\n fvals_dict = dict(zip(keys, fvals))\\n bvals_dict = dict(zip(keys, bvals))\\n cdiff = (waveform(fvals_dict) - waveform(bvals_dict)) / leps\\n\\n grads = np.vstack((grads, cdiff))\\n\\n return grads\",\n \"def __init__(self, fs=250, smoothing_win=20):\\n self.fs = fs\\n self.threshold = .35 # Generally between 0.3125 and 0.475\\n self.ns200ms = int(self.fs * .2)\\n self.r_peaks_buffer = [(0., 0.)]\\n self.noise_peaks_buffer = [(0., 0., 0.)]\\n self.prev_samples = np.zeros(smoothing_win)\\n self.prev_diff_samples = np.zeros(smoothing_win)\\n self.prev_times = np.zeros(smoothing_win)\\n self.prev_max_slope = 0\\n\\n self.bp_filter = ExGFilter(cutoff_freq=(1, 30), filter_type='bandpass', s_rate=fs, n_chan=1, order=3)\\n self.hamming_window = signal.windows.hamming(smoothing_win, sym=True)\\n self.hamming_window /= self.hamming_window.sum()\",\n \"def joss(sync, freq = 20, window_size = 8, shift = 4, errors=False):\\n\\n freq = 20\\n\\n ppg = sync.getSyncedPPG().resample(freq)\\n accel_x = sync.getSyncedAcceleration('x').resample(freq)[:ppg.size]\\n accel_y = sync.getSyncedAcceleration('y').resample(freq)[:ppg.size]\\n accel_z = sync.getSyncedAcceleration('z').resample(freq)[:ppg.size]\\n ecg = sync.getSyncedECG()\\n\\n \\n ppg = filtering.butter_bandpass_filter(ppg, 0.4, 4, 4)\\n accel_x = filtering.butter_bandpass_filter(accel_x, 0.4, 4, 4)\\n accel_y = filtering.butter_bandpass_filter(accel_y, 0.4, 4, 4)\\n accel_z = filtering.butter_bandpass_filter(accel_z, 0.4, 4, 4)\\n\\n hr = []\\n\\n eng = matlab.engine.start_matlab()\\n\\n loc = 121\\n bpm = 121\\n trap_count = 0\\n\\n if errors:\\n error_list = []\\n\\n\\n # Iterate through windows\\n start = 0\\n while (start + window_size) * freq < ppg.size:\\n window = np.arange(start * freq, (start+window_size) * freq, 1)\\n\\n spectrum, accel_max = joss_ssr(ppg[window].normalize(), accel_x[window].normalize(), \\n accel_y[window].normalize(), accel_z[window].normalize(), eng)\\n\\n if DEBUG:\\n print(\\\"At start={}, loc={} bpm={} trap_count={} spectrum_shape={}\\\".format(start, \\n loc, bpm, trap_count, spectrum.shape))\\n ecg_bpm = get_ecg_bpm(ecg, start, window_size)\\n print(\\\"ECG bpm = {}\\\".format(ecg_bpm))\\n plt.subplot(224)\\n plt.plot(spectrum)\\n plt.title(\\\"PPG\\\")\\n plt.gca().axvline(x=ecg_bpm, color='r')\\n plt.show()\\n\\n loc, bpm, trap_count = joss_spt(spectrum, freq, loc, bpm, trap_count)\\n\\n\\n if errors:\\n try:\\n ecg_bpm = get_ecg_bpm(ecg, start, window_size)\\n error = bpm - ecg_bpm\\n error_list.append(error)\\n except:\\n print(\\\"Error with HR calculation\\\")\\n \\n\\n \\n\\n\\n hr.append(bpm)\\n\\n start += shift \\n\\n eng.quit()\\n\\n if errors:\\n return error_list\\n\\n return np.array(hr)\",\n \"def __init__(self, sfreq, band_erp=None, n=None):\\n assert band_erp is not None\\n band_erp = np.array(band_erp, dtype=np.float64)\\n self._band_erp = band_erp\\n self.sfreq = sfreq\\n\\n if n is None:\\n n = int(sfreq / 5)\\n\\n if band_erp is not None:\\n if band_erp.size == 1:\\n b_erp = signal.firwin(n + 1, band_erp, fs=sfreq, pass_zero=True)\\n else:\\n b_erp = signal.firwin(n + 1, band_erp, fs=sfreq, pass_zero=False)\\n self.filter_erp = (b_erp, 1)\",\n \"def solve_nls (grad_f, hess_f, data, x_init=None, TOL=1e-6, rel_conv=True,\\r\\n gamma=1,MAX_ITER=100):\\r\\n\\r\\n d = 2*TOL\\r\\n k = 0\\r\\n\\r\\n xks = []\\r\\n\\r\\n t = data[0,:]\\r\\n y = data[1,:]\\r\\n\\r\\n if x_init is None:\\r\\n x_init = np.zeros(grad_f.shape[0])\\r\\n x = x_init\\r\\n\\r\\n xks.append(x)\\r\\n\\r\\n while (d > TOL and k < MAX_ITER):\\r\\n\\r\\n #Write your code here (This is very similar to the function above)\\r\\n\\r\\n return xks\",\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 gpt2_1w (station, dmjd,dlat,dlon,hell,it):\\n\\n# need to find diffpod and difflon\\n if (dlon < 0):\\n plon = (dlon + 2*np.pi)*180/np.pi;\\n else:\\n plon = dlon*180/np.pi;\\n# transform to polar distance in degrees\\n ppod = (-dlat + np.pi/2)*180/np.pi; \\n\\n# % find the index (line in the grid file) of the nearest point\\n# \\t % changed for the 1 degree grid (GP)\\n ipod = np.floor(ppod+1); \\n ilon = np.floor(plon+1);\\n \\n# normalized (to one) differences, can be positive or negative\\n#\\t% changed for the 1 degree grid (GP)\\n diffpod = (ppod - (ipod - 0.5));\\n difflon = (plon - (ilon - 0.5));\\n\\n\\n# change the reference epoch to January 1 2000\\n print('Modified Julian Day', dmjd)\\n dmjd1 = dmjd-51544.5 \\n\\n pi2 = 2*np.pi\\n pi4 = 4*np.pi\\n\\n# mean gravity in m/s**2\\n gm = 9.80665;\\n# molar mass of dry air in kg/mol\\n dMtr = 28.965E-3 \\n# dMtr = 28.965*10^-3 \\n# universal gas constant in J/K/mol\\n Rg = 8.3143 \\n\\n# factors for amplitudes, i.e. whether you want time varying\\n if (it==1):\\n print('>>>> no refraction time variation ')\\n cosfy = 0; coshy = 0; sinfy = 0; sinhy = 0;\\n else: \\n cosfy = np.cos(pi2*dmjd1/365.25)\\n coshy = np.cos(pi4*dmjd1/365.25) \\n sinfy = np.sin(pi2*dmjd1/365.25) \\n sinhy = np.sin(pi4*dmjd1/365.25) \\n cossin = np.matrix([1, cosfy, sinfy, coshy, sinhy])\\n# initialization of new vectors\\n p = 0; T = 0; dT = 0; Tm = 0; e = 0; ah = 0; aw = 0; la = 0; undu = 0;\\n undul = np.zeros(4)\\n Ql = np.zeros(4)\\n dTl = np.zeros(4)\\n Tl = np.zeros(4)\\n pl = np.zeros(4)\\n ahl = np.zeros(4)\\n awl = np.zeros(4)\\n lal = np.zeros(4)\\n Tml = np.zeros(4)\\n el = np.zeros(4)\\n#\\n pgrid, Tgrid, Qgrid, dTgrid, u, Hs, ahgrid, awgrid, lagrid, Tmgrid = read_4by5(station,dlat,dlon,hell)\\n#\\n for l in [0,1,2,3]:\\n KL = l #silly to have this as a variable like this \\n# transforming ellipsoidal height to orthometric height:\\n# Hortho = -N + Hell\\n undul[l] = u[KL] \\n hgt = hell-undul[l] \\n# pressure, temperature at the height of the grid\\n T0 = Tgrid[KL,0] + Tgrid[KL,1]*cosfy + Tgrid[KL,2]*sinfy + Tgrid[KL,3]*coshy + Tgrid[KL,4]*sinhy;\\n tg = float(Tgrid[KL,:] *cossin.T)\\n# print(T0,tg)\\n\\n p0 = pgrid[KL,0] + pgrid[KL,1]*cosfy + pgrid[KL,2]*sinfy + pgrid[KL,3]*coshy + pgrid[KL,4]*sinhy;\\n \\n# humidity \\n Ql[l] = Qgrid[KL,0] + Qgrid[KL,1]*cosfy + Qgrid[KL,2]*sinfy + Qgrid[KL,3]*coshy + Qgrid[KL,4]*sinhy;\\n \\n# reduction = stationheight - gridheight\\n Hs1 = Hs[KL]\\n redh = hgt - Hs1;\\n\\n# lapse rate of the temperature in degree / m\\n dTl[l] = dTgrid[KL,0] + dTgrid[KL,1]*cosfy + dTgrid[KL,2]*sinfy + dTgrid[KL,3]*coshy + dTgrid[KL,4]*sinhy;\\n \\n# temperature reduction to station height\\n Tl[l] = T0 + dTl[l]*redh - 273.15;\\n\\n# virtual temperature\\n Tv = T0*(1+0.6077*Ql[l]) \\n c = gm*dMtr/(Rg*Tv) \\n \\n# pressure in hPa\\n pl[l] = (p0*np.exp(-c*redh))/100 \\n \\n# hydrostatic coefficient ah\\n ahl[l] = ahgrid[KL,0] + ahgrid[KL,1]*cosfy + ahgrid[KL,2]*sinfy + ahgrid[KL,3]*coshy + ahgrid[KL,4]*sinhy;\\n \\n# wet coefficient aw\\n awl[l] = awgrid[KL,0] + awgrid[KL,1]*cosfy + awgrid[KL,2]*sinfy + awgrid[KL,3]*coshy + awgrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\n# water vapor decrease factor la - added by GP\\n lal[l] = lagrid[KL,0] + lagrid[KL,1]*cosfy + lagrid[KL,2]*sinfy + lagrid[KL,3]*coshy + lagrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\n# mean temperature of the water vapor Tm - added by GP\\n Tml[l] = Tmgrid[KL,0] + Tmgrid[KL,1]*cosfy + Tmgrid[KL,2]*sinfy + Tmgrid[KL,3]*coshy + Tmgrid[KL,4]*sinhy;\\n\\t\\t\\t\\t\\t \\t\\t \\n# water vapor pressure in hPa - changed by GP\\n e0 = Ql[l]*p0/(0.622+0.378*Ql[l])/100; # % on the grid\\n aa = (100*pl[l]/p0)\\n bb = lal[l]+1\\n el[l] = e0*np.power(aa,bb) # % on the station height - (14) Askne and Nordius, 1987\\n \\n dnpod1 = np.abs(diffpod); # % distance nearer point\\n dnpod2 = 1 - dnpod1; # % distance to distant point\\n dnlon1 = np.abs(difflon);\\n dnlon2 = 1 - dnlon1;\\n \\n# pressure\\n R1 = dnpod2*pl[0]+dnpod1*pl[1];\\n R2 = dnpod2*pl[2]+dnpod1*pl[3];\\n p = dnlon2*R1+dnlon1*R2;\\n \\n# temperature\\n R1 = dnpod2*Tl[0]+dnpod1*Tl[1];\\n R2 = dnpod2*Tl[2]+dnpod1*Tl[3];\\n T = dnlon2*R1+dnlon1*R2;\\n \\n# temperature in degree per km\\n R1 = dnpod2*dTl[0]+dnpod1*dTl[1];\\n R2 = dnpod2*dTl[2]+dnpod1*dTl[3];\\n dT = (dnlon2*R1+dnlon1*R2)*1000;\\n \\n# water vapor pressure in hPa - changed by GP\\n R1 = dnpod2*el[0]+dnpod1*el[1];\\n R2 = dnpod2*el[2]+dnpod1*el[3];\\n e = dnlon2*R1+dnlon1*R2;\\n \\n# hydrostatic\\n R1 = dnpod2*ahl[0]+dnpod1*ahl[1];\\n R2 = dnpod2*ahl[2]+dnpod1*ahl[3];\\n ah = dnlon2*R1+dnlon1*R2;\\n \\n# wet\\n R1 = dnpod2*awl[0]+dnpod1*awl[1];\\n R2 = dnpod2*awl[2]+dnpod1*awl[3];\\n aw = dnlon2*R1+dnlon1*R2;\\n \\n# undulation\\n R1 = dnpod2*undul[0]+dnpod1*undul[1];\\n R2 = dnpod2*undul[2]+dnpod1*undul[3];\\n undu = dnlon2*R1+dnlon1*R2;\\n\\n# water vapor decrease factor la - added by GP\\n R1 = dnpod2*lal[0]+dnpod1*lal[1];\\n R2 = dnpod2*lal[2]+dnpod1*lal[3];\\n la = dnlon2*R1+dnlon1*R2;\\n\\t\\t\\n# mean temperature of the water vapor Tm - added by GP\\n R1 = dnpod2*Tml[0]+dnpod1*Tml[1];\\n R2 = dnpod2*Tml[2]+dnpod1*Tml[3];\\n Tm = dnlon2*R1+dnlon1*R2; \\n\\n return p, T, dT,Tm,e,ah,aw,la,undu\",\n \"def importance_sampling_step(self, positions, analytic):\\n \\\"\\\"\\\"With upgrad method for suggetion of new positions.\\\"\\\"\\\"\\n \\\"\\\"\\\"Given through the Langevin equation.\\n D is the diffusion coefficient equal 0.5, xi is a gaussion random\\n variable and delta_t is the time step between 0.001 and 0.01\\\"\\\"\\\"\\n\\n D = 0.5\\n greens_function = 0.0\\n\\n if analytic == True:\\n F_old = self.w.quantum_force(positions)\\n else:\\n F_old = self.w.quantum_force_numerical(positions)\\n\\n # r = random.random()*random.choice((-1, 1))\\n # r = np.random.normal()\\n r = np.zeros(self.num_d)\\n for i in range(self.num_d):\\n r[i] = random.gauss(0, 1)\\n # Pick a random particle and calculate new position\\n random_index = random.randrange(len(positions))\\n new_positions = np.array(positions)\\n\\n term1 = D*F_old[random_index, :]*self.delta_t\\n term2 = r*np.sqrt(self.delta_t)\\n new_random_position = new_positions[random_index, :] + term1 + term2\\n new_positions[random_index, :] = new_random_position\\n\\n # Check if wave function is zero\\n test_wavefunction = self.w.wavefunction(new_positions)\\n if test_wavefunction**2 <= 1e-14:\\n pass\\n else:\\n prob_ratio = self.w.wavefunction_ratio(positions, new_positions)\\n\\n if analytic == True:\\n F_new = self.w.quantum_force(new_positions)\\n else:\\n F_new = self.w.quantum_force_numerical(new_positions)\\n\\n for i in range(self.num_p):\\n for j in range(self.num_d):\\n term1 = 0.5*((F_old[i, j] + F_new[i, j]) *\\n (positions[i, j] - new_positions[i, j]))\\n term2 = D*self.delta_t*(F_old[i, j] - F_new[i, j])\\n greens_function += term1 + term2\\n\\n greens_function = np.exp(greens_function)\\n\\n epsilon = np.random.sample()\\n acceptance_ratio = prob_ratio*greens_function\\n\\n if acceptance_ratio > epsilon:\\n positions = new_positions\\n self.s.distances_update(positions, random_index)\\n self.c += 1.0\\n\\n else:\\n pass\\n\\n return positions\",\n \"def main():\\n # Create a new instance of a high pass filter, using the default constructor\\n hpf = GRT.HighPassFilter()\\n\\n # Set the cutoff frequency of the filter to 2.0Hz\\n hpf.setCutoffFrequency(2, 1.0 / 1000.0)\\n\\n # Create some variables to help generate the signal data\\n num_seconds = 6 # The number of seconds of data we want to generate\\n t = 0 # This keeps track of the time\\n t_step = 1.0 / 1000.0 # This is how much the time will be updated at each iteration in the for loop\\n\\n # Add the freq rates\\n # The first value is the time in seconds and the second value is the frequency that should be set at that time\\n freq_rates = {0: 0.1, 1: 0.5, 2: 1, 3: 2, 4: 4, 5: 8, 6: 16}\\n\\n # Generate the signal and filter the data\\n for i in range(num_seconds * 1000):\\n # Check to see if we should update the freq rate to the next value\\n # Set the new frequency value\\n freq = [v for (k, v) in freq_rates.items() if k > (i / 1000)][0]\\n\\n # Generate the signal\\n signal = math.sin(t * math.tau * freq)\\n\\n # Filter the signal\\n filtered_value = hpf.filter(signal)\\n\\n # Print the signal and the filtered data\\n print(\\\"%.3f %.3f %.3f\\\" % (freq, signal, filtered_value))\\n\\n # Update the t\\n t += t_step\\n\\n # Save the HighPassFilter settings to a file\\n hpf.save(\\\"HighPassFilterSettings.grt\\\")\\n\\n # We can then load the settings later if needed\\n hpf.load(\\\"HighPassFilterSettings.grt\\\")\",\n \"def run(self):\\n\\n from dials.algorithms.refinement.refiner import phil_scope\\n params = phil_scope.fetch(source=phil.parse('')).extract()\\n\\n # disable outlier rejection for speed of refiner construction\\n params.refinement.reflections.outlier.algorithm='null'\\n\\n refiner = RefinerFactory.from_parameters_data_experiments(params,\\n self._reflections, self._experiments)\\n\\n d1 = self._experiments[0].detector\\n d2 = refiner.get_experiments()[0].detector\\n\\n assert d1.is_similar_to(d2)\\n print \\\"OK\\\"\\n return\",\n \"def derivatives(self, increment_filter):\\n ######################################################################\\n # derivatives fluid and mass balance are static\\n k = self.num_nw_fluids * 2 + 2\\n\\n ######################################################################\\n # derivatives for energy balance equation\\n for i in range(2):\\n self.jacobian[k, i, 0] = (\\n self.outl[i].h.val_SI - self.inl[i].h.val_SI)\\n self.jacobian[k, i, 2] = -self.inl[i].m.val_SI\\n\\n self.jacobian[k, 2, 2] = self.inl[0].m.val_SI\\n self.jacobian[k, 3, 2] = self.inl[1].m.val_SI\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified heat transfer\\n if self.Q.is_set:\\n self.jacobian[k, 0, 0] = (\\n self.outl[0].h.val_SI - self.inl[0].h.val_SI)\\n self.jacobian[k, 0, 2] = -self.inl[0].m.val_SI\\n self.jacobian[k, 2, 2] = self.inl[0].m.val_SI\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified heat transfer coefficient\\n if self.kA.is_set:\\n f = self.kA_func\\n self.jacobian[k, 0, 0] = (\\n self.outl[0].h.val_SI - self.inl[0].h.val_SI)\\n for i in range(4):\\n if not increment_filter[i, 1]:\\n self.jacobian[k, i, 1] = self.numeric_deriv(f, 'p', i)\\n if not increment_filter[i, 2]:\\n self.jacobian[k, i, 2] = self.numeric_deriv(f, 'h', i)\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified heat transfer coefficient\\n if self.kA_char.is_set:\\n f = self.kA_char_func\\n if not increment_filter[0, 0]:\\n self.jacobian[k, 0, 0] = self.numeric_deriv(f, 'm', 0)\\n if not increment_filter[1, 0]:\\n self.jacobian[k, 1, 0] = self.numeric_deriv(f, 'm', 1)\\n for i in range(4):\\n if not increment_filter[i, 1]:\\n self.jacobian[k, i, 1] = self.numeric_deriv(f, 'p', i)\\n if not increment_filter[i, 2]:\\n self.jacobian[k, i, 2] = self.numeric_deriv(f, 'h', i)\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified upper terminal temperature difference\\n if self.ttd_u.is_set:\\n f = self.ttd_u_func\\n for i in [0, 3]:\\n if not increment_filter[i, 1]:\\n self.jacobian[k, i, 1] = self.numeric_deriv(f, 'p', i)\\n if not increment_filter[i, 2]:\\n self.jacobian[k, i, 2] = self.numeric_deriv(f, 'h', i)\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified lower terminal temperature difference\\n if self.ttd_l.is_set:\\n f = self.ttd_l_func\\n for i in [1, 2]:\\n if not increment_filter[i, 1]:\\n self.jacobian[k, i, 1] = self.numeric_deriv(f, 'p', i)\\n if not increment_filter[i, 2]:\\n self.jacobian[k, i, 2] = self.numeric_deriv(f, 'h', i)\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified pressure ratio at hot side\\n if self.pr1.is_set:\\n self.jacobian[k, 0, 1] = self.pr1.val\\n self.jacobian[k, 2, 1] = -1\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified pressure ratio at cold side\\n if self.pr2.is_set:\\n self.jacobian[k, 1, 1] = self.pr2.val\\n self.jacobian[k, 3, 1] = -1\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified zeta at hot side\\n if self.zeta1.is_set:\\n f = self.zeta_func\\n if not increment_filter[0, 0]:\\n self.jacobian[k, 0, 0] = self.numeric_deriv(\\n f, 'm', 0, zeta='zeta1', inconn=0, outconn=0)\\n if not increment_filter[0, 1]:\\n self.jacobian[k, 0, 1] = self.numeric_deriv(\\n f, 'p', 0, zeta='zeta1', inconn=0, outconn=0)\\n if not increment_filter[0, 2]:\\n self.jacobian[k, 0, 2] = self.numeric_deriv(\\n f, 'h', 0, zeta='zeta1', inconn=0, outconn=0)\\n if not increment_filter[2, 1]:\\n self.jacobian[k, 2, 1] = self.numeric_deriv(\\n f, 'p', 2, zeta='zeta1', inconn=0, outconn=0)\\n if not increment_filter[2, 2]:\\n self.jacobian[k, 2, 2] = self.numeric_deriv(\\n f, 'h', 2, zeta='zeta1', inconn=0, outconn=0)\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified zeta at cold side\\n if self.zeta2.is_set:\\n f = self.zeta_func\\n if not increment_filter[1, 0]:\\n self.jacobian[k, 1, 0] = self.numeric_deriv(\\n f, 'm', 1, zeta='zeta2', inconn=1, outconn=1)\\n if not increment_filter[1, 1]:\\n self.jacobian[k, 1, 1] = self.numeric_deriv(\\n f, 'p', 1, zeta='zeta2', inconn=1, outconn=1)\\n if not increment_filter[1, 2]:\\n self.jacobian[k, 1, 2] = self.numeric_deriv(\\n f, 'h', 1, zeta='zeta2', inconn=1, outconn=1)\\n if not increment_filter[3, 1]:\\n self.jacobian[k, 3, 1] = self.numeric_deriv(\\n f, 'p', 3, zeta='zeta2', inconn=1, outconn=1)\\n if not increment_filter[3, 2]:\\n self.jacobian[k, 3, 2] = self.numeric_deriv(\\n f, 'h', 3, zeta='zeta2', inconn=1, outconn=1)\\n k += 1\\n\\n ######################################################################\\n # derivatives for additional equations\\n self.additional_derivatives(increment_filter, k)\",\n \"def resample(s, up, down, axis=0, fc='nn', **kwargs):\\n\\n # BUG FIX: if up==down, sig.fir_filter_design.firwin will throw\\n # an exception. In compute_filt that is OK (the user is assumed\\n # to know what they are doing if they use that function), but in\\n # the \\\"user-friendly\\\" resample function, we should just silently\\n # return a copy of the input. (Principle of least surprise)\\n # Thanks to johndoe46 on github for pointing this out.\\n if up==down:\\n return np.array(s)\\n\\n # from design parameters, find the generative parameters\\n N, beta, As = disambiguate_params(**kwargs)\\n\\n # check if a resampling filter with the chosen parameters already exists\\n params = (up, down, fc, beta, N)\\n if params in _precomputed_filters.keys():\\n # if so, use it.\\n filt = _precomputed_filters[params]\\n else:\\n # if not, generate filter, store it, use it\\n filt = compute_filt(up, down, fc, beta=beta, N=N)\\n _precomputed_filters[params] = filt\\n\\n return sig.resample_poly(s, up, down, window=np.array(filt), axis=axis)\",\n \"def analyze_fringes(self, f0=None):\\r\\n phase_roi, plot_roi = self.phase_roi, self.plot_roi\\r\\n roi_phase = (slice(phase_roi[2], phase_roi[3]),\\r\\n slice(phase_roi[0], phase_roi[1]))\\r\\n roi_plot = (slice(plot_roi[0] - phase_roi[2], plot_roi[1] - phase_roi[2]),\\r\\n slice(0, -1)) # subslice of phase_roi\\r\\n\\r\\n self.S = S = self.image[roi_phase] # signal\\r\\n\\r\\n if self.carrier_period is None:\\r\\n flim = (5, None)\\r\\n else:\\r\\n f0 = np.shape(S)[0] / self.carrier_period\\r\\n flim = (int(0.7*f0), int(1.4*f0))\\r\\n\\r\\n A, W, dphi2, U2 = ftm_analyze(S, flim=flim)\\r\\n\\r\\n self.A, self.W, self.dphi2, self.U2 = A, W, dphi2, U2\\r\\n \\r\\n f1 = mod_average(U2) # 2D\\r\\n f2 = mod_ave2(U2[roi_plot]) # 1D\\r\\n\\r\\n self.f1, self.f2 = f1, f2\",\n \"def solve(\\n self,\\n projections: Projections,\\n initial_squad: Squad,\\n next_gw: int = None,\\n force_chips: Dict[int, str] = None,\\n force_players: Dict[str, list] = None,\\n force_transfers: Dict[int, dict] = None,\\n price_changes: Dict[str, Iterable] = None,\\n time_limit: float = None,\\n optimizer: type = pulp.GUROBI,\\n message: bool = True\\n ):\\n if next_gw is None:\\n next_gw = sorted([int(column.split('_')[0]) for column in projections.columns if column.endswith('Pts')])[0]\\n # Set up useful references\\n initial_players = initial_squad.players\\n initial_itb = initial_squad.itb\\n initial_fts = initial_squad.fts\\n active_chip = initial_squad.active_chip\\n players = projections.index\\n positions = ('G', 'D', 'M', 'F')\\n teams = projections['Team'].unique()\\n gw_interval = list(range(next_gw, next_gw + self.horizon))\\n\\n # Initialise optimisation model\\n prob = LpProblem('FPL_transfer_optimisation')\\n\\n # Initialise decision variables\\n default_args = {'index': players, 'columns': gw_interval, 'column_type': 'gw', 'model': prob}\\n lineup = DecisionMatrix.lp_variable('lineup', **default_args)\\n bench_gk = DecisionMatrix.lp_variable('bench_gk', **default_args)\\n bench_1 = DecisionMatrix.lp_variable('bench_1', **default_args)\\n bench_2 = DecisionMatrix.lp_variable('bench_2', **default_args)\\n bench_3 = DecisionMatrix.lp_variable('bench_3', **default_args)\\n squad = DecisionMatrix.lp_variable('squad', **default_args)\\n prob += squad == lineup + bench_gk + bench_1 + bench_2 + bench_3\\n squad[next_gw - 1] = pd.Series(squad.index).isin(initial_players).astype(int)\\n captain = DecisionMatrix.lp_variable('captain', **default_args)\\n vice_captain = DecisionMatrix.lp_variable('vice_captain', **default_args)\\n transfer_in = DecisionMatrix.lp_variable('transfer_in', **default_args)\\n transfer_out = DecisionMatrix.lp_variable('transfer_out', **default_args)\\n itb = DecisionSeries(data=[initial_itb], index=[next_gw - 1], model=prob)\\n # itb is previous GW's itb + revenue from outgoing players + cost of incoming players\\n for i, gw in enumerate(gw_interval):\\n itb[gw] = itb[gw - 1] + (transfer_out[gw] * projections['SV']).sum() - \\\\\\n (transfer_in[gw] * projections['BV']).sum() - self.budget_decay_rate\\n\\n # Add problem constraints to optimisation model\\n prob += squad == squad.lag(1) + transfer_in - transfer_out # New squad is previous squad plus transfers\\n prob += squad.drop(next_gw - 1, axis=1) <= 1 # Each player can only appear in the squad once\\n prob += lineup.sum() == 11 # Lineup contains 11 players\\n prob += bench_gk.sum() == 1 # There is 1 bench GK;\\n prob += bench_1.sum() == 1 # 1 1st bench slot;\\n prob += bench_2.sum() == 1 # 1 2nd bench slot;\\n prob += bench_3.sum() == 1 # 1 3rd bench slot;\\n prob += captain.sum() == 1 # 1 Captain;\\n prob += transfer_out.sum() == transfer_in.sum() # Transfers in must be same as transfers out\\n\\n prob += vice_captain.sum() == 1 # 1 vice-captain\\n prob += captain <= lineup # Captain must be in lineup\\n prob += vice_captain <= lineup # Vice-captain must be in lineup\\n prob += captain + vice_captain <= 1 # Captain and vice-captain must be different players\\n for position, limit in zip(positions, (2, 5, 5, 3)):\\n prob += squad[projections['Pos'] == position].sum() == limit # Set squad position structure\\n for team in teams:\\n prob += squad[projections['Team'] == team].sum() <= 3 # No more than 3 players from each team\\n if self.exclude_everton:\\n prob += squad[projections['Team'] == 'Everton'].sum() == 0 # Option to exclude Everton players\\n prob += bench_gk <= (projections['Pos'] == 'G') # Bench GK must be a goalkeeper\\n prob += (lineup * (projections['Pos'] == 'G')).sum() == 1 # There must be 1 goalkeeper in lineup\\n prob += (lineup * (projections['Pos'] == 'D')).sum() >= 3 # There must be at least 3 defenders in lineup\\n prob += itb[[False] + [True] * self.horizon] >= 0 # The itb amount must be non-negative for future GWs\\n\\n # Set up transfer logic\\n transfer_args = {'index': gw_interval, 'column_type': 'gw', 'model': prob, 'cat': 'Integer'}\\n aux = DecisionSeries.lp_variable('aux', **transfer_args)\\n free_transfers = DecisionSeries(data=[initial_fts], index=[next_gw - 1], model=prob) + DecisionSeries.\\\\\\n lp_variable('free_transfers', **transfer_args)\\n penalised_transfers = DecisionSeries.lp_variable('penalised_transfers', **transfer_args)\\n transfer_counts = transfer_in.sum()\\n frees_minus_transfers = free_transfers.lag(1) - transfer_counts\\n lower_bound = aux * 15 - 14\\n upper_bound = aux * 2\\n if initial_fts > 1:\\n prob += transfer_counts[next_gw] >= 1\\n prob += frees_minus_transfers >= lower_bound\\n prob += frees_minus_transfers <= upper_bound\\n prob += free_transfers == aux + 1\\n # penalised_transfers is max(transfers - frees, 0)\\n prob += penalised_transfers >= -frees_minus_transfers\\n prob += penalised_transfers >= 0\\n\\n ev_values = projections[[f'{gw}_Pts' for gw in gw_interval]] # Restructure projections data for easier\\n ev_values.columns = gw_interval # manipulation\\n objective = ((lineup + captain) * ev_values).sum() # Objective function is sum of lineup and captain pts\\n objective += (vice_captain * self.vc_weight * ev_values).sum() # Add vice-captain weight\\n for loc, bench_slot in enumerate((bench_gk, bench_1, bench_2, bench_3)):\\n objective += (bench_slot * ev_values).sum() * self.bench_weights[:, loc] # Add bench weights to objective\\n if force_transfers is None:\\n objective -= penalised_transfers * 4 # Take away 4 points from each hit taken\\n if force_chips is not None:\\n self.force_chips = force_chips\\n for gw in force_chips:\\n if force_chips[gw] == 'wildcard':\\n objective[gw] += penalised_transfers[gw] * 4 # Remove penalised points in wildcard week\\n\\n if force_players is not None:\\n for player in force_players['include']:\\n prob += squad.T[player].drop(next_gw - 1) == 1\\n for player in force_players['exclude']:\\n prob += squad.T[player].drop(next_gw - 1) == 0\\n if 'include_for_gw' in force_players:\\n for gw in force_players['include_for_gw']:\\n try:\\n prob += squad[force_players['include_for_gw'][gw], gw] == 1\\n except ValueError:\\n pass\\n if 'exclude_for_gw' in force_players:\\n for gw in force_players['exclude_for_gw']:\\n try:\\n prob += squad[force_players['exclude_for_gw'][gw], gw] == 0\\n except ValueError:\\n pass\\n self.rolls = frees_minus_transfers + penalised_transfers\\n prob += self.rolls <= 2\\n\\n if self.penalties is not None:\\n if time_decay in self.penalties:\\n self.penalties[time_decay] = self.penalties.pop(time_decay) # Apply time decay after other penalties\\n for penalty, parameter in self.penalties.items():\\n objective = penalty(objective, self, parameter) # Apply external penalty functions\\n\\n # Apply price change EV\\n if price_changes is not None:\\n gws_remaining = 38 - next_gw + 1\\n for player in price_changes['rise']:\\n objective[next_gw] += self.million_value / 30 * squad[player, next_gw] * gws_remaining\\n for player in price_changes['drop']:\\n objective[next_gw] -= self.million_value / 10 * squad[player, next_gw] * gws_remaining\\n\\n prob.model += objective.sum()\\n prob.solve(time_limit=time_limit, optimizer=optimizer, message=message)\\n\\n return Solution(lineup, bench_gk, bench_1, bench_2, bench_3, captain, vice_captain, objective, transfer_in,\\n transfer_out, itb, projections, free_transfers, penalised_transfers, force_chips)\",\n \"def evolve_fqe_givens(wfn: Wavefunction, u: np.ndarray) -> Wavefunction:\\n wfn = evolve_fqe_givens_sector(wfn, u, sector='alpha')\\n wfn = evolve_fqe_givens_sector(wfn, u, sector='beta')\\n return wfn\",\n \"def __step__(self,f,t,u,dt,thetas,x=None,estimate_error=False,use_butcher=False):\\n if self.alpha is None:\\n use_butcher = True\\n\\n m=len(self)\\n u_old = u.copy() # Initial value\\n y = [np.zeros_like(np.atleast_1d(u)) for i in range(m+1)]\\n fy = [np.zeros_like(np.atleast_1d(u)) for i in range(m)]\\n\\n # First stage\\n y[0][:]=u_old\\n if x is not None: fy[0][:]=f(t,y[0],x)\\n else: fy[0][:]=f(t,y[0])\\n\\n if use_butcher: # Use Butcher coefficients\\n for i in range(1,m): # Compute stage i\\n y[i][:] = u_old\\n for j in range(i):\\n y[i] += self.A[i,j]*dt*fy[j]\\n if x is not None: fy[i][:] = f(t+self.c[i]*dt,y[i],x)\\n else: fy[i][:] = f(t+self.c[i]*dt,y[i])\\n u_new=u_old+dt*sum([self.b[j]*fy[j] for j in range(m)])\\n\\n else: # Use Shu-Osher coefficients\\n v = 1 - self.alpha.sum(1)\\n for i in range(1,m+1):\\n y[i] = v[i]*u_old\\n for j in range(i):\\n y[i] += self.alpha[i,j]*y[j] + dt*self.beta[i,j]*fy[j]\\n if i<m:\\n if x is not None: fy[i][:] = f(t+self.c[i]*dt,y[i],x)\\n else: fy[i][:] = f(t+self.c[i]*dt,y[i])\\n u_new = y[m]\\n\\n if thetas:\\n deg = self.b_dense.shape[1] # b_j polynomial degree\\n u_theta = [np.zeros_like(np.atleast_1d(u)) for i in range(len(thetas))]\\n for i, theta in enumerate(thetas):\\n u_theta[i]= u_old.copy()\\n for j in range(m):\\n bj = 0.\\n for d in range(1,deg):\\n bj += self.b_dense[j,d] * theta**d\\n u_theta[i] += dt*bj*fy[j]\\n else:\\n u_theta = None\\n\\n return u_new, u_theta\",\n \"def early_gradient_fusion():\\n pass\",\n \"def gredo(x,y,guessx,guessy,guesspar):\\n\\n global BTRACK, GSTRUC, NPIX\\n \\n flag = True # do it unless proven wrong \\n \\n # FROM **ANY** PREVIOUS POSITION \\n prev, = np.where((BTRACK['x']==x) & (BTRACK['y']==y))\\n nprev = len(prev)\\n\\n if guesspar is None:\\n return False\\n tguesspar = guesspar\\n nguesspar = len(tguesspar) \\n ngg = nguesspar//3 \\n \\n # FROM **ANY** PREVIOUS POSITION \\n # We have used a guess from this position before \\n # but have the parameters changed sufficiently\\n nogaussians = True # no gaussians found by default\\n if (nprev > 0): \\n \\n # Looping through the previous ones \\n for i in range(nprev):\\n guesspar2 = BTRACK['data'][prev[i]]['guesspar']\\n \\n # Some gaussians found \\n if (guesspar2 is not None):\\n nogaussians = False\\n tpar = guesspar2\\n ntpar = len(tpar) \\n ntg = ntpar//3 # number of gaussians in this guess \\n \\n # Same number of gaussians \\n if (ntpar == nguesspar): \\n # Sorting, largest first \\n tpar2 = utils.gsort(tpar) \\n tguesspar2 = utils.gsort(tguesspar) \\n \\n # Fixing possible zeros that could ruin the ratio \\n dum = np.copy(tpar2)\\n bd, = np.where(dum == 0.) \\n if len(bd) > 0:\\n dum[bd] = 1e-5 \\n diff = np.abs(tpar2 - tguesspar2) \\n ratio = diff/np.abs(dum) \\n \\n # These differences are too small, NO redo \\n if (np.max(ratio) < 0.01): \\n return False\\n \\n # Some previous visits, but no Gaussians detected, redo=False\\n if nogaussians:\\n return False\\n \\n return flag\",\n \"def ers(self, qL, qR, A, xt):\\n hL, hR, uL, uR, cL, cR = self.get_param(qL, qR)\\n fL = self.flux(qL)\\n fR = self.flux(qR)\\n # Find starting value for Newton-Rhapson iterative method\\n hS = self.start_exact(hL, hR, cL, cR, uL, uR)\\n h0 = hS\\n # Start iteration\\n for _ in range(self.n_iter):\\n fL, fld = self.geofun(hS, hL, cL)\\n fR, frd = self.geofun(hS, hR, cR)\\n hS = hS - (fL + fR + uR - uL)/(fld + frd)\\n if abs(hS - h0) / (0.5 * (hS + h0) ) <= self.tol: break\\n if hS < 0.: hS = self.tol\\n h0 = hS\\n # Check if converged or not\\n if _ == self.n_iter and abs(hS - h0) / (0.5 * (hS + h0) ) > self.tol:\\n raise 'Solution not converged, try to increase n_iter value'\\n else:\\n # Converged solution for depth hS in Star Region.\\n # Compute velocity uS in Star Region\\n uS = 0.5*(uL + uR) + 0.5*(fR - fL);\\n cS = math.sqrt(9.81*hS);\\n # Sample solution\\n h, u = self.samwet(hL, hR, hS, uL, uR, uS, cL, cR, cS, xt)\\n return h, h*u\",\n \"def __init__(self, trap=2.5*10**16, Keq=1.0*10**17,\\n EHdecay=1.0*10**-10, Etrap=2.0*10**-10, FHloss=8.0*10**-12,\\n G3decay = 0, step=200*ps, pretime=2, reprate=80000000,\\n verbose=False, trackQ=False, scalar=1, Gdecay=0, GHdecay=0,\\n tolerance=0.005, G2decay=0. ,Gescape=1., Gform=1., G3loss=0.):\\n # Some other variables used\\n self.tolerance = tolerance\\n self.scalar = scalar\\n self.verbose = verbose\\n self.reprate = reprate\\n self.duration = 1.00 / reprate\\n self.step = step\\n self.steps = int(self.duration / self.step)\\n self.powers = []\\n self.pretime = pretime\\n # Variables which hold state densities\\n self.exciton = []\\n self.hole = []\\n self.electron = []\\n self.trap = (trap) # Total number of traps\\n self.filled = [] # Filled traps\\n self.signal = []\\n self.xsignal = []\\n self.ehsignal = []\\n self.xloss = []\\n self.tloss = []\\n self.pulses = []\\n self.qk = []\\n self.trackQ = trackQ\\n # Rate and equilibrium constants, corrected for time step size\\n self.Keq = Gescape/Gform # Equilibrium constant for X<-->e+h\\n self.EHdecay = (EHdecay * step) # e+h->ground\\n self.Etrap = (Etrap * step) # e+trap->filled\\n self.FHloss = (FHloss * step) # filled+h->ground\\n self.Gdecay = Gdecay * step\\n self.G2decay = G2decay * step\\n self.G3decay = G3decay * step\\n self.GHdecay = GHdecay * step\\n self.Gescape = Gescape * step\\n self.G3loss = G3loss * step\\n self.Gform = Gform * step\",\n \"def FitnessSkopt(inputParams):\\n\\n elecsusParams = baseParams.copy()\\n\\n # NOTE: No bPhi as of yet.\\n paramDict = {'Bfield': inputParams[0], \\\"T\\\": inputParams[1], 'Btheta': np.deg2rad(inputParams[2]), 'Etheta': np.deg2rad(inputParams[3])}\\n\\n # This is the full dictionary to use on ElecSus.\\n elecsusParams.update(paramDict)\\n\\n # First generate the output transmission as before.\\n inputE = np.array([np.cos(elecsusParams[\\\"Etheta\\\"]), np.sin(elecsusParams[\\\"Etheta\\\"]), 0])\\n\\n # Call ElecSus to obtain the output electric field.\\n try:\\n # There may at times be issues with ElecSus, such as when NaN is entered as a variable.\\n [outputE] = elecsus.calculate(globalDetuning, inputE, elecsusParams, outputs = [\\\"E_out\\\"])\\n except:\\n print(\\\"There was an issue in ElecSus, so this iteration will return a figure of merit of 0. Here are the input parameters:\\\")\\n print(\\\"Input parameters: \\\" + str(elecsusParams))\\n print(\\\"Input field: \\\" + str(inputE))\\n return 0.0\\n \\n # Use a Jones matrix to determine the electric field after the action of the second polariser. As this is a single filter, the two polarisers are crossed.\\n polariserAngle = elecsusParams[\\\"Etheta\\\"] + np.pi/2\\n\\n # Define the Jones matrix. Though only explicitly defined for the x-y plane, we add the third dimension so that we can use all 3 dimensions of the output field.\\n jonesMatrix = np.matrix([[np.cos(polariserAngle)**2, np.sin(polariserAngle)*np.cos(polariserAngle), 0],\\n\\t\\t\\t\\t\\t\\t\\t\\t[np.sin(polariserAngle)*np.cos(polariserAngle), np.sin(polariserAngle)**2, 0],\\n [0, 0, 1]])\\n\\n # Get the output from the filter and the polarisers.\\n singleFilterOutputE = np.array(jonesMatrix * outputE)\\n\\n # Get the transmission.\\n singleFilterTransmission = (singleFilterOutputE * singleFilterOutputE.conjugate()).sum(axis=0)\\n\\n ENBW = ((integrate(singleFilterTransmission, globalDetuning)/singleFilterTransmission.max().real)/1e3).real\\n\\n figureOfMerit = (singleFilterTransmission.max()/ENBW).real\\n \\n if np.isnan(figureOfMerit):\\n # Usually occurs in the case of high temperatures and B fields, since the transmission is just a flat line.\\n print(\\\"Figure of merit is NaN! Here are the input parameters:\\\")\\n print(str(elecsusParams))\\n return 0.0\\n else:\\n return -1.0 * figureOfMerit\",\n \"def _calculate(self,*args,**kwargs):\\n\\n like = self.like\\n name = self.name\\n\\n init_energes = like.energies[[0,-1]]\\n\\n # Freeze all sources except one to make sed of.\\n all_sources = like.sourceNames()\\n\\n if name not in all_sources:\\n raise Exception(\\\"Cannot find source %s in list of sources\\\" % name)\\n\\n # make copy of parameter values + free parameters\\n \\n saved_state = SuperState(like)\\n\\n if self.verbosity: print 'Freezing background sources'\\n for other_name in get_background(like):\\n if self.freeze_bg_diffuse:\\n if self.verbosity: print ' * Freezing diffuse source %s' % other_name\\n modify(like, other_name, free=False)\\n else:\\n if self.verbosity: print ' * Freezing spectral shape for diffuse source %s' % other_name\\n modify(like, other_name, freeze_spectral_shape=True)\\n for other_name in get_sources(like):\\n if self.freeze_bg_sources:\\n if self.verbosity: print ' * Freezing bg source %s' % other_name\\n modify(like, other_name, free=False)\\n else:\\n if self.verbosity: print ' * Freezing spectral shape for bg source %s' % other_name\\n modify(like, other_name, freeze_spectral_shape=True)\\n\\n self.raw_results = []\\n for i,(lower,upper) in enumerate(zip(self.lower,self.upper)):\\n\\n like.setEnergyRange(float(lower)+1, float(upper)-1)\\n\\n e = np.sqrt(lower*upper)\\n\\n if self.verbosity: print 'Calculating SED from %.0dMeV to %.0dMeV' % (lower,upper)\\n\\n \\\"\\\"\\\" Note, the most robust method I have found for computing SEDs in gtlike is:\\n (a) Create a generic spectral model with a fixed spectral index.\\n (b) Set the 'Scale' to sqrt(emin*emax) so the prefactor is dNdE in the middle\\n of the sed bin.\\n (b) Set the limits to go from norm/fit_range to norm*fit_range and set the scale to 'norm'\\n \\\"\\\"\\\" \\n old_flux = self.init_model.i_flux(emin=lower,emax=upper)\\n model = PowerLaw(index=self.powerlaw_index, e0=e)\\n model.set_flux(old_flux, emin=lower, emax=upper)\\n norm = model['norm']\\n model.set_limits('norm',norm/float(self.fit_range),norm*self.fit_range, scale=norm)\\n model.set_limits('index',-5,5)\\n model.freeze('index')\\n spectrum = build_gtlike_spectrum(model)\\n\\n like.setSpectrum(name,spectrum)\\n like.syncSrcParams(name)\\n\\n if self.verbosity:\\n print 'Before fitting SED from %.0dMeV to %.0dMeV' % (lower,upper)\\n print summary(like)\\n\\n paranoid_gtlike_fit(like, verbosity=self.verbosity)\\n\\n if self.verbosity:\\n print 'After fitting SED from %.0dMeV to %.0dMeV' % (lower,upper)\\n print summary(like)\\n\\n d = dict()\\n self.raw_results.append(d)\\n\\n d['energy'] = energy_dict(emin=lower, emax=upper, energy_units=self.energy_units)\\n d['flux'] = flux_dict(like, name, emin=lower,emax=upper, flux_units=self.flux_units, \\n errors=True, include_prefactor=True, prefactor_energy=e)\\n d['prefactor'] = powerlaw_prefactor_dict(like, name, errors=self.save_hesse_errors, minos_errors=True,\\n flux_units=self.flux_units)\\n d['TS'] = ts_dict(like, name, verbosity=self.verbosity)\\n\\n if self.verbosity: print 'Calculating SED upper limit from %.0dMeV to %.0dMeV' % (lower,upper)\\n\\n if self.always_upper_limit or d['TS']['reoptimize'] < self.min_ts:\\n ul = GtlikePowerLawUpperLimit(like, name,\\n cl=self.ul_confidence,\\n emin=lower,emax=upper,\\n flux_units=self.flux_units,\\n energy_units=self.energy_units,\\n upper_limit_kwargs=self.upper_limit_kwargs,\\n include_prefactor=True,\\n prefactor_energy=e,\\n verbosity=self.verbosity,\\n )\\n d['upper_limit'] = ul.todict()\\n\\n # revert to old model\\n like.setEnergyRange(*init_energes)\\n saved_state.restore()\\n\\n self._condense_results()\",\n \"def smooth(f, g):\\r\\n chi_f = f.apply(lambda x: 0.0 if pd.isna(x) else 1.0)\\r\\n f_ext = pd.concat([f, chi_f], axis=1).prod(axis=1)\\r\\n a = convolve(f_ext, g)\\r\\n b = convolve(chi_f, g)\\r\\n return a.div(b)\",\n \"def __call__(self, grad, gradnat=None, si=None, *args, **kw):\\r\\n if not gradnat:\\r\\n gradnat = grad\\r\\n self.gradold = self.grad\\r\\n self.gradnatold = self.gradnat\\r\\n self.grad = grad\\r\\n self.gradnat = gradnat\\r\\n self.si = si\\r\\n return self._gamma(*args, **kw)\",\n \"def gradFun(self, S, x):\",\n \"def gaussbroad(w, s, hwhm):\\n \\\"\\\"\\\"\\n History\\n --------\\n Dec-90 GB,GM\\n Rewrote with fourier convolution algorithm.\\n Jul-91 AL\\n Translated from ANA to IDL.\\n 22-Sep-91 JAV\\n Relaxed constant dispersion check# vectorized, 50% faster.\\n 05-Jul-92 JAV\\n Converted to function, handle nonpositive hwhm.\\n Oct-18 AW\\n Python version\\n \\\"\\\"\\\"\\n\\n # Warn user if hwhm is negative.\\n if hwhm < 0:\\n logger.warning(\\\"Forcing negative smoothing width to zero.\\\")\\n\\n # Return input argument if half-width is nonpositive.\\n if hwhm <= 0:\\n return s # true: no broadening\\n\\n # Calculate (uniform) dispersion.\\n nw = len(w) ## points in spectrum\\n wrange = w[-1] - w[0]\\n dw = wrange / (nw - 1) # wavelength change per pixel\\n\\n # Make smoothing gaussian; extend to 4 sigma.\\n # 4.0 / sqrt(2.0 * alog(2.0)) = 3.3972872\\n # sqrt(alog(2.0)) = 0.83255461\\n # sqrt(alog(2.0) / pi) = 0.46971864\\n # (*1.0000632 to correct for >4 sigma wings)\\n if hwhm >= 5 * wrange:\\n return np.full(nw, np.sum(s) / nw)\\n ## points in half gaussian\\n nhalf = int(3.3972872 * hwhm / dw)\\n ## points in gaussian (odd!)\\n ng = 2 * nhalf + 1\\n # wavelength scale of gaussian\\n wg = dw * (np.arange(ng, dtype=float) - (ng - 1) / 2)\\n # convenient absisca\\n xg = (0.83255461 / hwhm) * wg\\n # unit area gaussian w / FWHM\\n gpro = (0.46974832 * dw / hwhm) * np.exp(-xg * xg)\\n gpro = gpro / np.sum(gpro)\\n\\n # Pad spectrum ends to minimize impact of Fourier ringing.\\n sout = convolve(s, gpro, mode=\\\"nearest\\\")\\n\\n return sout\",\n \"def _newtons_method_gmres_action(f, initial_guess, max_iter=50, tol=1e-12):\\n\\n output_dim = len(f(initial_guess))\\n \\n @np.vectorize\\n def sum_values(dictionary):\\n return sum(dictionary.values())\\n \\n def create_action(x0):\\n \\n def L_fun(x):\\n \\\"\\\"\\\"\\n Action\\n Returns J_f(x0)*x by setting the values of 'x' as the initial derivatives for the variables in x0.\\n \\\"\\\"\\\"\\n \\n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\\n action = sum_values(ad.get_deriv(f_x0))\\n return action\\n \\n L = LinearOperator(shape=(output_dim, len(x0)), matvec=L_fun)\\n \\n return L\\n \\n x0 = initial_guess\\n for iter_num in range(max_iter):\\n L = create_action(x0)\\n b = -1 * np.array(f(x0))\\n if len(x0) == 1:\\n b = np.array([b])\\n step, _ = gmres(L, b, tol = tol, atol = 'legacy')\\n xnext = x0 + step \\n if np.all(np.abs(xnext - x0) < tol):\\n return (xnext, iter_num + 1);\\n x0 = xnext\\n \\n raise RuntimeError(\\\"Failed to converge after {0} iterations, value is {1}\\\".format(max_iter, x0) );\",\n \"def compute_gradient(self, verbose):\\n from inversionson.helpers.autoinverter_helpers import IterationListener\\n\\n # Attempt to dispatch model smoothing right at the beginning.\\n # So there is no smoothing bottleneck when updates are not smoothed.\\n it_listen = IterationListener(\\n self.comm,\\n events=self.comm.project.events_in_iteration)\\n it_listen.listen()\\n\\n self.task_dict[\\\"forward_submitted\\\"] = True\\n self.task_dict[\\\"misfit_completed\\\"] = True\\n self.task_dict[\\\"gradient_completed\\\"] = True\\n self._update_task_file()\\n self.finish_task()\",\n \"def gauss_smoothing(engine, smoothed, R, d_k):\\n code = CodeSegment(engine)\\n def tf(k):\\n k2 = sum(ki**2 for ki in k)\\n wts = numpy.exp(-0.5*k2* R**2)\\n return wts\\n \\n code.assign(x='d_k', y='tmp')\\n code.transfer(complex='tmp', tf=tf)\\n code.c2r(real=smoothed, complex='tmp')\\n return code\",\n \"def finalize_graph(self, g, ng):\\n fv_sens = Constant(newenv)\\n for fv in g.free_variables_extended:\\n sens = self.get(g, fv)\\n if sens.is_apply(zeros_like):\\n # Skip if there is no gradient\\n continue\\n fv_sens = ng.apply(\\n P.env_setitem,\\n fv_sens,\\n ng.apply(operations.embed, self.grad_fprop.get_jinv(fv)),\\n sens,\\n )\\n in_sens = [self.get(g, p) for p in g.parameters]\\n ng.output = ng.apply(P.make_tuple, fv_sens, *in_sens)\\n if len(ng.parameters) == 0:\\n # This can happen if the output is a constant. In that case we just\\n # add a dummy parameter to satisfy the backpropagator protocol.\\n with About(g.output.debug, \\\"grad_sens\\\"):\\n ng.add_parameter()\",\n \"def conditional_wegstein(f, x0):\\n g0, condition = f(x0)\\n g1 = x1 = g0\\n w = np.ones_like(x0)\\n np_abs = np.abs\\n while condition:\\n try: g1, condition = f(x1)\\n except:\\n x1 = g1\\n g1, condition = f(x1)\\n dx = x1-x0\\n dummy = dx-g1+g0\\n mask = np_abs(dummy) > 1e-16\\n w[mask] = dx[mask]/dummy[mask]\\n x0 = x1\\n g0 = g1\\n x1 = w*g1 + (1.-w)*x1\",\n \"def optimise_GP_kernel(self,iters=1000):\\n \\n new_params=SCG(self.ll_hyper,self.ll_hyper_grad,np.hstack((self.DGPLVM_tar.GP.kernel.get_params(), np.log(self.DGPLVM_tar.GP.beta))),maxiters=iters,display=True,func_flg=0)\\n #gtol=1e-10,epsilon=1e-10,\\n# new_params = fmin_cg(self.ll,np.hstack((self.kernel.get_params(), np.log(self.beta))),fprime=self.ll_grad,maxiter=iters,gtol=1e-10,disp=False) \\n self.DGPLVM_src.GP.set_params(new_params)\\n self.DGPLVM_tar.GP.set_params(new_params)\\n self.DGPLVM_all.GP.set_params(new_params)\",\n \"def apply_gates(self, gates):\\n for gate in gates:\\n self.apply_gate(*gate)\\n\\n self._psi.squeeze_()\",\n \"def cgls_Ploak_Ribiere(self, iterations = None):\\n if self.iters == 0 :\\n self.r = - self.df(self.x)\\n self.r_old = self.r.copy()\\n self.d = self.r.copy()\\n self.delta_new = np.sum(self.r**2)\\n self.delta_0 = self.delta_new.copy()\\n # \\n if iterations == None :\\n iterations = self.imax\\n #\\n for i in range(iterations):\\n #\\n # perform a line search of f along d\\n self.x, status = self.line_search(self.x, self.d)\\n # \\n self.r = - self.df(self.x)\\n delta_old = self.delta_new\\n delta_mid = np.sum(self.r * self.r_old)\\n self.r_old = self.r.copy()\\n self.delta_new = np.sum(self.r**2)\\n #\\n # Polak-Ribiere formula\\n beta = (self.delta_new - delta_mid)/ delta_old\\n #\\n self.d = self.r + beta * self.d\\n #\\n # reset the algorithm \\n if (self.iters % 50 == 0) or (status == False) or beta <= 0.0 :\\n self.d = self.r\\n else :\\n self.d = self.r + beta * self.d\\n #\\n # calculate the error\\n self.errors.append(self.f(self.x))\\n self.iters = self.iters + 1\\n if self.iters > self.imax or (self.errors[-1] < self.e_tol):\\n break\\n #\\n #\\n return self.x\",\n \"def make_erb_filters(self, sr, centre_freqs, width=1.0):\\n\\t\\tT = 1.0 / sr\\n\\t\\t# Change the followFreqing three parameters if you wish to use a different\\n\\t\\t# ERB scale. Must change in ERBSpace too.\\n\\t\\t# TODO: factor these out\\n\\t\\tear_q = 9.26449 # Glasberg and Moore Parameters\\n\\t\\tmin_bw = 24.7\\n\\t\\torder = 1\\n\\n\\t\\terb = width*((centre_freqs/ear_q)**order + min_bw**order)**(1/order)\\n\\t\\tB = 1.019*2*np.pi*erb\\n\\n\\t\\targ = 2*centre_freqs*np.pi*T\\n\\t\\tvec = np.exp(2j*arg)\\n\\n\\t\\tA0 = T\\n\\t\\tA2 = 0\\n\\t\\tB0 = 1\\n\\t\\tB1 = -2*np.cos(arg)/np.exp(B*T)\\n\\t\\tB2 = np.exp(-2*B*T)\\n\\n\\t\\trt_pos = np.sqrt(3 + 2**1.5)\\n\\t\\trt_neg = np.sqrt(3 - 2**1.5)\\n\\n\\t\\tcommon = -T * np.exp(-(B * T))\\n\\n\\t\\t# TODO: This could be simplified to a matrix calculation involving the\\n\\t\\t# constant first term and the alternating rt_pos/rt_neg and +/-1 second\\n\\t\\t# terms\\n\\t\\tk11 = np.cos(arg) + rt_pos * np.sin(arg)\\n\\t\\tk12 = np.cos(arg) - rt_pos * np.sin(arg)\\n\\t\\tk13 = np.cos(arg) + rt_neg * np.sin(arg)\\n\\t\\tk14 = np.cos(arg) - rt_neg * np.sin(arg)\\n\\n\\t\\tA11 = common * k11\\n\\t\\tA12 = common * k12\\n\\t\\tA13 = common * k13\\n\\t\\tA14 = common * k14\\n\\n\\t\\tgain_arg = np.exp(1j * arg - B * T)\\n\\n\\t\\tgain = np.abs( (vec - gain_arg * k11) * (vec - gain_arg * k12)\\\\\\n\\t\\t\\t * (vec - gain_arg * k13) * (vec - gain_arg * k14)\\\\\\n\\t\\t\\t * ( T * np.exp(B*T) / (-1 / np.exp(B*T) + 1 + vec * (1 - np.exp(B*T))) )**4 )\\n\\n\\t\\tallfilts = np.ones_like(centre_freqs)\\n\\n\\t\\tfcoefs = np.column_stack([A0*allfilts, A11, A12, A13, A14, A2*allfilts,\\\\\\n\\t\\t\\tB0*allfilts, B1, B2,gain])\\n\\n\\t\\treturn fcoefs\",\n \"def step(self):\\n for p, grad, v, square_grad_avg, delta_x_acc in self.params:\\n # Compute the running average of the squared gradients \\n square_grad_avg.mul_(self.rho)\\n square_grad_avg.addcmul_(grad, grad, value = 1 - self.rho)\\n # Compute the RMS of the previous squared gradients (eps to avoid numerical issues later for division)\\n std = (square_grad_avg.add_(self.eps)).sqrt_()\\n # Compute the accumulated update\\n delta_x = ((delta_x_acc.add_(self.eps)).sqrt_()) * grad / std\\n # Accumulate the updates\\n delta_x_acc.mul_(self.rho)\\n delta_x_acc.addcmul_(delta_x, delta_x, value = 1 - self.rho) \\n # Update the parameters\\n p.add_(delta_x, alpha = - self.lr)\",\n \"def optimize(self):\\n prm = (self.b,self.c)\\n d = self.d\\n no = int(d*d)\\n bounds = [(-1,1)]*no\\n resG = differential_evolution(inpSc.entBias, bounds, args = prm, popsize = 40, disp = False)\\n\\n xOpt = resG.x\\n xOpt = xOpt/(np.linalg.norm(xOpt))\\n\\n #Refine the global optimization by performing a second local optimizaiton\\n x0 = xOpt\\n\\n res = minimize(inpSc.entBias, x0, args = prm, method='BFGS', options={'disp': False})\\n xOpt = res.x\\n xOpt = xOpt/(np.linalg.norm(xOpt))\\n self.rhoOp = inpSc.getMat(xOpt, d)\\n self.Q1 = -res.fun\",\n \"def doParametersOfInterest(self):\\n \\n self.modelBuilder.doVar('expr::cosW(\\\"0.87681811112\\\",)')\\n self.modelBuilder.doVar('expr::sinW(\\\"0.48082221247\\\",)')\\n self.modelBuilder.doVar('expr::mZ(\\\"91.2\\\",)')\\n self.modelBuilder.doVar('expr::Lambda1(\\\"100.0\\\",)')\\n self.modelBuilder.doVar('expr::e2(\\\"0.0917\\\",)')\\n self.modelBuilder.doVar('expr::gs2(\\\"1.533\\\",)')\\n\\n # EFT Higgs basis couplings\\n\\n self.modelBuilder.doVar('cZ[0,-1,1]') \\n self.modelBuilder.doVar(\\\"cZZ[0,-2,2]\\\") \\n self.modelBuilder.doVar(\\\"cZZt[0,-2,2]\\\") \\n self.modelBuilder.doVar(\\\"cZB[0,-6,6]\\\") \\n\\n poi='cZ,cZZ,cZZt,cZB'\\n\\n # Amplitude couplings from EFT couplings \\n\\n self.modelBuilder.doVar('expr::a1(\\\"@0+1\\\",cZ)') # (\\\"2*(@0+1)\\\",cZ) in AN/Paper but a1 = 1 for signal model and width calculation\\n self.modelBuilder.doVar('expr::a2(\\\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\\\",cZZ,e2,sinW,cosW)')\\n self.modelBuilder.doVar('expr::a3(\\\"-1*@0*(@1/(2*pow(@2,2)*pow(@3,2)))\\\",cZZt,e2,sinW,cosW)')\\n self.modelBuilder.doVar('expr::k1(\\\"@0*(@1*pow(@2,2)/(pow(@3,2)*pow(@4,2)))\\\",cZB,e2,Lambda1,sinW,mZ)')\\n self.modelBuilder.doVar('expr::k1L1(\\\"@0/pow(@1,2)\\\",k1,Lambda1)')\\n\\n ###### gamma_H ########\\n\\n # SMEFT relationships for VV couplings (Expressed using amplitude couplings)\\n\\n self.modelBuilder.doVar('expr::kappa(\\\"1.0\\\",)')\\n self.modelBuilder.doVar('expr::kappa_tilde(\\\"0.0\\\",)') \\n\\n self.modelBuilder.doVar('expr::a1_WW(\\\"@0\\\",a1)')\\n self.modelBuilder.doVar('expr::a2_WW(\\\"@0*@0*@1\\\",cosW,a2)')\\n self.modelBuilder.doVar('expr::a3_WW(\\\"@0*@0*@1\\\",cosW,a3)')\\n self.modelBuilder.doVar('expr::k1_WW(\\\"(@2 / (@0*@0 - @1*@1) - 2*@1*@1*@3*@4*@4 /(@5*@5*(@0*@0 - @1*@1)))\\\",cosW,sinW,k1,a2,Lambda1,mZ)')\\n self.modelBuilder.doVar('expr::k2_k1(\\\"2*@0*@1*@2/(@0*@0 - @1*@1)\\\",cosW,sinW,k1)')\\n self.modelBuilder.doVar('expr::k2_a2(\\\"-2*@0*@1*@3*@4*@4/((@2*@2)*(@0*@0 - @1*@1))\\\",cosW,sinW,mZ,a2,Lambda1)')\\n self.modelBuilder.doVar('expr::k2(\\\"@0 + @1\\\",k2_k1,k2_a2)')\\n\\n # Determine gamma_H from VV couplings\\n\\n zz_expr = '\\\"4*(@0*@0/4. + 0.1695*@3*@3 + 0.09076*@1*@1 + 0.03809*@2*@2 + 0.8095*@0*@3/2. + 0.5046*@0*@1/2. + 0.2092*@1*@3 + 0.1023*@4*@4 + 0.1901*@0*@4/2. + 0.07429*@3*@4 + 0.04710*@1*@4) \\\",a1,a2,a3,k1,k2'\\n ww_expr = '\\\"4*(@0*@0/4. + 0.1320*@3*@3 + 0.1944*@1*@1 + 0.08075*@2*@2 + 0.7204*@0*@3/2. + 0.7437*@0*@1/2. + 0.2774*@3*@1) \\\",a1_WW,a2_WW,a3_WW,k1_WW'\\n zgamma_expr = '\\\"4*(1.118600*@0*@0/4. +0.0035*@1*@1 - 0.125010*@0*@1/2. + 0.000003*@1*@1 - 0.00018*@1*@1 + 0.003100*@0*@1/2. +0.00126*@2*@2 + 0.000005*@2*@2 -0.00047*@2*@2)\\\",a1_WW,kappa,kappa_tilde'\\n gg_expr = '\\\"(1.1068*@0*@0 + 0.0082*@0*@0 - 0.1150*@0*@0 + 2.5717*@1*@1 + 0.0091*@1*@1 - 0.1982*@1*@1)\\\",kappa,kappa_tilde'\\n bb_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n cc_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n tautau_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n mumu_expr = '\\\"(@0*@0 + @1*@1)\\\",kappa,kappa_tilde'\\n gmgm_expr = '\\\"4*(1.6054*@0*@0/4. + 0.07312*@1*@1 - 0.6854*@0*@1/2. + 0.00002*@1*@1 - 0.0018*@1*@1 + 0.0085*@0*@1/2. + 0.1699*@2*@2 + 0.00002*@2*@2 - 0.0031*@2*@2)\\\",a1_WW,kappa,kappa_tilde'\\n \\n self.modelBuilder.doVar('expr::R_WW('+str(ww_expr)+')')\\n self.modelBuilder.doVar('expr::R_ZZ('+str(zz_expr)+')')\\n self.modelBuilder.doVar('expr::R_Zgamma('+str(zgamma_expr)+')')\\n self.modelBuilder.doVar('expr::R_gg('+str(gg_expr)+')')\\n self.modelBuilder.doVar('expr::R_bb('+str(bb_expr)+')')\\n self.modelBuilder.doVar('expr::R_cc('+str(cc_expr)+')')\\n self.modelBuilder.doVar('expr::R_tautau('+str(tautau_expr)+')')\\n self.modelBuilder.doVar('expr::R_mumu('+str(mumu_expr)+')')\\n self.modelBuilder.doVar('expr:R_gammagamma('+str(gmgm_expr)+')')\\n\\n self.modelBuilder.doVar('expr::gammaH(\\\"(0.5824*@0 + 0.2137*@1 + 0.08187*@2 + 0.06272*@3 + 0.02891*@4 + 0.02619*@5 + 0.002270*@6 + 0.001533*@7 + 0.0002176*@8 )/0.9998\\\",R_bb,R_WW,R_gg,R_tautau,R_cc,R_ZZ,R_gammagamma,R_Zgamma,R_mumu)') \\n\\n ###########################\\n\\n self.g1V = GetCoupTerms(1,1,1,-0.0001,\\\"1V\\\") # Compensate for scaling of k1 templates \\n self.g2V = GetCoupTerms(1,1,1,-0.0001,\\\"2V\\\") \\n \\n self.modelBuilder.doVar(\\\"expr::g2V_1(\\\\\\\"\\\"+str(self.g2V[0])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T1(\\\\\\\"((pow(@0,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T1_Neg(\\\\\\\"-1*((pow(@0,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_1)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_2(\\\\\\\"\\\"+str(self.g2V[1])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T2(\\\\\\\"((pow(@0,3)*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T2_Neg(\\\\\\\"-1*((pow(@0,3)*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_2)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_3(\\\\\\\"\\\"+str(self.g2V[2])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T3(\\\\\\\"((pow(@0,2)*pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T3_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_3)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_4(\\\\\\\"\\\"+str(self.g2V[3])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T4(\\\\\\\"((@0*pow(@1,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T4_Neg(\\\\\\\"-1*((@0*pow(@1,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_4)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_5(\\\\\\\"\\\"+str(self.g2V[4])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T5(\\\\\\\"((pow(@1,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T5_Neg(\\\\\\\"-1*((pow(@1,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_5)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_6(\\\\\\\"\\\"+str(self.g2V[5])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T6(\\\\\\\"((pow(@0,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T6_Neg(\\\\\\\"-1*((pow(@0,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_6)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_7(\\\\\\\"\\\"+str(self.g2V[6])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T7(\\\\\\\"((pow(@0,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T7_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_7)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_8(\\\\\\\"\\\"+str(self.g2V[7])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T8(\\\\\\\"((@0*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T8_Neg(\\\\\\\"-1*((@0*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_8)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_9(\\\\\\\"\\\"+str(self.g2V[8])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T9(\\\\\\\"((pow(@2,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T9_Neg(\\\\\\\"-1*((pow(@2,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_9)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_10(\\\\\\\"\\\"+str(self.g2V[9])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T10(\\\\\\\"((pow(@0,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T10_Neg(\\\\\\\"-1*((pow(@0,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_10)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_11(\\\\\\\"\\\"+str(self.g2V[10])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T11(\\\\\\\"((pow(@0,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T11_Neg(\\\\\\\"-1*((pow(@0,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_11)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_12(\\\\\\\"\\\"+str(self.g2V[11])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T12(\\\\\\\"((@0*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T12_Neg(\\\\\\\"-1*((@0*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_12)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_13(\\\\\\\"\\\"+str(self.g2V[12])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T13(\\\\\\\"((pow(@3,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T13_Neg(\\\\\\\"-1*((pow(@3,4))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_13)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_14(\\\\\\\"\\\"+str(self.g2V[13])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T14(\\\\\\\"((pow(@1,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T14_Neg(\\\\\\\"-1*((pow(@1,3)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_14)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_15(\\\\\\\"\\\"+str(self.g2V[14])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T15(\\\\\\\"((pow(@1,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T15_Neg(\\\\\\\"-1*((pow(@1,2)*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_15)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_16(\\\\\\\"\\\"+str(self.g2V[15])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T16(\\\\\\\"((@1*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T16_Neg(\\\\\\\"-1*((@1*pow(@2,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_16)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_17(\\\\\\\"\\\"+str(self.g2V[16])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T17(\\\\\\\"((pow(@1,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T17_Neg(\\\\\\\"-1*((pow(@1,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_17)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_18(\\\\\\\"\\\"+str(self.g2V[17])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T18(\\\\\\\"((pow(@1,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T18_Neg(\\\\\\\"-1*((pow(@1,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_18)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_19(\\\\\\\"\\\"+str(self.g2V[18])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T19(\\\\\\\"((@1*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T19_Neg(\\\\\\\"-1*((@1*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_19)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_20(\\\\\\\"\\\"+str(self.g2V[19])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T20(\\\\\\\"((pow(@2,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T20_Neg(\\\\\\\"-1*((pow(@2,3)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_20)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_21(\\\\\\\"\\\"+str(self.g2V[20])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T21(\\\\\\\"((pow(@2,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T21_Neg(\\\\\\\"-1*((pow(@2,2)*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_21)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_22(\\\\\\\"\\\"+str(self.g2V[21])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T22(\\\\\\\"((@2*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T22_Neg(\\\\\\\"-1*((@2*pow(@3,3))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_22)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_23(\\\\\\\"\\\"+str(self.g2V[22])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T23(\\\\\\\"((@0*@1*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T23_Neg(\\\\\\\"-1*((@0*@1*pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_23)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_24(\\\\\\\"\\\"+str(self.g2V[23])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T24(\\\\\\\"((@0*pow(@1,2)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T24_Neg(\\\\\\\"-1*((@0*pow(@1,2)*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_24)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_25(\\\\\\\"\\\"+str(self.g2V[24])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T25(\\\\\\\"((pow(@0,2)*@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T25_Neg(\\\\\\\"-1*((pow(@0,2)*@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_25)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_26(\\\\\\\"\\\"+str(self.g2V[25])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T26(\\\\\\\"((@0*@1*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T26_Neg(\\\\\\\"-1*((@0*@1*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_26)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_27(\\\\\\\"\\\"+str(self.g2V[26])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T27(\\\\\\\"((@0*pow(@1,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T27_Neg(\\\\\\\"-1*((@0*pow(@1,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_27)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_28(\\\\\\\"\\\"+str(self.g2V[27])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T28(\\\\\\\"((pow(@0,2)*@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T28_Neg(\\\\\\\"-1*((pow(@0,2)*@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_28)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_29(\\\\\\\"\\\"+str(self.g2V[28])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T29(\\\\\\\"((@0*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T29_Neg(\\\\\\\"-1*((@0*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_29)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_30(\\\\\\\"\\\"+str(self.g2V[29])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T30(\\\\\\\"((@0*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T30_Neg(\\\\\\\"-1*((@0*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_30)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_31(\\\\\\\"\\\"+str(self.g2V[30])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T31(\\\\\\\"((pow(@0,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T31_Neg(\\\\\\\"-1*((pow(@0,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_31)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_32(\\\\\\\"\\\"+str(self.g2V[31])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T32(\\\\\\\"((@1*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T32_Neg(\\\\\\\"-1*((@1*@2*pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_32)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_33(\\\\\\\"\\\"+str(self.g2V[32])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T33(\\\\\\\"((@1*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T33_Neg(\\\\\\\"-1*((@1*pow(@2,2)*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_33)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_34(\\\\\\\"\\\"+str(self.g2V[33])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T34(\\\\\\\"((pow(@1,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T34_Neg(\\\\\\\"-1*((pow(@1,2)*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_34)\\\") \\n self.modelBuilder.doVar(\\\"expr::g2V_35(\\\\\\\"\\\"+str(self.g2V[34])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T35(\\\\\\\"((@0*@1*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_Ewk_T35_Neg(\\\\\\\"-1*((@0*@1*@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g2V_35)\\\") \\n \\n self.modelBuilder.doVar(\\\"expr::g1V_1(\\\\\\\"\\\"+str(self.g1V[0])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T1(\\\\\\\"((pow(@0,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T1_Neg(\\\\\\\"-1*((pow(@0,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_1)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_2(\\\\\\\"\\\"+str(self.g1V[1])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T2(\\\\\\\"((@0*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T2_Neg(\\\\\\\"-1*((@0*@1)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_2)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_3(\\\\\\\"\\\"+str(self.g1V[2])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T3(\\\\\\\"((pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T3_Neg(\\\\\\\"-1*((pow(@1,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_3)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_4(\\\\\\\"\\\"+str(self.g1V[3])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T4(\\\\\\\"((@0*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T4_Neg(\\\\\\\"-1*((@0*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_4)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_5(\\\\\\\"\\\"+str(self.g1V[4])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T5(\\\\\\\"((pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T5_Neg(\\\\\\\"-1*((pow(@2,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_5)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_6(\\\\\\\"\\\"+str(self.g1V[5])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T6(\\\\\\\"((@0*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T6_Neg(\\\\\\\"-1*((@0*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_6)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_7(\\\\\\\"\\\"+str(self.g1V[6])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T7(\\\\\\\"((pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T7_Neg(\\\\\\\"-1*((pow(@3,2))/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_7)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_8(\\\\\\\"\\\"+str(self.g1V[7])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T8(\\\\\\\"((@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T8_Neg(\\\\\\\"-1*((@1*@2)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_8)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_9(\\\\\\\"\\\"+str(self.g1V[8])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T9(\\\\\\\"((@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T9_Neg(\\\\\\\"-1*((@1*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_9)\\\") \\n self.modelBuilder.doVar(\\\"expr::g1V_10(\\\\\\\"\\\"+str(self.g1V[9])+\\\"\\\\\\\",)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T10(\\\\\\\"((@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\\\") \\n self.modelBuilder.factory_(\\\"expr::scale_ggH_T10_Neg(\\\\\\\"-1*((@2*@3)/@4)*@5\\\\\\\", a1, a2, a3, k1L1, gammaH, g1V_10)\\\") \\n \\n self.modelBuilder.doSet(\\\"POI\\\",poi)\",\n \"def galaxy():\\n rot_ang = 1\\n pol_ang = 1\\n\\n\\n time_array = [datetime.datetime(2017, 5, 25, 2, 0),\\n datetime.datetime(2017, 5, 26, 7, 0),\\n #~ datetime.datetime(2017, 5, 28, 1, 0),\\n #~ datetime.datetime(2017, 5, 30, 8, 0),\\n datetime.datetime(2017, 6, 4, 2, 0)]\\n\\n lfdic = {1:{'name':'LI', 'lat':[26,33,19.676], 'long':[97,26,31.174], 't_offset':6.496132851851852},\\n 2:{'name':'LII', 'lat':[34,4,43.497], 'long':[107,37,5.819], 't_offset':7.174552203703703},\\n 3:{'name':'LIII', 'lat':[38,25,59.0], 'long':[79,50,23.0], 't_offset':5.322648148148148},\\n 4:{'name':'LIV', 'lat':[34,12,3.0], 'long':[118,10,18.0], 't_offset':7.87811111111111}}\\n lfs = lfdic[4]\\n long_radians = (lfs['long'][0] + lfs['long'][1]/60.0 + lfs['long'][2]/3600.0)*np.pi/180.0\\n\\n LoFASM = station(lfs['name'],lfs['lat'],lfs['long'],FOV_color='b',\\n time='',frequency=20.0,one_ring='inner',\\n rot_angle=rot_ang,pol_angle=pol_ang)\\n innerNS_FOV = 0.61975795698554226 #LoFASM.lofasm.Omega()\\n inner_conversion_NS = np.divide((np.power(np.divide(3.0*1.0e8,45.0e6),2)),(innerNS_FOV))\\n\\n print('Stage 1/2 Done.')\\n\\n powe = np.multiply(LoFASM.calculate_gpowervslstarray(time_array),inner_conversion_NS)\\n power = 10*np.log10(np.array(powe))\\n print('Stage 2/2 Done.')\\n\\n return power\",\n \"def __call__(self, glon, glat, e):\\n return self.flux(glon, glat, e)\",\n \"def callParallelReducedGA(region):\\n year = 2000\\n while(year <= 2005):\\n execParallelReducedGAModel(year, region)\\n year+=1\",\n \"def evolve(self, xInitial, vInitial, dt, runningCondition, tolerances=None):\\n self._validateRunArguments(xInitial, vInitial, dt,\\n runningCondition, tolerances)\\n # Choose variable or constant step size\\n if self.adaptiveStepSize:\\n self.t, self.x, self.v = self._evolveVS(dt, runningCondition)\\n else:\\n self.t, self.x, self.v = self._evolveCS(dt, runningCondition)\",\n \"def evol_run(self, pkg_setup):\\n\\n params = specs.ODict()\\n params[(\\\"tune\\\", \\\"soma\\\", \\\"Ra\\\")] = [100.0 * 0.5, 100 * 1.5]\\n\\n amps = [0.0, 0.65] # amplitudes\\n times = [100, 200] # start times\\n dur = 50 # ms\\n targetRates = [0.0, 81.0]\\n\\n # initial cfg set up\\n initCfg = {} # specs.ODict()\\n initCfg[\\\"duration\\\"] = 200 * len(amps)\\n initCfg[(\\\"hParams\\\", \\\"celsius\\\")] = 37\\n\\n initCfg[\\\"savePickle\\\"] = True\\n initCfg[\\\"saveJson\\\"] = False\\n initCfg[\\\"saveDataInclude\\\"] = [\\\"simConfig\\\", \\\"netParams\\\", \\\"net\\\", \\\"simData\\\"]\\n\\n initCfg[(\\\"IClamp1\\\", \\\"pop\\\")] = \\\"ITS4\\\"\\n initCfg[(\\\"IClamp1\\\", \\\"amp\\\")] = amps\\n initCfg[(\\\"IClamp1\\\", \\\"start\\\")] = times\\n initCfg[(\\\"IClamp1\\\", \\\"dur\\\")] = 100\\n\\n initCfg[(\\\"analysis\\\", \\\"plotfI\\\", \\\"amps\\\")] = amps\\n initCfg[(\\\"analysis\\\", \\\"plotfI\\\", \\\"times\\\")] = times\\n initCfg[(\\\"analysis\\\", \\\"plotfI\\\", \\\"dur\\\")] = dur\\n initCfg[(\\\"analysis\\\", \\\"plotfI\\\", \\\"targetRates\\\")] = targetRates\\n\\n for k, v in params.items():\\n initCfg[k] = v[0] # initialize params in cfg so they can be modified\\n\\n # fitness function\\n fitnessFuncArgs = {}\\n fitnessFuncArgs[\\\"targetRates\\\"] = targetRates\\n\\n def fitnessFunc(simData, **kwargs):\\n targetRates = kwargs[\\\"targetRates\\\"]\\n\\n diffRates = [abs(x - t) for x, t in zip(simData[\\\"fI\\\"], targetRates)]\\n fitness = np.mean(diffRates)\\n\\n print(\\\" Candidate rates: \\\", simData[\\\"fI\\\"])\\n print(\\\" Target rates: \\\", targetRates)\\n print(\\\" Difference: \\\", diffRates)\\n\\n return fitness\\n\\n # create Batch object with paramaters to modify, and specifying files to use\\n b = Batch(cfgFile='src/cfg.py', netParamsFile='src/netParams.py', params=params, initCfg=initCfg)\\n\\n # Set output folder, grid method (all param combinations), and run configuration\\n b.batchLabel = \\\"ITS4_evol\\\"\\n b.saveFolder = \\\"/tmp/\\\" + b.batchLabel\\n b.method = \\\"evol\\\"\\n b.seed = 0\\n b.runCfg = {\\\"type\\\": \\\"mpi_bulletin\\\", \\\"script\\\": \\\"init.py\\\"}\\n b.evolCfg = {\\n \\\"evolAlgorithm\\\": \\\"custom\\\",\\n \\\"fitnessFunc\\\": fitnessFunc, # fitness expression (should read simData)\\n \\\"fitnessFuncArgs\\\": fitnessFuncArgs,\\n \\\"pop_size\\\": 2,\\n \\\"num_elites\\\": 1, # keep this number of parents for next generation if they are fitter than children\\n \\\"mutation_rate\\\": 0.4,\\n \\\"crossover\\\": 0.5,\\n \\\"maximize\\\": False, # maximize fitness function?\\n \\\"max_generations\\\": 1,\\n \\\"time_sleep\\\": 0.25, # wait this time before checking again if sim is completed (for each generation)\\n \\\"maxiter_wait\\\": 20, # max number of times to check if sim is completed (for each generation)\\n \\\"defaultFitness\\\": 1000, # set fitness value in case simulation time is over\\n }\\n # Run batch simulations\\n b.run()\",\n \"def approximate_gradient(self, theta, c, iter):\\n\\n true_theta = utils.true_param(theta)\\n\\n if self.history_count > 0:\\n current_goal, _ = self.average_evaluations(30)\\n else:\\n current_goal = SPSA_minimization.BAD_GOAL\\n\\n logging.info(f'{__file__} > current_goal: {current_goal}')\\n\\n print(f'current optimizer mean goal: {current_goal:0.5f} (low is better, lowest: -1.0, highest: 1.0)')\\n # print(f'Sample, optimizer goal = -(engine match score) or -(3.0 pts/4 games) or -0.75')\\n\\n bernouilli = self.create_bernouilli(theta)\\n\\n count = 0\\n while True:\\n logging.info(f'{__file__} Apply bernouilli term to theta, theta={theta}, c={c}, bernouilli={bernouilli}')\\n # Calculate two evaluations of f at points M + c * bernouilli and\\n # M - c * bernouilli to estimate the gradient. We do not want to\\n # use a null gradient, so we loop until the two functions evaluations\\n # are different. Another trick is that we use the same seed for the\\n # random generator for the two function evaluations, to reduce the\\n # variance of the gradient if the evaluations use simulations (like\\n # in games).\\n state = random.getstate()\\n theta1 = utils.linear_combinaison(1.0, theta, c, bernouilli)\\n logging.info(f'{__file__} theta1: {theta1}')\\n\\n # Apply parameter limits\\n logging.info(f'{__file__} > Apply limits to theta1 before sending to engine')\\n theta1 = utils.apply_limits(theta1)\\n logging.info(f'{__file__} theta1 with limits: {theta1}')\\n logging.info(f'{__file__} > run 1st match with theta1: {theta1}')\\n\\n random.setstate(state)\\n theta2 = utils.linear_combinaison(1.0, theta, -c, bernouilli)\\n logging.info(f'{__file__} theta2: {theta2}')\\n\\n # Apply parameter limits\\n logging.info(f'{__file__} > Apply limits to theta2 before sending to engine')\\n theta2 = utils.apply_limits(theta2)\\n logging.info(f'{__file__} theta2 with limits: {theta2}')\\n logging.info(f'{__file__} > run 2nd match with theta2: {theta2}')\\n\\n # Run the 2 matches in parallel after iteration 1.\\n manager = multiprocessing.Manager()\\n res = manager.dict()\\n thetas = [theta1, theta2]\\n\\n if iter < self.iter_parallel_start:\\n print('Run match 1 ...')\\n true_param = utils.true_param(theta1)\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n t1 = time.perf_counter()\\n f1 = self.evaluate_goal(theta1, theta, 0, res, iter)\\n logging.info(f'f1 elapse: {time.perf_counter() - t1:0.2f}s')\\n print(f'Done match 1!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n print(f'goal after match 1: {f1:0.5f}')\\n\\n # Run match 2\\n print('Run match 2 ...')\\n true_param = utils.true_param(theta2)\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n t1 = time.perf_counter()\\n f2 = self.evaluate_goal(theta2, theta, 1, res, iter)\\n logging.info(f'f2 elapse: {time.perf_counter() - t1:0.2f}s')\\n print(f'Done match 2!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n print(f'goal after match 2: {f2:0.5f}')\\n\\n print('Done engine match!')\\n else:\\n print('Run 2 matches in parallel ...')\\n t1 = time.perf_counter()\\n jobs = []\\n for i in range(2):\\n print(f'Run match {i + 1} ...')\\n\\n true_param = utils.true_param(thetas[i])\\n print('test_engine param:')\\n for (name, val), (name1, val1) in zip(true_param.items(), true_theta.items()):\\n print(f' {name}: {val[\\\"value\\\"]}, ({val[\\\"value\\\"] - val1[\\\"value\\\"]:+})')\\n\\n print('base_engine param:')\\n for name, val in utils.true_param(theta).items():\\n print(f' {name}: {val[\\\"value\\\"]}')\\n\\n p = multiprocessing.Process(target=self.evaluate_goal, args=(thetas[i], theta, i, res, iter))\\n jobs.append(p)\\n p.start()\\n\\n for num, proc in enumerate(jobs):\\n proc.join()\\n\\n # If match is done in parallel, update the history count, eval and theta here.\\n self.history_eval[self.history_count % 1000] = res.values()[num]\\n self.history_theta[self.history_count % 1000] = thetas[num]\\n self.history_count += 1\\n\\n print(f'Done match {num + 1}!, elapse: {time.perf_counter() - t1:0.2f}sec')\\n\\n logging.info(f'parallel elapse: {time.perf_counter() - t1:0.2f}s')\\n\\n print('Done engine match!')\\n\\n f1, f2 = res.values()[0], res.values()[1]\\n\\n logging.info(f'{__file__} > f1: {f1}, f2: {f2}')\\n print(f'optimizer goal after match 1: {f1:0.5f} (low is better)')\\n print(f'optimizer goal after match 2: {f2:0.5f} (low is better)')\\n\\n if f1 != f2:\\n break\\n\\n print('perf is the same in match 1 and 2, launch new matches ...')\\n\\n count = count + 1\\n logging.info(f'{__file__} > f1 and f2 are the same, try the engine match again. num_tries = {count}')\\n\\n if count >= 100:\\n logging.info(f'{__file__} > too many evaluation to find a gradient, function seems flat')\\n break\\n\\n # Update the gradient\\n gradient = copy.deepcopy(theta)\\n # print(f'Basic gradient after 2 engine matches:')\\n for name, value in theta.items():\\n gradient[name]['value'] = (f1 - f2) / (2.0 * c * bernouilli[name]['value'])\\n # print(f' {name}: {gradient[name][\\\"value\\\"]}')\\n logging.info(f'{__file__} > {name} gradient: {gradient}')\\n\\n if (f1 > current_goal) and (f2 > current_goal):\\n logging.info(f'{__file__} > function seems not decreasing')\\n gradient = utils.linear_combinaison(0.1, gradient)\\n\\n print('Modify the gradient because the results of engine matches\\\\n'\\n 'did not improve when using the new param. But we will not\\\\n'\\n 're-run the engine matches.')\\n\\n print('Modified gradient at alpha=0.1:')\\n for n, v in gradient.items():\\n print(f' {n}: {v[\\\"value\\\"]}')\\n\\n # For the correction factor used in the running average for the gradient,\\n # see the paper \\\"Adam: A Method For Stochastic Optimization, Kingma and Lei Ba\\\"\\n\\n beta = 0.9\\n correction = 1.0 / 1.0 - pow(beta, self.iter)\\n\\n gradient = utils.linear_combinaison((1 - beta), gradient, beta, self.previous_gradient)\\n gradient = utils.linear_combinaison(correction, gradient)\\n\\n # print('New gradient after applying correction:')\\n # for n, v in gradient.items():\\n # print(f' {n}: {v[\\\"value\\\"]}')\\n\\n # Store the current gradient for the next time, to calculate the running average\\n self.previous_gradient = gradient\\n\\n # Store the best the two evals f1 and f2 (or both)\\n if (f1 <= current_goal):\\n self.best_eval[self.best_count % 1000] = f1\\n self.best_theta[self.best_count % 1000] = theta1\\n self.best_count += 1\\n\\n if (f2 <= current_goal):\\n self.best_eval[self.best_count % 1000] = f2\\n self.best_theta[self.best_count % 1000] = theta2\\n self.best_count += 1\\n\\n logging.info(f'{__file__} > final gradient: {gradient}')\\n \\n # Return the estimation of the new gradient\\n return gradient\",\n \"def iterate_data(dataset,iter_no=5,pixel_mask=None,plot_clear=True,algo=\\\"FordRollett\\\",unit_weights=False):\\n import overlap\\n start_gain = array.ones(len(dataset))\\n if unit_weights is True:\\n weights = array.ones_like(dataset)\\n else:\\n weights = 1.0/dataset.var\\n # Use weights as the mask\\n if pixel_mask is not None:\\n weights = weights*pixel_mask\\n if algo == \\\"FordRollett\\\":\\n gain,first_ave,ar,esds,k = overlap.find_gain_fr(dataset,weights,start_gain,pixel_mask=pixel_mask)\\n else:\\n raise ValueError(\\\"No such algorithm: %s\\\" % algo)\\n chisquared,residual_map = overlap.get_statistics_fr(gain,first_ave,dataset,dataset.var,pixel_mask)\\n old_result = first_ave #store for later\\n chisq_history = [chisquared]\\n k_history = [k]\\n if iter_no > 0: \\n no_iters = iter_no\\n else:\\n no_iters = abs(iter_no)\\n for cycle_no in range(no_iters+1):\\n esdflag = (cycle_no == no_iters) # need esds as well, and flags the last cycle\\n print 'Cycle %d' % cycle_no\\n if cycle_no > 3 and iter_no < 0:\\n esdflag = (esdflag or (abs(chisq_history[-2]-chisq_history[-1]))<0.005)\\n if algo == \\\"FordRollett\\\":\\n gain,interim_result,ar,esds,k = overlap.find_gain_fr(dataset,weights,gain,arminus1=ar,pixel_mask=pixel_mask,errors=esdflag)\\n chisquared,residual_map = overlap.get_statistics_fr(gain,interim_result,dataset,dataset.var,pixel_mask)\\n chisq_history.append(chisquared)\\n k_history.append(k)\\n if esdflag is True:\\n break\\n print 'Chisquared: ' + `chisq_history`\\n print 'K: ' + `k_history`\\n print 'Total cycles: %d' % cycle_no\\n print 'Maximum shift/error: %f' % max(ar/esds)\\n return gain,dataset,interim_result,residual_map,chisq_history,esds,first_ave,weights\",\n \"def derivatives(self, increment_filter):\\n ######################################################################\\n # derivatives fluid and mass balance are static\\n k = self.num_nw_fluids + 1\\n\\n ######################################################################\\n # derivatives for specified heat transfer\\n if self.Q.is_set:\\n self.jacobian[k, 0, 0] = (\\n self.outl[0].h.val_SI - self.inl[0].h.val_SI)\\n self.jacobian[k, 0, 2] = -self.inl[0].m.val_SI\\n self.jacobian[k, 1, 2] = self.inl[0].m.val_SI\\n # custom variable Q\\n if self.Q.is_var:\\n self.jacobian[k, 2 + self.Q.var_pos, 0] = -1\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified pressure ratio\\n if self.pr.is_set:\\n self.jacobian[k, 0, 1] = self.pr.val\\n self.jacobian[k, 1, 1] = -1\\n # custom variable pr\\n if self.pr.is_var:\\n self.jacobian[k, 2 + self.pr.var_pos, 0] = (\\n self.inl[0].p.val_SI)\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified zeta\\n if self.zeta.is_set:\\n f = self.zeta_func\\n if not increment_filter[0, 0]:\\n self.jacobian[k, 0, 0] = self.numeric_deriv(\\n f, 'm', 0, zeta='zeta')\\n if not increment_filter[0, 2]:\\n self.jacobian[k, 0, 1] = self.numeric_deriv(\\n f, 'p', 0, zeta='zeta')\\n if not increment_filter[0, 2]:\\n self.jacobian[k, 0, 2] = self.numeric_deriv(\\n f, 'h', 0, zeta='zeta')\\n if not increment_filter[1, 1]:\\n self.jacobian[k, 1, 1] = self.numeric_deriv(\\n f, 'p', 1, zeta='zeta')\\n if not increment_filter[1, 2]:\\n self.jacobian[k, 1, 2] = self.numeric_deriv(\\n f, 'h', 1, zeta='zeta')\\n # custom variable zeta\\n if self.zeta.is_var:\\n self.jacobian[k, 2 + self.zeta.var_pos, 0] = (\\n self.numeric_deriv(f, 'zeta', 2, zeta='zeta'))\\n k += 1\\n\\n ######################################################################\\n # derivatives for specified hydro-group parameters\\n if self.hydro_group.is_set:\\n # hazen williams equation\\n if self.hydro_group.method == 'HW':\\n func = self.hw_func\\n # darcy friction factor\\n else:\\n func = self.darcy_func\\n\\n if not increment_filter[0, 0]:\\n self.jacobian[k, 0, 0] = self.numeric_deriv(func, 'm', 0)\\n if not increment_filter[0, 1]:\\n self.jacobian[k, 0, 1] = self.numeric_deriv(func, 'p', 0)\\n if not increment_filter[0, 2]:\\n self.jacobian[k, 0, 2] = self.numeric_deriv(func, 'h', 0)\\n if not increment_filter[1, 1]:\\n self.jacobian[k, 1, 1] = self.numeric_deriv(func, 'p', 1)\\n if not increment_filter[1, 2]:\\n self.jacobian[k, 1, 2] = self.numeric_deriv(func, 'h', 1)\\n # custom variables of hydro group\\n for var in self.hydro_group.elements:\\n if var.is_var:\\n self.jacobian[k, 2 + var.var_pos, 0] = (\\n self.numeric_deriv(func, self.vars[var], 2))\\n k += 1\\n\\n ######################################################################\\n # derivatives for additional equations\\n self.additional_derivatives(increment_filter, k)\",\n \"def fit(self, channel, noise_var, noised_signal, stop_iter=10):\\n for i in range(stop_iter):\\n self.global_iter_num = i\\n \\n self.get_parameter_s_from_q(channel, noise_var, noised_signal)\\n self.update_r()\\n self.get_parameter_s_from_r(channel, noise_var, noised_signal)\\n self.update_q()\",\n \"def compute_gravity(self):\\r\\n # compute the gravity from the Gauss form.\\r\\n # if it fails, marks divergence\\r\\n try:\\r\\n self.gravsolver.solve()\\r\\n except:\\r\\n print(\\\"GRAVITY DIVERGED\\\")\\r\\n\\r\\n # write to log\\r\\n self.logfile.write(\\\"%s: STOPPED DUE TO DIVERGENCE IN GRAVITY \\\\n\\\" %\\r\\n (self.convert_time(time.time() -\\r\\n self.start_time)))\\r\\n self.diverged = True # set diverged to True, break the run\\r\\n return\\r\\n\\r\\n # split and update the gravity function with the answers\\r\\n # note the gravscale\\r\\n gravg, gravs = self.gravgs.split()\\r\\n\\r\\n # assign the result to the gravity function\\r\\n self.gravity.assign(project(gravg/self.gravscale, self.V))\",\n \"def magic_sample(self, ys):\\n\\n #for each non-zero element in y\\n #we want to multiply the initial state by HGate(i) SGate(i) HGate(i)\\n #this turns out to be equivalent to multiplying the whole final state by\\n #U H_k S_k H_k U^\\\\dagger\\n #but H_k S_k H_k = e^{i\\\\pi/4} \\\\frac{1}{\\\\sqrt{2}} (I -i X_k)\\n #so now we evolve identity forward by U (trivial)\\n #and evolve X_k forward by U (using the AGState)\\n #then we have to send the resulting Pauli through UC and UH\\n #giving a third Pauli\\n #then the state is of the form (we^{i\\\\pi/4}) UC UH (I + i^d P)/sqrt(2) |s>\\n #then we apply Bravyi et al's prop. 4 to turn this into a new ch form\\n \\n\\n chCopy = deepcopy(self.chState) #we update this copy as we go\\n\\n for i, y in enumerate(ys):\\n if y:\\n #we want to know what U_c^\\\\dagger U X_i U^\\\\dagger U_c is\\n #firstly we use the A-G info\\n # U X_i U^\\\\dagger is the i'th destabiliser\\n x = self.agState.x[self.n+i]\\n z = self.agState.z[self.n+i]\\n r = self.agState.r[self.n+i]\\n\\n #print(x,z,r)\\n x_col = np.array([x]).T\\n z_col = np.array([z]).T\\n \\n #now we apply U_c to this using the CH-form info\\n x_mat = chCopy.F * x_col\\n z_mat = (chCopy.M * x_col + chCopy.G*z_col) % np.uint8(2)\\n r = (r + util.sort_pauli_string(x_mat, z_mat)) % np.uint8(2)\\n\\n u = (x @ chCopy.F) % np.uint8(2)\\n h = (x @ chCopy.M + z @ chCopy.G) % np.uint8(2)\\n\\n g = (x @ (z + chCopy.g)) % np.uint8(4)\\n\\n #now U_c^dag U X_i U^dag U_C = (-1)^r i^g prod_j Z_j^{h_j} X_j^{u_j}\\n #we want to conjugate this by U_H\\n #everywhere chCopy.v == 1 we flip a z to an x and an x to a z\\n #everywhere chCopy.v == 1 and u == 1 and h == 1 we need to swap the order of our x and z so we get a minus sign\\n\\n u2 = u*(np.uint8(1) ^ chCopy.v) ^ (h*chCopy.v)\\n h2 = (u*chCopy.v) ^ (h*(np.uint8(1) ^ chCopy.v))\\n\\n r = (r + (u*h*chCopy.v).sum()) % np.uint8(2)\\n \\n \\n #now U_H^dag U_c^dag U X_i U^dag U_C U_H = (-1)^r i^g prod_j Z_j^{h2_j} X_j^{u2_j}\\n\\n t = u2 ^ chCopy.s\\n r = (r + h2 @ t) % np.uint8(2)\\n\\n #now we have w UC UH |s> = w (-1)^r (i)^g UC UH |t>\\n\\n if all(t == chCopy.s):\\n chCopy.w *= np.exp(1j*np.pi/4) * (1 + (1j)**(g+2*r -1) )/ np.sqrt(2)\\n else:\\n phase, VCList, v, s = util.desuperpositionise(chCopy.s, t, (g+2*r -1)%np.uint8(4), chCopy.v)\\n\\n chCopy.w *= phase*np.exp(1j*np.pi/4)/np.sqrt(2)\\n chCopy.v = v\\n chCopy.s = s\\n\\n for gate in VCList:\\n gate.rightMultiplyC(chCopy)\\n \\n return chCopy\",\n \"def step(self):\\n if self.store_paths:\\n leapfrog_steps = self._max_leapfrog_steps\\n else:\\n leapfrog_steps = torch.ceil(self._max_leapfrog_steps * torch.rand(1)).int()\\n self.potential_ = self.get_potential()\\n self.metric_ = self.get_metric()\\n self.momentum = self.resample_momenta()\\n self.hamiltonian_ = self.get_hamiltonian()\\n old_hamiltonian = self.hamiltonian_\\n if self.shadow:\\n if self.max_shadow is not None:\\n old_shadow = torch.max(self.shadow_.clone() + self.max_shadow, old_hamiltonian)\\n else:\\n old_shadow = self.shadow_.clone()\\n rejected = False\\n for step in range(leapfrog_steps):\\n if (self._integrator == 'RMHMC') and (self.lbfgs == False):\\n self.momentum, rejected = self.implicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n self.parameters, rejected = self.implicit_drift()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n self.momentum, rejected = self.explicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n elif self.lbfgs == True:\\n self.momentum, rejected = self.lbfgs_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n self.parameters, rejected = self.lbfgs_drift()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n self.momentum = self.explicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if rejected:\\n break\\n else:\\n self.momentum, rejected = self.explicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n self.parameters = self.explicit_drift()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n self.momentum, rejected = self.explicit_half_kick()\\n self.parameters = self.parameters.detach().requires_grad_(True)\\n if self.store_paths:\\n self.paths.append(self.parameters.detach())\\n new_hamiltonian = self.get_hamiltonian()\\n ratio = old_hamiltonian - new_hamiltonian\\n self.hamiltonian_error.append(ratio.detach().unsqueeze(0))\\n if self.shadow:\\n if self.max_shadow is not None:\\n new_shadow = torch.max(self.get_shadow() + self.max_shadow, new_hamiltonian)\\n else:\\n new_shadow = self.get_shadow()\\n shadow_error = old_shadow - new_shadow\\n newratio = ratio + shadow_error\\n self.shadow_hamiltonian_error.append(newratio.detach().unsqueeze(0))\\n ratio = newratio\\n\\n uniform_rand = torch.rand(1)\\n if uniform_rand >= torch.exp(ratio):\\n # Reject sample\\n rejected = True\\n\\n if rejected:\\n if (len(self.momenta) > 10) and (self.momenta[-1] == self.momenta[-10]).sum().item():\\n self.degenerate = True\\n self.rejected += 1\\n self.momentum = self.momenta[-1]\\n self.parameters = self.samples[-1].clone().detach().requires_grad_(True)\\n if self.shadow:\\n radon_nikodym = torch.exp(old_shadow).unsqueeze(0)\\n \\n if self.verbose:\\n print(\\\"(Rejected)\\\", int(self.acceptance_rate() * 100), \\\"%; Log-ratio: \\\",\\n ratio.detach())\\n else:\\n self.accepted += 1\\n if self.shadow:\\n radon_nikodym = torch.exp(new_shadow).unsqueeze(0)\\n if self.verbose:\\n print(\\\"(Accepted)\\\", int(self.acceptance_rate() * 100), \\\"%; Log-ratio: \\\",\\n ratio.detach())\\n self.samples.append(self.parameters.detach())\\n self.momenta.append(self.momentum)\\n self.hamiltonians.append(self.hamiltonian_.detach())\\n self.rands_.append(uniform_rand)\\n self.shadows.append(self.shadow_.detach())\\n if self.shadow:\\n self.radon_nikodym.append(radon_nikodym.detach())\\n return None\",\n \"def sample_refine(self, **kwargs):\",\n \"def sgd(params, grads, lr, batch_size): #@save\\n for param, grad in zip(params, grads):\\n param.assign_sub(lr*grad/batch_size)\",\n \"def run_gravity_analysis(steps=10):\\n ops.wipeAnalysis()\\n ops.system(\\\"BandGeneral\\\")\\n ops.numberer(\\\"RCM\\\")\\n ops.constraints(\\\"Transformation\\\")\\n ops.test(\\\"NormDispIncr\\\", 1.0E-12, 10, 3)\\n ops.algorithm(\\\"Newton\\\") # KrylovNewton\\n ops.integrator(\\\"LoadControl\\\", 1/steps)\\n ops.analysis(\\\"Static\\\")\\n ops.analyze(steps)\\n title(\\\"Gravity Analysis Completed!\\\")\\n # Set the gravity loads to be constant & reset the time in the domain\\n ops.loadConst(\\\"-time\\\", 0.0)\\n ops.wipeAnalysis()\",\n \"def GaussSeidelSmoother(iterations=1, sweep='forward'):\\n from .relaxation import gauss_seidel\\n def apply(A, u, f):\\n gauss_seidel(A, u, f, iterations=iterations, sweep=sweep)\\n return apply\",\n \"def apply(self, field):\\n with timed_stage('limiter'):\\n if self.squeezed_triangles:\\n self.squeezed_filter.apply(field)\\n\\n if self.is_vector:\\n tmp_func = self.P1DG.get_work_function()\\n fs = field.function_space()\\n for i in range(fs.value_size):\\n tmp_func.dat.data_with_halos[:] = field.dat.data_with_halos[:, i]\\n super(VertexBasedP1DGLimiter, self).apply(tmp_func)\\n field.dat.data_with_halos[:, i] = tmp_func.dat.data_with_halos[:]\\n self.P1DG.restore_work_function(tmp_func)\\n else:\\n super(VertexBasedP1DGLimiter, self).apply(field)\",\n \"def _function(self):\\n\\n\\n\\n def calculate_weights():\\n \\\"\\\"\\\"\\n calculate a weight inversely proportional to the expected to duration of the two steps in the\\n script\\n\\n Returns: weights as a dictionary for the two steps\\n\\n \\\"\\\"\\\"\\n weights = {}\\n\\n\\n # estimate run time of step 1 (fast sweep)\\n f_range = sweeper_script.settings['stop'] - sweeper_script.settings['start']\\n N_samples = sweeper_script.settings['samplecount']\\n df = f_range / N_samples\\n\\n t = N_samples / df\\n\\n weights['quick scan'] = t\\n\\n # estimate run time of step 2 (high res sweep)\\n df = self.settings['high_res_df']\\n N_samples = self.settings['high_res_N']\\n\\n t = N_samples / df\\n\\n weights['high res scan'] = t\\n\\n\\n total_time = sum([v for k, v in weights.iteritems()])\\n\\n weights = {k: v/total_time for k, v in weights.iteritems()}\\n\\n print('weights',weights)\\n\\n return weights\\n\\n def run_scan(name):\\n self.current_subscript = name\\n sweeper_script.start()\\n while self.current_subscript is name:\\n time.sleep(0.1)\\n\\n def calc_new_range():\\n\\n\\n df = self.settings['high_res_df']\\n N = self.settings['high_res_N']\\n\\n r = sweeper_script.data[-1]['r']\\n freq = sweeper_script.data[-1]['frequency']\\n freq = freq[np.isfinite(r)]\\n r = r[np.isfinite(r)]\\n\\n fo = freq[np.argmax(r)]\\n\\n f_start, f_end = fo - N/2 *df, fo + N/2 *df\\n\\n\\n # make sure that we convert back to native python types (numpy file types don't pass the Parameter validation)\\n return float(f_start), float(f_end), int(N)\\n\\n\\n sweeper_script = self.scripts['zi sweep']\\n #save initial settings, so that we can rest at the end of the script\\n initial_settings = deepcopy(sweeper_script.settings)\\n self.weights = calculate_weights()\\n\\n # take the signal from the subscript and route it to a function that takes care of it\\n sweeper_script.updateProgress.connect(self._receive_signal)\\n\\n print('====== start quick scan ============')\\n\\n run_scan('quick scan')\\n\\n print('====== calculate new scan range ====')\\n f_start, f_stop, N = calc_new_range()\\n\\n print('f_start, f_stop, N', f_start, f_stop, N)\\n\\n print('====== update sweeper ==============')\\n sweeper_script.update({\\n 'start' : f_start,\\n 'stop' : f_stop,\\n 'samplecount' : N\\n })\\n\\n print('====== start high res scan =========')\\n # print(sweeper_script.sweeper.finished())\\n # print(sweeper_script.sweeper.progress())\\n\\n run_scan('high res scan')\\n\\n sweeper_script.updateProgress.disconnect()\\n self.data = sweeper_script.data[-1]\\n\\n self._recording = False\\n\\n if self.settings['save']:\\n self.save()\\n\\n # set the sweeper script back to initial settings\\n sweeper_script.update(initial_settings)\\n # make sure that progess is set 1o 100 because we check that in the old_gui\\n self.updateProgress.emit(100)\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n\\n for p in group['params']:\\n if p.grad is None:\\n grad = p.grad\\n continue\\n else:\\n grad =p.grad\\n\\n # s = self.spikes.popitem()\\n #grad = jnp.matmul(p.grad, s.data)\\n\\n\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['exp_avg'] = jnp.zeros(grad.shape)\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = jnp.zeros(grad.shape)\\n\\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\\n beta1, beta2 = group['betas']\\n\\n state['step'] += 1\\n\\n if group['weight_decay'] != 0:\\n grad += group['weight_decay'] * p.data\\n\\n # Decay the first and second moment running average coefficient\\n exp_avg = exp_avg * beta1 + (1 - beta1) * grad\\n exp_avg_sq = exp_avg_sq * beta2 + (1 - beta2) * grad * grad\\n denom = jnp.sqrt(exp_avg_sq) + group['eps']\\n\\n bias_correction1 = 1 - beta1 ** state['step']\\n bias_correction2 = 1 - beta2 ** state['step']\\n step_size = group['lr'] * jmath.sqrt(bias_correction2) / bias_correction1\\n\\n p.data += -step_size * exp_avg / denom\\n\\n return loss\",\n \"def softclippingHGMevaluation(input_generator,branches,iden_method,Plot,reference=None):\\n for t in range(8,11):\\n t = t / 10.0\\n p = 1.0 - t\\n input_signal = input_generator.GetOutput()\\n nl_functions = [nlsp.function_factory.softclip(power=p),]*branches\\n filter_spec_tofind = nlsp.log_bpfilter(branches=branches, input=input_signal)\\n ref_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\\n nonlinear_functions=nl_functions,\\n filter_irs=filter_spec_tofind,\\n max_harmonics=range(1,branches+1))\\n\\n found_filter_spec, nl_functions = iden_method(input_generator,ref_nlsystem.GetOutput(),branches)\\n iden_nlsystem = nlsp.HammersteinGroupModel_up(input_signal=input_signal,\\n nonlinear_functions=nl_functions,\\n filter_irs=found_filter_spec,\\n max_harmonics=range(1,branches+1))\\n # sine = sumpf.modules.SineWaveGenerator(frequency=5000.0,phase=0.0,samplingrate=input_signal.GetSamplingRate(),length=len(input_signal)).GetSignal()\\n sine = sumpf.modules.SweepGenerator(samplingrate=input_signal.GetSamplingRate(),length=len(input_signal)).GetSignal()\\n ref_nlsystem.SetInput(sine)\\n iden_nlsystem.SetInput(sine)\\n if reference is not None:\\n reference = nlsp.change_length_signal(reference,length=len(input_signal))\\n ref_nlsystem.SetInput(reference)\\n iden_nlsystem.SetInput(reference)\\n\\n if Plot is True:\\n plot.relabelandplot(sumpf.modules.FourierTransform(ref_nlsystem.GetOutput()).GetSpectrum(),\\\"Reference System\\\",show=False)\\n plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem.GetOutput()).GetSpectrum(),\\\"Identified System\\\",show=False)\\n print \\\"SNR between Reference and Identified output for symmetric hardclipping HGM(threshold:%r): %r\\\" %(t,nlsp.snr(ref_nlsystem.GetOutput(),\\n iden_nlsystem.GetOutput()))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56499416","0.5638964","0.559936","0.55021787","0.54349416","0.53798175","0.5369566","0.53046954","0.52480394","0.52229273","0.5188865","0.51813334","0.51805145","0.5169596","0.513884","0.51108414","0.5085409","0.5055628","0.504844","0.5031253","0.50300574","0.50059116","0.49997154","0.49921116","0.49863032","0.49792093","0.49672055","0.4937295","0.49156523","0.48636192","0.48573065","0.4857298","0.48554897","0.4847248","0.48471504","0.48412168","0.48263547","0.48190212","0.4818455","0.48129338","0.4807995","0.48026913","0.4792697","0.4791153","0.47841385","0.4776715","0.4775058","0.4768771","0.47623646","0.47617579","0.47606823","0.47583503","0.4752525","0.47518992","0.47510326","0.47497937","0.47485805","0.4748171","0.47462624","0.47412187","0.47392642","0.47307143","0.4729343","0.47201553","0.4718474","0.4715976","0.47151634","0.4711224","0.4711219","0.47110325","0.4707776","0.4705392","0.47023556","0.46973434","0.46908224","0.46895996","0.4688774","0.468465","0.4683458","0.4680461","0.46779266","0.46773097","0.4677301","0.4664027","0.46624067","0.46589512","0.4657695","0.46534005","0.46523404","0.46499762","0.46496785","0.46476883","0.46422803","0.46402815","0.46330562","0.46314955","0.46294987","0.46277928","0.4624517","0.46126258"],"string":"[\n \"0.56499416\",\n \"0.5638964\",\n \"0.559936\",\n \"0.55021787\",\n \"0.54349416\",\n \"0.53798175\",\n \"0.5369566\",\n \"0.53046954\",\n \"0.52480394\",\n \"0.52229273\",\n \"0.5188865\",\n \"0.51813334\",\n \"0.51805145\",\n \"0.5169596\",\n \"0.513884\",\n \"0.51108414\",\n \"0.5085409\",\n \"0.5055628\",\n \"0.504844\",\n \"0.5031253\",\n \"0.50300574\",\n \"0.50059116\",\n \"0.49997154\",\n \"0.49921116\",\n \"0.49863032\",\n \"0.49792093\",\n \"0.49672055\",\n \"0.4937295\",\n \"0.49156523\",\n \"0.48636192\",\n \"0.48573065\",\n \"0.4857298\",\n \"0.48554897\",\n \"0.4847248\",\n \"0.48471504\",\n \"0.48412168\",\n \"0.48263547\",\n \"0.48190212\",\n \"0.4818455\",\n \"0.48129338\",\n \"0.4807995\",\n \"0.48026913\",\n \"0.4792697\",\n \"0.4791153\",\n \"0.47841385\",\n \"0.4776715\",\n \"0.4775058\",\n \"0.4768771\",\n \"0.47623646\",\n \"0.47617579\",\n \"0.47606823\",\n \"0.47583503\",\n \"0.4752525\",\n \"0.47518992\",\n \"0.47510326\",\n \"0.47497937\",\n \"0.47485805\",\n \"0.4748171\",\n \"0.47462624\",\n \"0.47412187\",\n \"0.47392642\",\n \"0.47307143\",\n \"0.4729343\",\n \"0.47201553\",\n \"0.4718474\",\n \"0.4715976\",\n \"0.47151634\",\n \"0.4711224\",\n \"0.4711219\",\n \"0.47110325\",\n \"0.4707776\",\n \"0.4705392\",\n \"0.47023556\",\n \"0.46973434\",\n \"0.46908224\",\n \"0.46895996\",\n \"0.4688774\",\n \"0.468465\",\n \"0.4683458\",\n \"0.4680461\",\n \"0.46779266\",\n \"0.46773097\",\n \"0.4677301\",\n \"0.4664027\",\n \"0.46624067\",\n \"0.46589512\",\n \"0.4657695\",\n \"0.46534005\",\n \"0.46523404\",\n \"0.46499762\",\n \"0.46496785\",\n \"0.46476883\",\n \"0.46422803\",\n \"0.46402815\",\n \"0.46330562\",\n \"0.46314955\",\n \"0.46294987\",\n \"0.46277928\",\n \"0.4624517\",\n \"0.46126258\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54431874"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":86093,"cells":{"query":{"kind":"string","value":"Perform a chi square test. Returns"},"document":{"kind":"string","value":"def run_chi2(self, silent_run=False):\n self.chi2 = (self.obs - self.exp)**2.\n self.chi2.data /= self.exp.data**2.\n if not silent_run:\n return self.chi2"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_chi_2(self):\n NN = 4\n w = 0.01\n kz = 1.0e-7\n kp = 3.0e-7\n wp = 2.0e3\n tz = 2.0e-18\n tp = 1.0e-18\n vthz = 1e5\n vthp = 1e5\n omega = 0.1\n vz = 100.\n\n chi = f_chi(NN, w, kz, kp, wp, tz, tp, vthz, vthp,\n omega, vz, method = 'numpy')/w**2\n expected_chi = np.array([\n [4.972725326e8, 3.812283500e9j, -3.086420946e8],\n [-3.812283500e9j, -3.037753676e9 + 1.098455531e9j, -3.661518437e9-3.465700712e8j],\n [-3.086420946e8, 3.661518437e9+3.465700712e8j, -1.976136342e9 + 2.497184730e10j]])\n npt.assert_allclose(chi, expected_chi, rtol = 1e-7)","def chisq_test(observed):\n\tn, k = observed.shape\n\trow = observed.sum(axis=0).reshape(1,-1)\n\tcol = observed.sum(axis=1).reshape(-1,1)\n\texpected = np.dot(col, row)/observed.sum()\n\t#chi2, pvalue = scipy.stats.mstats.chisquare(observed.ravel(), expected.ravel(), ddof = n+k-2)\n\tchi2 = (((observed-expected)**2)/expected).sum()\n\tpvalue = 1-scipy.stats.chi2.cdf(chi2, (n-1)*(k-1))\n\tmessage = \"\"\"\n\tPerforming the test of independence in\ta contingency table.\n\ttest statistic: %(chi2)s\n\tdegrees of freedom: %(df)s\n\tp-value: %(pvalue)s\n\t\"\"\" % {'chi2': chi2, 'df': (n-1)*(k-1), 'pvalue': pvalue}\n\tprint(message)\n\twarning = \"\"\"\n\tWarning message:\n\tChi-squared approximation may be incorrect\n\t\"\"\"\n\tif expected.min() < 5:\n\t\tprint(warning)\n\treturn chi2, pvalue","def test_chi_1(self):\n NN = 0\n w = 0.01\n kz = 1.0e-7\n kp = 1.0e-7\n wp = 2.0e3\n tz = 1.0e-18\n tp = 1.0e-18\n vthz = 1e5\n vthp = 1e5\n omega = 0.1\n vz = 100.\n\n chi = f_chi(NN, w, kz, kp, wp, tz, tp, vthz, vthp,\n omega, vz, method = 'numpy')/w**2\n expected_chi = np.array([\n [0,0,0],\n [0, -4.268813377e8+2.591303241e8j, -2.591303241e9-3.026588661e8j],\n [0, 2.591303241e9+3.026588661e8j, -5.988348146e9+5.195595431e10j]])\n npt.assert_allclose(chi, expected_chi, rtol = 1e-7)","def chi_sq ( ) :\n \n # get the list of all files\n die_file_paths = _sort_all_apropriate_files(options.input)\n temp_tuples = [ ]\n \n # open the files and arrange the info into tuples\n for die_file_path in die_file_paths :\n \n #print\n #print (\"loading die information from file: \" + die_file_path)\n die_description, die_roll_dict = _read_die_file (die_file_path)\n temp_tuples.append((die_description, die_roll_dict.values()))\n \n # analyze the info from each file with a chi squared test\n chi_sq_results = _calculate_chi_squared(temp_tuples)\n \n # display the results\n print (\"-----\")\n for desc_text in sorted(chi_sq_results.keys()) :\n \n (chi_sq_stat, p_value) = chi_sq_results[desc_text]\n print (\"analysis of die: \" + desc_text.strip())\n print (\"chi squared stat: \" + str(chi_sq_stat))\n print (\"p value: \" + str(p_value))\n print (\"-----\")","def chi(self):\n return self._chi","def chi_square_analysis(obs_list):\r\n obs = np.array(obs_list)\r\n chi2, p, dof, expected = chi2_contingency(obs)\r\n return chi2, p, dof, expected","def calculate_chi_squared(self):\n chi = 0\n obsVals, expVals = self.calculate_obs_and_exp()\n for i in range(4):\n if expVals[i] != 0:\n chi += (obsVals[i] - expVals[i])**2 / expVals[i]\n return chi","def chibar(z):\n return chi(z)","def chi_square_test(data, var1, var2, pairwise = False, alpha = 0.05): \n cont_table = pd.crosstab(data[var1], data[var2])\n if not pairwise:\n missing_indices = find_indices_with_value(cont_table, 0)\n cont_table = cont_table.drop(missing_indices)\n chi2, p, df, exp = stats.chi2_contingency(cont_table)\n if (p < alpha): \n print(\"statistically significant: %s\" % (tuple([var1, var2]), ))\n print(\"p-value is \" + str(p))\n display(cont_table.apply(lambda r: 100 * r/r.sum(), axis=0))\n\n return chi2, p, df, exp\n else:\n pairs = [\",\".join(map(str, comb)).split(\",\") for comb in combinations(cont_table.columns, 2)]\n for pair in pairs:\n cont_table2 = cont_table[pair]\n missing_indices = find_indices_with_value(cont_table2, 0)\n cont_table2 = cont_table2.drop(missing_indices)\n \n chi2, p, df, exp = stats.chi2_contingency(cont_table2)\n if (p < alpha): \n print(\"statistically significant: %s\" % (tuple(pair), ))\n print(\"p-value is \" + str(p))\n display(cont_table2.apply(lambda r: 100 * r/r.sum(), axis=0))","def chi_square(self, collocation):\n terms = collocation.split()\n\n # compute 2 X 2 table here\n array = [[], []]\n array[0] = [float(self.combined_freq[collocation]), float(self.combined_freq[terms[1]] - self.combined_freq[collocation])]\n array[1] = [float(self.combined_freq[terms[0]]) - float(self.combined_freq[collocation]),\n float(len(self.combined_freq) - ((2.0 * float(self.combined_freq[collocation])) +\n float(self.combined_freq[terms[0]]) + float(self.combined_freq[terms[1]])))]\n\n # convert to nd array\n array = np.array(array)\n\n # compute chi square statistic\n chi_square = (float(len(self.combined_freq)) * pow(((array[0, 0] * array[1, 1]) - (array[0, 1] * array[1, 0])), 2)) /\\\n ((array[0, 0] + array[0, 1]) * (array[0, 0] + array[1, 0]) * (array[0, 1] + array[1, 1]) *\n (array[1, 0] + array[1, 1]))\n return chi_square","def chi2(data, fdata, err):\n return sum(((data-fdata)/err)**2)","def test_chi_3(self):\n NN = 3\n w = 0.09578833596200093\n kz = 1.5975774807850725e-06\n kp = 1.5975774807850725e-06\n wp = 4789.4167982678364\n tz = 217763.9218377612\n tp = 195987.52965398508\n vthz = 59958.491600000001\n vthp = 56881.619557222031\n omega = 0.9578833596200093\n vz = 0.\n\n chi = f_chi(NN, w, kz, kp, wp, tz, tp, vthz, vthp,\n omega, vz, method = 'numpy')\n expected_chi = np.array([[246532.0684, 2.3160720168e6j, -14138.594698],\n [-2.31607201685e6j, 25210.8159178 + \n 120337.3246248j,-1.33708138e6-143053.010866j],\n [-14138.594698, 1.33708138472e6 + 143053.010866j, -3.4654579662e6 + 2.977992432056e7j]])\n npt.assert_allclose(chi, expected_chi, rtol = 1e-7)","def compare_sums_chi(array1, array2):\n return stats.chisquare(array1, array2)","def _chisquare_value(self):\n x2 = np.sum((np.absolute(self.observed - self.expected) - (0.5 * self.continuity_correction)) ** 2 /\n self.expected)\n\n return x2","def test_l19_chi(self):\n beta_calc_chisq = BetaDiversityCalc(dist_chisq, 'chi square', False)\n matrix, labels = beta_calc_chisq(data_path=self.l19_str, tree_path=None)\n self.assertEqual(labels, self.l19_sample_names)\n self.assertFloatEqual(matrix, dist_chisq(self.l19_data))","def test_l19_chi(self):\n beta_calc_chisq = BetaDiversityCalc(dist_chisq, 'chi square', False)\n matrix, labels = beta_calc_chisq(data_path=self.l19_str, tree_path=None)\n self.assertEqual(labels, self.l19_sample_names)\n self.assertFloatEqual(matrix, dist_chisq(self.l19_data))","def task_6_2_1():\n # TODO Task 6.2.1: Your code goes here\n x = []\n for i in range(100):\n xi = 0\n xi = numpy.random.normal(0, 1)\n x.append(xi)\n\n bins = 15\n emp_n, emp_x = numpy.histogram(x, bins=bins)\n Ch_2 = ChiSquare(emp_x, emp_n)\n Ch_2.test_distribution(0.05, 0, 1)\n # pass","def chi(Mu, Y):\n return Y*(1-hg2f3(Mu,Y))","def test_l19_chi(self):\r\n beta_calc_chisq = BetaDiversityCalc(dist_chisq, 'chi square', False)\r\n matrix, labels = beta_calc_chisq(data_path=self.l19_fp, tree_path=None)\r\n self.assertEqual(labels, self.l19_sample_names)\r\n assert_almost_equal(matrix, dist_chisq(self.l19_data))","def test_chi2(y0, y1, level):\n if len(y0) == 0 or len(y1) == 0:\n return True\n l0 = np.argmax(y0, axis=1)\n l1 = np.argmax(y1, axis=1)\n v, c = np.unique(np.append(l0,l1), return_counts=True)\n v0, c0 = np.unique(l0, return_counts=True)\n v1, c1 = np.unique(l1, return_counts=True)\n p = np.zeros(len(y0[0]))\n p0 = p.copy()\n p1 = p.copy()\n p[v] = c / np.sum(c)\n p0[v0] = c0 / np.sum(c0)\n p1[v1] = c1 / np.sum(c1)\n p0[p0==0] = 0.05\n p1[p1 == 0] = 0.05\n p[p==0] = 0.05\n _, p0_value = stat.chisquare(p0, p)\n _, p1_value = stat.chisquare(p1, p)\n if 1-p0_value > level or 1-p1_value > level:\n return False\n else:\n return True","def calc_torsion_chi(self):\n return (self.calc_torsion(\"chi1\"),\n self.calc_torsion(\"chi2\"),\n self.calc_torsion(\"chi3\"),\n self.calc_torsion(\"chi4\"))","def chi_squared(*choices):\n\n term = lambda expected, observed: float((expected - observed) ** 2) / max(expected, 1)\n mean_success_rate = float(sum([c.rewards for c in choices])) / max(sum([c.plays for c in choices]), 1)\n mean_failure_rate = 1 - mean_success_rate\n\n return sum([\n term(mean_success_rate * c.plays, c.rewards)\n + term(mean_failure_rate * c.plays, c.plays - c.rewards\n ) for c in choices])","def chi_squared(model, y, y_err):\n\n chi2 = np.sum(((model - y)**2)/(y_err**2))\n return chi2","def chi_squared(actual, predicted):\n perturb = np.vectorize(lambda x: x if x != 0 else config.decision_boundary)\n return np.sum((predicted - actual)**2 / perturb(actual))","def chi_sq_test(v, alpha, k):\n v = np.asarray(v).flatten()\n n = v.shape[0]\n # разделили на k интервалов\n hist, bins = np.histogram(v, k)\n dlt = bins[1] - bins[0]\n\n v_mean = np.sum(hist*bins[1:])/n\n v_mean_sq = np.sum(hist*bins[1:]**2)/n\n v_std = np.sqrt(v_mean_sq - v_mean**2)\n print('mean: {}, std: {}'.format(v_mean, v_std))\n\n v_t = list(map(lambda x: n*norm_dist((x - v_mean)/v_std)*dlt/v_std, bins[1:]))\n v_t = np.array(v_t)\n chi_sq = np.sum(np.divide((hist - v_t)**2, v_t))\n\n q_right = stats.chi.ppf(1 - alpha*0.5, k - 1)\n q_left = stats.chi.ppf(alpha*0.5, k - 1)\n print(chi_sq)\n print(q_left, q_right)\n if q_left < chi_sq < q_right or chi_sq < q_left:\n print('Не можем отвергать H0')\n else:\n print('H0 отвергается')","def test_chao1(self):\n self.assertEqual(chao1(self.TestData), 9.75)\n self.assertEqual(chao1(self.TestData,bias_corrected=False),10.5)\n self.assertEqual(chao1(self.NoSingles), 4)\n self.assertEqual(chao1(self.NoSingles,bias_corrected=False),4)\n self.assertEqual(chao1(self.NoDoubles), 5)\n self.assertEqual(chao1(self.NoDoubles,bias_corrected=False),5)","def chi_squared_of_fit(y_data, fitted_y_data):\n\t# note that in the typical definition of Chi-squared, it is assumed that \n\t# nature is wrong and our formula is theoretically perfect, but here we \n\t# are testing a model against emperical data, so the \"expected\" values \n\t# are the data we measured and the \"observed\" values are the values \n\t# generated by a fitting formula, and therefore we swap these variables \n\t# in the stats.chisquare(...) invocation\n\treturn stats.chisquare(fitted_y_data,y_data)","def chi2_test(val0, val1):\n try:\n chisq = float((val0 - val1)**2) / float(val0 + val1)\n if not chisq:\n return (0, 1)\n pval = 1.0 - chi2.cdf(chisq, 1)\n return (chisq, pval)\n except ZeroDivisionError as errstr:\n return (0, 1)","def chi_square(X, Y, Z, data, **kwargs):\n\n if isinstance(Z, (frozenset, list, set, tuple)):\n Z = list(Z)\n else:\n Z = [Z]\n\n state_names = kwargs[\"state_names\"]\n num_params = (\n (len(state_names[X]) - 1)\n * (len(state_names[Y]) - 1)\n * np.prod([len(state_names[z]) for z in Z])\n )\n sufficient_data = len(data) >= num_params * 5\n\n if not sufficient_data:\n warn(\n \"Insufficient data for testing {0} _|_ {1} | {2}. \".format(X, Y, Z)\n + \"At least {0} samples recommended, {1} present.\".format(\n 5 * num_params, len(data)\n )\n )\n\n # compute actual frequency/state_count table:\n # = P(X,Y,Zs)\n XYZ_state_counts = pd.crosstab(\n index=data[X], columns=[data[Y]] + [data[z] for z in Z]\n )\n # reindex to add missing rows & columns (if some values don't appear in data)\n row_index = state_names[X]\n column_index = pd.MultiIndex.from_product(\n [state_names[Y]] + [state_names[z] for z in Z], names=[Y] + Z\n )\n if not isinstance(XYZ_state_counts.columns, pd.MultiIndex):\n XYZ_state_counts.columns = pd.MultiIndex.from_arrays([XYZ_state_counts.columns])\n XYZ_state_counts = XYZ_state_counts.reindex(\n index=row_index, columns=column_index\n ).fillna(0)\n\n # compute the expected frequency/state_count table if X _|_ Y | Zs:\n # = P(X|Zs)*P(Y|Zs)*P(Zs) = P(X,Zs)*P(Y,Zs)/P(Zs)\n if Z:\n XZ_state_counts = XYZ_state_counts.sum(axis=1, level=Z) # marginalize out Y\n YZ_state_counts = XYZ_state_counts.sum().unstack(Z) # marginalize out X\n else:\n XZ_state_counts = XYZ_state_counts.sum(axis=1)\n YZ_state_counts = XYZ_state_counts.sum()\n Z_state_counts = YZ_state_counts.sum() # marginalize out both\n\n XYZ_expected = pd.DataFrame(\n index=XYZ_state_counts.index, columns=XYZ_state_counts.columns\n )\n for X_val in XYZ_expected.index:\n if Z:\n for Y_val in XYZ_expected.columns.levels[0]:\n XYZ_expected.loc[X_val, Y_val] = (\n XZ_state_counts.loc[X_val]\n * YZ_state_counts.loc[Y_val]\n / Z_state_counts\n ).values\n else:\n for Y_val in XYZ_expected.columns:\n XYZ_expected.loc[X_val, Y_val] = (\n XZ_state_counts.loc[X_val]\n * YZ_state_counts.loc[Y_val]\n / float(Z_state_counts)\n )\n\n observed = XYZ_state_counts.values.flatten()\n expected = XYZ_expected.fillna(0).values.flatten()\n # remove elements where the expected value is 0;\n # this also corrects the degrees of freedom for chisquare\n observed, expected = zip(\n *((o, e) for o, e in zip(observed, expected) if not e == 0)\n )\n\n chi2, significance_level = stats.chisquare(observed, expected)\n\n return chi2, significance_level","def stat_test(self, counts):\n\n vals_list = list(counts.values())\n\n # account for bitstring with zero counts\n numqubits = len(list(counts)[0])\n numzeros = 2 ** numqubits - len(counts)\n vals_list.extend([0] * numzeros)\n\n chisq, pval = chisquare(vals_list)\n passed = bool(pval >= self._pcrit)\n return (chisq, pval, passed)","def chi_expected_values(contingency):\n #Deprecated\n total_responses = contingency.column(contingency.num_columns - 1).item(-1)\n expected_values = []\n for col_index in range(1, contingency.num_columns - 1):\n for row_index in range(0, contingency.num_rows - 1):\n column_total = contingency.column(col_index).item(-1)\n row_total = contingency.row(row_index).item(-1)\n expected_values.append((column_total*row_total)/total_responses)\n return np.array(expected_values)","def chi2(self):\n return np.sum((np.dot(self.mmatrix,self.acoeff) - self.bvec)**2)","def chi_2_test(magnitudes, errors):\n num_obs = magnitudes.shape[0]\n errors_sq = np.square(errors)\n\n m_bar = np.sum(np.divide(magnitudes, errors_sq)) /\\\n np.sum(np.divide(np.ones(num_obs), errors_sq))\n\n chi_2 = np.sum(np.divide(np.square(magnitudes - m_bar), errors_sq))\n return chi_2","def f_test(chi1,df1,chi2,df2,red_chi = True):\n\n# if chi1/df1 > chi2/df2:\n#\tprob = 2. * f.cdf(chi1/df1, chi2/df2, df1, df2)\n# else:\n#\tprob = 2. * f.cdf(chi2/df2, chi1/df1, df2, df1)\n if red_chi:\n\tfval = (chi1/df1) / (chi2/df2)\n else:\n\tfval = chi1 / chi2\n prob = 2. * f.cdf((chi1/df1) / (chi2/df2), df1, df2)\n if prob > 1.: \n\treturn 2. - prob\n else:\n\treturn prob","def calculate_chi_square_p_value(A):\n nonzero_columns = np.where(A.any(axis=0))[0]\n A_nonzero_columns = A[:, nonzero_columns]\n _, p_value, _, _ = scipy.stats.chi2_contingency(A_nonzero_columns)\n return p_value","def chi2sf(x, k):","def chisquare(obs, exp=None):\n obs = N.array(obs)\n\n # get total number of observations\n nobs = N.sum(obs)\n\n # if no expected value are supplied assume equal distribution\n if exp == None:\n exp = N.ones(obs.shape) * nobs / N.prod(obs.shape)\n\n # make sure to have floating point data\n exp = exp.astype(float)\n\n # compute chisquare value\n chisq = N.sum((obs - exp )**2 / exp)\n\n # return chisq and probability (upper tail)\n return chisq, stats.chisqprob(chisq, N.prod(obs.shape) - 1)","def _compute_chi_squared(confmat: Tensor, bias_correction: bool) ->Tensor:\n expected_freqs = _compute_expected_freqs(confmat)\n df = expected_freqs.numel() - sum(expected_freqs.shape) + expected_freqs.ndim - 1\n if df == 0:\n return torch.tensor(0.0, device=confmat.device)\n if df == 1 and bias_correction:\n diff = expected_freqs - confmat\n direction = diff.sign()\n confmat += direction * torch.minimum(0.5 * torch.ones_like(direction), direction.abs())\n return torch.sum((confmat - expected_freqs) ** 2 / expected_freqs)","def chisq(self, expected=None):\n if expected is None:\n expected = self.indep()\n if self.y == expected.y and self.x == expected.x:\n tot = 0.0\n for y,x in self.coords(False):\n tot += float(self.retrieve(y,x)-expected.retrieve(y,x))**2.0/float(expected.retrieve(y,x))\n return tot\n else:\n raise IndexError(\"Matrix Chi Squared invalid for dimensions \"+str(self.y)+\"x\"+str(self.x)+\" and \"+str(other.y)+\"x\"+str(other.x))","def calculate_chi2(target_data, source_data, q_min, q_max):\n\n matched_source_I = match_scatter_curves(target_data, source_data)\n\n # Get average I for experimental and calculated values over matched q\n # range\n matched_no = len(matched_source_I)\n expt_avg = np.mean(target_data[0:matched_no, 1])\n calc_avg = np.mean(matched_source_I)\n\n # Initial guess of the concentration:\n # ratio of experimental and calculated average intensities\n con = expt_avg / calc_avg\n\n if np.count_nonzero(target_data[:, 1]) == 0:\n print(\"Chi^2 calculations cannot proceed without target data\")\n sys.exit()\n else:\n \n if (target_data.shape[1] > 2) and (\n np.count_nonzero(target_data[:, 2]) != 0):\n \n # Call fortran code to calculate the reduced Chi2\n chi2 = sjp_util.calc_chi2(\n target_data[\n :, 0], target_data[\n :, 1], target_data[\n :, 2], matched_source_I, matched_no, q_min, q_max, con, False)\n \n else:\n #print \"For Chi^2 calculations an error column must be present\"\n #sys.exit()\n # Call fortran code to calculate the Pearson Chi2\n chi2 = sjp_util.calc_pearson(target_data[:,0],\n target_data[:,1],\n matched_source_I,\n matched_no,\n q_min,\n q_max,\n con,\n False)\n \n # 1/con is the scaling factor needed to multiply experimental I values\n # to compare with calculated data\n return chi2, 1.0 / con","def test_action_of_choi_operator():\n krauss = initialize_pauli_examples(0.1, 0.2, 0.3)\n choi = sum([np.outer(np.ravel(x, \"F\"),\n np.conj(np.ravel(x, \"F\").T)) for x in krauss])\n choi_obj = ChoiQutip(choi, numb_qubits=[1, 1], dim_in=2, dim_out=2)\n\n for _ in range(0, 1000):\n rho = np.array(rand_dm_ginibre(2).data.todense())\n actual = choi_obj.channel(rho)\n desired = sum([k.dot(rho).dot(np.conj(k).T) for k in krauss])\n assert np.all(np.abs(actual - desired) < 1e-3)\n\n # Test number of qubits being 2.\n krauss = np.kron(krauss, krauss)\n choi = sum([np.outer(np.ravel(x, \"F\"),\n np.conj(np.ravel(x, \"F\"))) for x in krauss])\n choi_obj = ChoiQutip(choi, numb_qubits=[2, 2], dim_in=2, dim_out=2)\n\n for _ in range(0, 1000):\n rho = np.array(rand_dm_ginibre(4).data.todense())\n actual = choi_obj.channel(rho)\n desired = sum([k.dot(rho).dot(np.conj(k).T) for k in krauss])\n assert np.all(np.abs(actual - desired) < 1e-3)\n\n # Test Dephrasure Channe\n krauss = set_up_dephrasure_conditions(0.1, 0.2)\n choi = sum([np.outer(np.ravel(x, \"F\"),\n np.conj(np.ravel(x, \"F\"))) for x in krauss])\n choi_obj = ChoiQutip(choi, [1, 1], 2, 3)\n\n for _ in range(0, 1000):\n rho = np.array(rand_dm_ginibre(2).data.todense())\n actual = choi_obj.channel(rho)\n desired = sum([k.dot(rho).dot(np.conj(k).T) for k in krauss])\n assert np.all(np.abs(actual - desired) < 1e-3)","def _update_chi2(self):\n n_cols = len(self._profile)\n # Fill matrix with nan initially\n chi2_mat = np.full((n_cols, n_cols), np.nan)\n # Compute chi_sq for each\n for i in range(n_cols):\n data_stats_compiler1 = self._profile[i].profiles[\"data_stats_profile\"]\n profiler1 = data_stats_compiler1._profiles[\"category\"]\n if not profiler1.is_match:\n continue\n for j in range(i, n_cols):\n if i == j:\n chi2_mat[i][j] = 1\n continue\n data_stats_compiler2 = self._profile[j].profiles[\"data_stats_profile\"]\n profiler2 = data_stats_compiler2._profiles[\"category\"]\n if not profiler2.is_match:\n continue\n\n results = utils.perform_chi_squared_test_for_homogeneity(\n profiler1.categorical_counts,\n profiler1.sample_size,\n profiler2.categorical_counts,\n profiler2.sample_size\n )\n chi2_mat[i][j] = results[\"p-value\"]\n chi2_mat[j][i] = results[\"p-value\"]\n\n return chi2_mat","def assoc(X, Y, Zs):\n return 1 - chi_square(X, Y, Zs, self.data, boolean=False)[1]","def test(self):\n return self._test(result_count=1, failure_amount=1)","def test(self):\n return self._test(result_count=1, failure_amount=1)","def chi_squared(normalization, model, data, data_err):\n model = np.array(model) * normalization\n\n # degrees of freedom = # observations - # params\n dof = len(data) - 1.\n\n # for detections, get usual negative log-likelihood\n detections = 0.5 * (data - model)**2 / data_err**2\n\n # for nondetections, use survival analysis likelihood, e.g., \n # Feigelson & Nelson (1985)\n #nondetections = 0.5 * (1 + erf(model / (np.sqrt(2) * data_err)))\n\n # UPDATE: we'll instead use a normal distribution centered on \n # zero since it gives the intuitively correct answer when fitting. \n nondetections = 0.5 * (0 - model)**2 / data_err**2\n\n # For a better treatment, we may want to use the survival function\n # for a non-normal distribution... i.e., if we know the \n # completeness as a function of flux, we may be able to create a \n # log-likelihood of some non-detection for any model prediction.\n\n return np.sum(np.where(np.isfinite(data), detections, nondetections)) / dof","def stat_test(self, counts):\n q0len = len(self._qubit0)\n q1len = len(self._qubit1)\n cont_table = np.ones((2 ** q0len, 2 ** q1len))\n\n for (key, value) in counts.items():\n key_rev = key[::-1]\n q0index = int(key_rev[:q0len], 2)\n q1index = int(key_rev[q0len:], 2)\n cont_table[q0index][q1index] = value\n\n chisq, pval, _, _ = chi2_contingency(cont_table)\n passed = bool(pval >= self._pcrit)\n return (chisq, pval, passed)","def tests_truth():\n circ_m = ccxtest(4)\n print(circ_m)\n circ_m = crootnxtest(4)\n print(circ_m)\n circ_m = oracletest(4)\n print(circ_m)\n circ_m = ccx_otest(4)\n print(circ_m)","def testcheatTrue(self):\n import Cheat\n res = Cheat.cheatclass.cheatT(self)\n exp = Cheat.cheatclass.cheatingR(self)\n\n self.assertTrue(res, exp)","def chi_test_goodness_of_fit(dimension1, dimension2):\n total_len = (dimension1 + dimension2) / 2\n\n X = (dimension1 - total_len) ** 2 / total_len + (dimension2 - total_len) ** 2 / total_len\n return 1 - chi2.cdf(X, df=1)","def chi2s(h1s, h2s):\n return np.sum((h1s-h2s)**2/(h1s+h2s+1e-10), axis=1)","def chi(self, theta):\n yf = self.predict(self.t, theta)\n sse = np.sum(np.square((yf - self.y) / self.dy))\n return sse","def chi2(actual_values, expected_values):\n if actual_values.shape != expected_values.shape:\n raise ValueError(\n 'Shape mismatch: actual_values.shape = %s,'\n ' expected_values.shape = %s'\n % (actual_values.shape, expected_values.shape)\n )\n\n # Convert to simple numpy arrays containing floats\n if not isbarenumeric(actual_values):\n actual_values = unp.nominal_values(actual_values)\n if not isbarenumeric(expected_values):\n expected_values = unp.nominal_values(expected_values)\n\n with np.errstate(invalid='ignore'):\n # Mask off any nan expected values (these are assumed to be ok)\n actual_values = np.ma.masked_invalid(actual_values)\n expected_values = np.ma.masked_invalid(expected_values)\n\n # TODO: this check (and the same for `actual_values`) should probably\n # be done elsewhere... maybe?\n if np.any(actual_values < 0):\n msg = ('`actual_values` must all be >= 0...\\n'\n + maperror_logmsg(actual_values))\n raise ValueError(msg)\n\n if np.any(expected_values < 0):\n msg = ('`expected_values` must all be >= 0...\\n'\n + maperror_logmsg(expected_values))\n raise ValueError(msg)\n\n # TODO: Is this okay to do? Mathematically suspect at best, and can\n # still destroy a minimizer's hopes and dreams...\n\n # Replace 0's with small positive numbers to avoid inf in division\n np.clip(expected_values, a_min=SMALL_POS, a_max=np.inf,\n out=expected_values)\n\n\n delta = actual_values - expected_values\n\n if np.all(np.abs(delta) < 5*FTYPE_PREC):\n return np.zeros_like(delta, dtype=FTYPE)\n\n chi2_val = np.square(delta) / expected_values\n assert np.all(chi2_val >= 0), str(chi2_val[chi2_val < 0])\n return chi2_val","def test_hermitian(self, nqubits):\n # better might be (arXiv:1405.6741)\n dim = 2**nqubits\n umat = scipy.stats.unitary_group.rvs(dim, random_state=750)\n dmat = np.diag(np.exp(1j * np.random.normal(size=dim)))\n mat = umat.T.conjugate() @ dmat @ umat\n circ = self.qsd(mat, opt_a1=True, opt_a2=False)\n ccirc = transpile(circ, basis_gates=[\"u\", \"cx\"], optimization_level=0)\n self.assertTrue(np.allclose(mat, Operator(ccirc).data))\n if nqubits > 1:\n expected_cx = self._qsd_l2_cx_count(nqubits) - self._qsd_l2_a1_mod(nqubits)\n self.assertLessEqual(ccirc.count_ops().get(\"cx\"), expected_cx)","def chi2_adequacy_test (Y, Z, S, D):\n\tnum_models = Z.shape[0]\n\n\tD = np.asarray(D)\n\tassert_is_shape(D, (num_models,))\n\n\t# Squared Mahalanobis distance\n\tmahaf1 = lambda d, is2: np.sum( d * np.matmul(is2, d) )\n\t# Mahalanobis distances for all test points\n\tmahaf2 = lambda Y, Z, iS: [ mahaf1(y-z, is2) for y,z,is2 in zip(Y,Z,iS) ]\n\n\tiS = np.linalg.inv(S)\n\tmaha = [ np.sum(mahaf2(Y,z,is2)) for z,is2 in zip(Z, iS)]\n\tmaha = np.array( maha )\n\n\t# Degrees of freedom\n\tdof = Y.shape[0]*Y.shape[1] - np.asarray(D)\n\n\tif np.any(dof <= 0):\n\t\traise RuntimeWarning('Degrees of freedom not greater than zero.')\n\treturn 1. - chi2.cdf(maha, dof)","def chi2_test(df, sample1, sample2, correction=True, alpha=0.05,\n show_graph=True, **kwargs):\n hypothesis = {\n 'two-sided_H0': \"the samples are independent\",\n 'two-sided_H1': \"the samples are dependent\"\n }\n expected, observed, stats = pg.chi2_independence(df, sample1, sample2,\n correction)\n p_value = stats.loc[stats['test'] == 'pearson']['pval'][0]\n statistic = stats.loc[stats['test'] == 'pearson']['chi2'][0]\n df_result = (\n pd.DataFrame(\n data={'statistic': [statistic],\n 'p-val': [p_value]})\n .rename({0: 'chi2'})\n )\n df_result['Expected Distribution'] = str(expected.values.tolist())\n df_result['Observed Distribution'] = str(observed.values.tolist())\n if show_graph:\n pd.crosstab(df[sample1], df[sample2], normalize='index').plot(\n kind='bar',\n color=['r', 'b'],\n **kwargs\n )\n return HypothesisTester.test_alternative(df_result, hypothesis,\n alpha=alpha).T","def _p_value(self):\n p_value = chi2.sf(self.test_statistic, 2)\n\n return p_value","def afriedmanchisquare(*args):\r\n k = len(args)\r\n if k < 3:\r\n raise ValueError, '\\nLess than 3 levels. Friedman test not appropriate.\\n'\r\n n = len(args[0])\r\n data = apply(pstats.aabut,args)\r\n data = data.astype(N.float_)\r\n for i in range(len(data)):\r\n data[i] = arankdata(data[i])\r\n ssbn = asum(asum(args,1)**2)\r\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\r\n return chisq, achisqprob(chisq,k-1)","def chi2(self, pars = [], returnParameters = False):\n\t\tif not self.chi2init:\n\t\t\traise RuntimeError(\"chi2 not inited, cannot evaluate\")\n\t\t\tprint pars\n\t\tif len(pars) is not 0:\n\t\t\tself.setShapeParameters(pars)\n\t\tA,B,C = self.getOwnTheoryABC()\n\n#\t\tprint B\n#\t\tprint A\n\n\t\tif self.ownPinv:\n\t\t\tzmPars = -np.dot(B, utils.pinv(A + np.transpose(A), numLim = self.numLim))\n\t\telse:\n\t\t\tzmPars = -np.dot(B, la.pinv(A + np.transpose(A)))\n\n\n\t\tchi2 = np.dot(zmPars,np.dot(A,zmPars)) + np.dot(zmPars,B) + C\n\n\t\tif returnParameters:\n\t\t\treturn chi2, zmPars\n\t\telse:\n\t\t\treturn chi2","def make_chi_sq(data, errors, fit_range):\n\n def chi_sq(m, c):\n ff = pp_flat(fit_range, m, c)\n return sum((data - ff)**2 / errors**2) / len(fit_range)\n # return sum([(data[t] - pp_flat(t, m, c))**2 / (errors[t])**2\n # for t in fit_range]) / len(fit_range)\n\n return chi_sq","def lfriedmanchisquare(*args):\r\n k = len(args)\r\n if k < 3:\r\n raise ValueError, 'Less than 3 levels. Friedman test not appropriate.'\r\n n = len(args[0])\r\n data = apply(pstats.abut,tuple(args))\r\n for i in range(len(data)):\r\n data[i] = rankdata(data[i])\r\n ssbn = 0\r\n for i in range(k):\r\n ssbn = ssbn + sum(args[i])**2\r\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\r\n return chisq, chisqprob(chisq,k-1)","def chi2(u,v):\n\n u[u==0] = 1e-6\n v[v==0] = 1e-6\n r = np.sum(((u-v)**2).astype(np.float)/(u+v))\n\n # m = (u != 0) & (v != 0)\n # r = np.sum(((u[m]-v[m])**2).astype(np.float)/(u[m]+v[m]))\n\n # r = np.nansum(((u-v)**2).astype(np.float)/(u+v))\n return r","def test_cci(self):\n q = qufilab.cci(self.close, self.high, self.low, 200)\n t = talib.CCI(self.high, self.low, self.close, 200)\n np.testing.assert_allclose(q, t, rtol = self.tolerance)","def wrap_chi_sq(gcalc, gobs):\n rw, scale = get_chi_sq(gobs, gcalc)\n return rw, scale","def c_test_fitness_function(self, function):\r\n return 1","def c_test_fitness_function(self, function):\r\n return 1","def test_hessian():\n x, y = fwd.Variable(), fwd.Variable()\n rosen = 100.0*(y - x**2)**2 + (1 - x)**2.0\n rosen_hessian = lambda x, y: \\\n np.array([[1200*x**2-400*x+2, -400*x],\n [-400*x, 200]])\n rosen_hessian_returned = rosen.hessian_at({x: 1.0, y: 1.0})\n rosen_hessian_expected = rosen_hessian(1.0, 1.0)\n for i in range(2):\n for j in range(2):\n assert equals(rosen_hessian_returned[i, j],\n rosen_hessian_expected[i, j])","def get_chi2(a, b):\n off = (a - b)**2\n return np.sqrt(np.sum(off)) / b.sum()","def test_result(self):\n result = compute()\n self.assertEqual(result, '4782')\n print(\"eulpy25Test passed\")","def test_score():\n print(\"Tests for 'score' function\")\n test_suite = TestSuite()\n\n # Testing with empty hand\n result = score([])\n test_suite.run_test(result, 0, '0')\n # Testing with non-empty hand\n result = score([1, 3])\n test_suite.run_test(result, 3, '1')\n # Testing with non-empty hand\n result = score([1, 3, 1, 1])\n test_suite.run_test(result, 3, '2')\n # Testing with non-empty hand\n result = score([4, 3, 4, 3, 3])\n test_suite.run_test(result, 9, '3')\n\n # Show report\n test_suite.report_results()","def test_single_hessian(self):\n self.options.hes_method = [\"analytic\"]\n self.controller.minimizer = \"general\"\n _ = loop_over_hessians(self.controller,\n options=self.options,\n grabbed_output=self.grabbed_output,\n checkpointer=self.cp)\n self.assertEqual(self.controller.count, 1)","def test_dichotomous_scores(dichotomous_Contingency, method, expected):\n xs_score = getattr(dichotomous_Contingency, method)().item()\n npt.assert_almost_equal(xs_score, expected)","def test_suite():\n test(sum_of_squares([2, 3, 4]) == 29)\n test(sum_of_squares([ ]) == 0)\n test(sum_of_squares([2, -3, 4]) == 29)","def testSpeciesRichness(self):\n self.assertEqual(66, self.coal.get_species_richness(1))\n self.assertEqual(56, self.coal.get_species_richness(2))\n self.assertEqual(125, self.coal.get_species_richness(3))\n self.assertEqual(168, self.coal.get_species_richness(4))\n self.assertEqual(102, self.coal.get_species_richness(5))\n self.assertEqual(80, self.coal.get_species_richness(6))\n self.assertEqual(169, self.coal.get_species_richness(7))\n self.assertEqual(244, self.coal.get_species_richness(8))\n self.assertEqual(126, self.coal.get_species_richness(9))\n self.assertEqual(100, self.coal.get_species_richness(10))\n self.assertEqual(196, self.coal.get_species_richness(11))\n self.assertEqual(299, self.coal.get_species_richness(12))\n self.assertEqual(145, self.coal.get_species_richness(13))\n self.assertEqual(118, self.coal.get_species_richness(14))\n self.assertEqual(218, self.coal.get_species_richness(15))\n self.assertEqual(345, self.coal.get_species_richness(16))","def test_quick_answer(self):\n pass","def test_entropy_complementary_channel_of_choi_operator():\n # Dephrasure\n krauss = set_up_dephrasure_conditions(0.1, 0.2)\n choi = sum([np.outer(np.ravel(x, \"F\"),\n np.conj(np.ravel(x, \"F\"))) for x in krauss])\n choi_obj = ChoiQutip(choi, [1, 1], 2, 3)\n\n for _ in range(0, 1000):\n # Random rho\n rho = rand_dm_ginibre(2).data.todense()\n # Get eigenvalues\n desired = np.linalg.eigvalsh(entropyexchange(krauss, rho))\n actual = np.linalg.eigvalsh(choi_obj.complementary_channel(rho))\n\n # Assert that eigenvalues are the same.\n i = 0\n for x in actual:\n if np.abs(x) > 1e-8:\n assert np.abs(desired[i] - x) < 1e-5\n i += 1","def test_cosine_mixture(self):\n fun = get_problem('cosine_mixture', dimension=2, lower=-1, upper=1)\n self.assertAlmostEqual(fun(np.zeros(2)), -0.2)","def compute(real_data, synthetic_data):\n f_obs, f_exp = get_frequencies(real_data, synthetic_data)\n if len(f_obs) == len(f_exp) == 1:\n pvalue = 1.0\n else:\n _, pvalue = chisquare(f_obs, f_exp)\n\n return pvalue","def test_quintic(self):\n fun = get_problem('quintic', self.dimension, -10.0, 10.0)\n self.assertEqual(fun(self.array6), 0.0)","def test_handcrafted_examples(self):\n for i in range(1000):\n self.assertEqual(perfectd(0), True)\n self.assertEqual(prime(0), False)\n self.assertEqual(prime(2), True)\n self.assertEqual(prime(7), True)\n self.assertEqual(prime(15), False)\n self.assertEqual(perfectd(6), True)\n self.assertEqual(perfectd(15), False)","def cmh_test(*args):\n import pandas, math\n from statsmodels.stats.contingency_tables import StratifiedTable as cmh\n\n # set up data logging\n ignored = {}\n\n # get contingency tables for pops with case and control data\n tables = create_tables(*args)\n\n # fill in a dataframe with cmh test results, one locus at a time\n results = pandas.DataFrame(columns=['locus', 'odds_ratio', 'p-value',\n 'lower_confidence', 'upper_confidence', 'num_pops'])\n for locus,table in tables.items():\n if len(table) == 0:\n # if none of the populations for a locus provide a contingency table (due to missing data)\n # ... then continue to the next locus.\n ignored[locus] = 'there were no populations that provided contingency tables'\n continue\n # cmh results for stratified contingency tables (called \"table\" = an array of tables)\n cmh_res = cmh(table)\n res = cmh_res.test_null_odds(True) # statistic and p-value\n odds_ratio = cmh_res.oddsratio_pooled # odds ratio\n conf = cmh_res.oddsratio_pooled_confint() # lower and upper confidence\n locus_results = locus, odds_ratio, res.pvalue, *conf, len(table)\n\n # look for fixed states across all tables\n\n if sum([math.isnan(x) for x in conf]) > 0:\n # if the upper and lower estimat of the confidence interval are NA, ignore\n # this can happen when all of the tables returned for a specific locus are fixed\n # ... for either the REF or ALT. This happens rarely for loci with low MAF, where\n # ... the populations that have variable case or control, do not have a frequency\n # ... estimated for the other treatment (case or control) and therefore don't\n # ... make it into the list of stratified tables and the remaining tables\n # ... (populations) are all fixed for the REF or ALT - again, this happens for\n # ... some low MAF loci and may happen if input file has few pops to stratify.\n\n # log reason\n ignored[locus] = 'the upper and lower confidence interval for the odds ratio was NA'\n ignored[locus] = ignored[locus] + '\\t' + '\\t'.join(map(str, locus_results[1:]))\n\n continue\n\n results.loc[len(results.index), :] = locus_results\n\n return results, ignored","def chi(self, theta, star_params=None):\n if star_params is None:\n star_params = []\n theta = np.append(star_params, theta)\n error = self.y - self.solve(theta)\n return np.sum(np.square(error / self.dy))","def test_print_result(capsys):\n assert \"\"\"Total 5 hands solved\nTotal 4 hands solved with hint\nTotal 4 hands failed to solve\"\"\" in hl.test_help_print_result(capsys)","def test_integration(self, ix, iy, iz, zx, zy, zz):\n sigma = 20\n toff = np.sqrt(2 * np.pi) * sigma * 1e-9\n\n backend = CrossResonanceHamiltonianBackend(toff, ix, iy, iz, zx, zy, zz)\n durations = np.linspace(0, 700, 50)\n expr = cr_hamiltonian.CrossResonanceHamiltonian(\n qubits=(0, 1), flat_top_widths=durations, sigma=sigma, risefall=2\n )\n exp_data = expr.run(backend, shots=1000)\n exp_data.block_for_results()\n\n self.assertAlmostEqual(exp_data.analysis_results(\"omega_ix\").value.value, ix, delta=1e3)\n self.assertAlmostEqual(exp_data.analysis_results(\"omega_iy\").value.value, iy, delta=1e3)\n self.assertAlmostEqual(exp_data.analysis_results(\"omega_iz\").value.value, iz, delta=1e3)\n self.assertAlmostEqual(exp_data.analysis_results(\"omega_zx\").value.value, zx, delta=1e3)\n self.assertAlmostEqual(exp_data.analysis_results(\"omega_zy\").value.value, zy, delta=1e3)\n self.assertAlmostEqual(exp_data.analysis_results(\"omega_zz\").value.value, zz, delta=1e3)","def test_stat(df,ivar,tvar,equal_var=True,ddof=0):\n ivar_uniques = df[ivar].unique().shape[0]\n tvar_uniques = df[tvar].unique().shape[0]\n if tvar_uniques < 2:\n print \"Only one sample can be generated\"\n return None\n if ivar_uniques <= 10: #This the case of a categorical independant variable. We use chisquare\n ss = pd.crosstab(df[ivar],df[tvar])\n ss = (ss.T/ss.sum(axis=1)).T\n s0,s1 = ss[0].values,ss[1].values\n\n return chisquare(s1,s0,ddof=ddof)\n\n if ivar_uniques >10: #Consider using ttest\n s0 = df[ivar][df[tvar] == 0]\n s1 = df[ivar][df[tvar] == 1]\n return ttest_ind(s1,s0,equal_var=equal_var)","def fit_chi(fit,data,errs,dof):\n\tif len(fit)!=len(data) or len(data)!=len(errs):\n\t\traise ValueError('Input vectors have unequal lengths.')\n\tsquared_err = np.power(np.subtract(fit,data),2)\n\treturn np.sum(np.divide(squared_err,np.power(errs,2)))/dof","def test_secant(testFunctions, tol, printFlag): \n pass","def test_secant_system(testFunctions, tol, printFlag): \n pass","def _calculate_chi_squared (desc_rolls_tuples) :\n \n results = { }\n \n for desc_str, obs_roll_array in desc_rolls_tuples :\n \n # we aren't providing expected values because we expect the sides\n # of the die to be rolled with equal frequency,\n # and that's the default for the scipy version of chi squared;\n # scipy's chi squared method also calculates the degrees of\n # freedom based on the length of our array, which works in this case\n chi_sq_stat, p_value = chisquare(numpy.array(obs_roll_array))\n results[desc_str] = (chi_sq_stat, p_value)\n \n return results","def _test_evaluate(self, format_only, outfile_predix=None):\n metric = MOTChallengeMetric(\n metric=['HOTA', 'CLEAR', 'Identity'],\n format_only=format_only,\n outfile_prefix=outfile_predix)\n metric.dataset_meta = {'classes': ('pedestrian', )}\n data_batch = dict(input=None, data_samples=None)\n predictions = self._get_predictions_demo()\n metric.process(data_batch, predictions)\n eval_results = metric.evaluate()\n return eval_results","def test(self, session, num_tests):\n score_list = np.zeros(num_tests)\n for n in range(num_tests):\n game = tetris.Game(self.rows, self.columns, self.tetriminos, self.end_at)\n while not game.game_over:\n # Pass state to network - perform best action and add reward to log\n state = [game.state()]\n q_values = session.run(self.net.q_out, feed_dict={self.net.inputs: state})\n mask = validity_mask(game.next_tetrimino, self.columns)\n q_masked = np.where(mask, q_values, -1000)\n action = np.argmax(q_masked, 1)[0]\n rotation, column = action_to_rc(action, self.columns)\n score_list[n] += game.place_tetrimino(rotation, column)\n return np.mean(score_list), np.std(score_list)","def test_fun_result(self):\n x = CArray([3, 5])\n correct_result = x[0] ** 2 + x[1] ** 2\n self._test_fun_result(self.fun, x, correct_result.item())","def test_menhinick(self):\n self.assertEqual(menhinick(self.TestData), 9/sqrt(22))","def main():\r\n _evaluative_test(5)\r\n _fuzz_test(1)\r\n _fuzz_test(1, 512)\r\n _fuzz_test(1, 1512)\r\n _fuzz_test(1000)\r\n _fuzz_test(1000, 512)\r\n _fuzz_test(1000, 4077)","def test_multifit_num_results(self, perform_fit):\n cost_func = make_cost_function('multifit_set/multifit.txt')\n problem = cost_func.problem\n cost_func.jacobian = Scipy(problem)\n cost_func.jacobian.method = '2-point'\n controller = DummyController(cost_func=cost_func)\n options = problem.options\n options.table_type = ['acc', 'runtime', 'compare', 'local_min']\n grabbed_output = output_grabber.OutputGrabber(options)\n controller.final_params = [[0.1, 0.1], [0.1, 0.1]]\n controller.parameter_set = 0\n perform_fit.return_value = ([0.1, 0.2],\n [0.1, 0.01],\n [10e-3, 10e-4])\n results = loop_over_hessians(controller=controller,\n options=options,\n grabbed_output=grabbed_output,\n checkpointer=self.cp)\n self.assertTrue(len(results) == 2)","def test(self, c):\n\tc.sort()\n\n # If we had this test before, return its result\n if self.cache_outcomes:\n cached_result = self.outcome_cache.lookup(c)\n if cached_result is not None:\n return cached_result\n\n if self.monotony:\n # Check whether we had a passing superset of this test before\n cached_result = self.outcome_cache.lookup_superset(c)\n if cached_result == self.PASS:\n return self.PASS\n \n cached_result = self.outcome_cache.lookup_subset(c)\n if cached_result == self.FAIL:\n return self.FAIL\n\n\tif self.debug_test:\n print\n\t print \"test(\" + self.coerce(c) + \")...\"\n\n\toutcome = self._test(c)\n\n #Statistics about actually executed tests\n self.n_tests +=1\n if outcome == self.FAIL:\n self.n_fails +=1\n elif outcome == self.PASS:\n self.n_passes +=1\n elif outcome == self.UNRESOLVED:\n self.n_unres +=1\n\n\tif self.debug_test:\n\t print \"test(\" + self.coerce(c) + \") = \" + `outcome`\n\n if self.cache_outcomes:\n self.outcome_cache.add(c, outcome)\n\n\treturn outcome","def chi(nuc, temp=300.0, group_struct=None, phi_g=None, xs_cache=None, eres=101):\n xs_cache = cache.xs_cache if xs_cache is None else xs_cache\n _prep_cache(xs_cache, group_struct, phi_g)\n if isinstance(nuc, collectionsAbc.Iterable) and not isinstance(nuc, basestring):\n return _atom_mass_channel(chi, nuc, temp=temp, xs_cache=xs_cache, eres=eres)\n nuc = nucname.id(nuc)\n key = (nuc, \"chi\", temp)\n\n # Don't recalculate anything if you don't have to\n if key in xs_cache:\n return xs_cache[key]\n\n # Get the the set of nuclides we know we need chi for.\n if \"fissionable_nucs\" not in xs_cache:\n with tb.open_file(nuc_data, \"r\") as f:\n if \"/neutron/cinder_xs/fission\" in f:\n fn = set(f.root.neutron.cinder_xs.fission.cols.nuc)\n else:\n fn = set()\n xs_cache[\"fissionable_nucs\"] = fn\n fissionable_nucs = xs_cache[\"fissionable_nucs\"]\n if (nuc not in fissionable_nucs) and (86 <= nucname.znum(nuc)):\n fissionable_nucs.add(nuc)\n\n # Perform the group collapse on a continuous chi\n E_g = xs_cache[\"E_g\"]\n G = len(E_g) - 1\n chi_g = np.zeros(G, dtype=\"f8\")\n if nuc in fissionable_nucs:\n for g in range(G):\n E_space = np.logspace(np.log10(E_g[g]), np.log10(E_g[g + 1]), eres)\n dnumer = models.chi(E_space)\n numer = scipy.integrate.trapz(dnumer, E_space)\n denom = E_g[g + 1] - E_g[g]\n chi_g[g] = numer / denom\n # renormalize chi\n chi_g = chi_g / chi_g.sum()\n # Put this value back into the cache, with the appropriate label\n xs_cache[key] = chi_g\n return chi_g","def __getChiSq(self, wMP):\n\t\t\n\t\t# Calculate reconstructed spectrum\n\t\trecSp = np.dot(self.specTemplates, wMP)\n\t\t\n\t\t# Determine residual and transpose\n\t\tres = (recSp-self.flux).reshape(self.nBins,1)\n\t\tresT = np.transpose(res)\n\t\t\n\t\t# Determine chi-squared value.\n\t\tchiSq = 0.5*np.dot((resT * self.covInv), res)[0][0]\n\t\t\t\t\n\t\treturn chiSq","def test_square(self, board, row, col, test):\n if row < 0 or row > 7:\n return False\n if col < 0 or col > 7:\n return False\n \n return test(board[row][col])","def testGetsPresentRichness(self):\n self.assertEqual(37, self.coal.get_species_richness(1))\n self.assertEqual(53, self.coal.get_species_richness(3))"],"string":"[\n \"def test_chi_2(self):\\n NN = 4\\n w = 0.01\\n kz = 1.0e-7\\n kp = 3.0e-7\\n wp = 2.0e3\\n tz = 2.0e-18\\n tp = 1.0e-18\\n vthz = 1e5\\n vthp = 1e5\\n omega = 0.1\\n vz = 100.\\n\\n chi = f_chi(NN, w, kz, kp, wp, tz, tp, vthz, vthp,\\n omega, vz, method = 'numpy')/w**2\\n expected_chi = np.array([\\n [4.972725326e8, 3.812283500e9j, -3.086420946e8],\\n [-3.812283500e9j, -3.037753676e9 + 1.098455531e9j, -3.661518437e9-3.465700712e8j],\\n [-3.086420946e8, 3.661518437e9+3.465700712e8j, -1.976136342e9 + 2.497184730e10j]])\\n npt.assert_allclose(chi, expected_chi, rtol = 1e-7)\",\n \"def chisq_test(observed):\\n\\tn, k = observed.shape\\n\\trow = observed.sum(axis=0).reshape(1,-1)\\n\\tcol = observed.sum(axis=1).reshape(-1,1)\\n\\texpected = np.dot(col, row)/observed.sum()\\n\\t#chi2, pvalue = scipy.stats.mstats.chisquare(observed.ravel(), expected.ravel(), ddof = n+k-2)\\n\\tchi2 = (((observed-expected)**2)/expected).sum()\\n\\tpvalue = 1-scipy.stats.chi2.cdf(chi2, (n-1)*(k-1))\\n\\tmessage = \\\"\\\"\\\"\\n\\tPerforming the test of independence in\\ta contingency table.\\n\\ttest statistic: %(chi2)s\\n\\tdegrees of freedom: %(df)s\\n\\tp-value: %(pvalue)s\\n\\t\\\"\\\"\\\" % {'chi2': chi2, 'df': (n-1)*(k-1), 'pvalue': pvalue}\\n\\tprint(message)\\n\\twarning = \\\"\\\"\\\"\\n\\tWarning message:\\n\\tChi-squared approximation may be incorrect\\n\\t\\\"\\\"\\\"\\n\\tif expected.min() < 5:\\n\\t\\tprint(warning)\\n\\treturn chi2, pvalue\",\n \"def test_chi_1(self):\\n NN = 0\\n w = 0.01\\n kz = 1.0e-7\\n kp = 1.0e-7\\n wp = 2.0e3\\n tz = 1.0e-18\\n tp = 1.0e-18\\n vthz = 1e5\\n vthp = 1e5\\n omega = 0.1\\n vz = 100.\\n\\n chi = f_chi(NN, w, kz, kp, wp, tz, tp, vthz, vthp,\\n omega, vz, method = 'numpy')/w**2\\n expected_chi = np.array([\\n [0,0,0],\\n [0, -4.268813377e8+2.591303241e8j, -2.591303241e9-3.026588661e8j],\\n [0, 2.591303241e9+3.026588661e8j, -5.988348146e9+5.195595431e10j]])\\n npt.assert_allclose(chi, expected_chi, rtol = 1e-7)\",\n \"def chi_sq ( ) :\\n \\n # get the list of all files\\n die_file_paths = _sort_all_apropriate_files(options.input)\\n temp_tuples = [ ]\\n \\n # open the files and arrange the info into tuples\\n for die_file_path in die_file_paths :\\n \\n #print\\n #print (\\\"loading die information from file: \\\" + die_file_path)\\n die_description, die_roll_dict = _read_die_file (die_file_path)\\n temp_tuples.append((die_description, die_roll_dict.values()))\\n \\n # analyze the info from each file with a chi squared test\\n chi_sq_results = _calculate_chi_squared(temp_tuples)\\n \\n # display the results\\n print (\\\"-----\\\")\\n for desc_text in sorted(chi_sq_results.keys()) :\\n \\n (chi_sq_stat, p_value) = chi_sq_results[desc_text]\\n print (\\\"analysis of die: \\\" + desc_text.strip())\\n print (\\\"chi squared stat: \\\" + str(chi_sq_stat))\\n print (\\\"p value: \\\" + str(p_value))\\n print (\\\"-----\\\")\",\n \"def chi(self):\\n return self._chi\",\n \"def chi_square_analysis(obs_list):\\r\\n obs = np.array(obs_list)\\r\\n chi2, p, dof, expected = chi2_contingency(obs)\\r\\n return chi2, p, dof, expected\",\n \"def calculate_chi_squared(self):\\n chi = 0\\n obsVals, expVals = self.calculate_obs_and_exp()\\n for i in range(4):\\n if expVals[i] != 0:\\n chi += (obsVals[i] - expVals[i])**2 / expVals[i]\\n return chi\",\n \"def chibar(z):\\n return chi(z)\",\n \"def chi_square_test(data, var1, var2, pairwise = False, alpha = 0.05): \\n cont_table = pd.crosstab(data[var1], data[var2])\\n if not pairwise:\\n missing_indices = find_indices_with_value(cont_table, 0)\\n cont_table = cont_table.drop(missing_indices)\\n chi2, p, df, exp = stats.chi2_contingency(cont_table)\\n if (p < alpha): \\n print(\\\"statistically significant: %s\\\" % (tuple([var1, var2]), ))\\n print(\\\"p-value is \\\" + str(p))\\n display(cont_table.apply(lambda r: 100 * r/r.sum(), axis=0))\\n\\n return chi2, p, df, exp\\n else:\\n pairs = [\\\",\\\".join(map(str, comb)).split(\\\",\\\") for comb in combinations(cont_table.columns, 2)]\\n for pair in pairs:\\n cont_table2 = cont_table[pair]\\n missing_indices = find_indices_with_value(cont_table2, 0)\\n cont_table2 = cont_table2.drop(missing_indices)\\n \\n chi2, p, df, exp = stats.chi2_contingency(cont_table2)\\n if (p < alpha): \\n print(\\\"statistically significant: %s\\\" % (tuple(pair), ))\\n print(\\\"p-value is \\\" + str(p))\\n display(cont_table2.apply(lambda r: 100 * r/r.sum(), axis=0))\",\n \"def chi_square(self, collocation):\\n terms = collocation.split()\\n\\n # compute 2 X 2 table here\\n array = [[], []]\\n array[0] = [float(self.combined_freq[collocation]), float(self.combined_freq[terms[1]] - self.combined_freq[collocation])]\\n array[1] = [float(self.combined_freq[terms[0]]) - float(self.combined_freq[collocation]),\\n float(len(self.combined_freq) - ((2.0 * float(self.combined_freq[collocation])) +\\n float(self.combined_freq[terms[0]]) + float(self.combined_freq[terms[1]])))]\\n\\n # convert to nd array\\n array = np.array(array)\\n\\n # compute chi square statistic\\n chi_square = (float(len(self.combined_freq)) * pow(((array[0, 0] * array[1, 1]) - (array[0, 1] * array[1, 0])), 2)) /\\\\\\n ((array[0, 0] + array[0, 1]) * (array[0, 0] + array[1, 0]) * (array[0, 1] + array[1, 1]) *\\n (array[1, 0] + array[1, 1]))\\n return chi_square\",\n \"def chi2(data, fdata, err):\\n return sum(((data-fdata)/err)**2)\",\n \"def test_chi_3(self):\\n NN = 3\\n w = 0.09578833596200093\\n kz = 1.5975774807850725e-06\\n kp = 1.5975774807850725e-06\\n wp = 4789.4167982678364\\n tz = 217763.9218377612\\n tp = 195987.52965398508\\n vthz = 59958.491600000001\\n vthp = 56881.619557222031\\n omega = 0.9578833596200093\\n vz = 0.\\n\\n chi = f_chi(NN, w, kz, kp, wp, tz, tp, vthz, vthp,\\n omega, vz, method = 'numpy')\\n expected_chi = np.array([[246532.0684, 2.3160720168e6j, -14138.594698],\\n [-2.31607201685e6j, 25210.8159178 + \\n 120337.3246248j,-1.33708138e6-143053.010866j],\\n [-14138.594698, 1.33708138472e6 + 143053.010866j, -3.4654579662e6 + 2.977992432056e7j]])\\n npt.assert_allclose(chi, expected_chi, rtol = 1e-7)\",\n \"def compare_sums_chi(array1, array2):\\n return stats.chisquare(array1, array2)\",\n \"def _chisquare_value(self):\\n x2 = np.sum((np.absolute(self.observed - self.expected) - (0.5 * self.continuity_correction)) ** 2 /\\n self.expected)\\n\\n return x2\",\n \"def test_l19_chi(self):\\n beta_calc_chisq = BetaDiversityCalc(dist_chisq, 'chi square', False)\\n matrix, labels = beta_calc_chisq(data_path=self.l19_str, tree_path=None)\\n self.assertEqual(labels, self.l19_sample_names)\\n self.assertFloatEqual(matrix, dist_chisq(self.l19_data))\",\n \"def test_l19_chi(self):\\n beta_calc_chisq = BetaDiversityCalc(dist_chisq, 'chi square', False)\\n matrix, labels = beta_calc_chisq(data_path=self.l19_str, tree_path=None)\\n self.assertEqual(labels, self.l19_sample_names)\\n self.assertFloatEqual(matrix, dist_chisq(self.l19_data))\",\n \"def task_6_2_1():\\n # TODO Task 6.2.1: Your code goes here\\n x = []\\n for i in range(100):\\n xi = 0\\n xi = numpy.random.normal(0, 1)\\n x.append(xi)\\n\\n bins = 15\\n emp_n, emp_x = numpy.histogram(x, bins=bins)\\n Ch_2 = ChiSquare(emp_x, emp_n)\\n Ch_2.test_distribution(0.05, 0, 1)\\n # pass\",\n \"def chi(Mu, Y):\\n return Y*(1-hg2f3(Mu,Y))\",\n \"def test_l19_chi(self):\\r\\n beta_calc_chisq = BetaDiversityCalc(dist_chisq, 'chi square', False)\\r\\n matrix, labels = beta_calc_chisq(data_path=self.l19_fp, tree_path=None)\\r\\n self.assertEqual(labels, self.l19_sample_names)\\r\\n assert_almost_equal(matrix, dist_chisq(self.l19_data))\",\n \"def test_chi2(y0, y1, level):\\n if len(y0) == 0 or len(y1) == 0:\\n return True\\n l0 = np.argmax(y0, axis=1)\\n l1 = np.argmax(y1, axis=1)\\n v, c = np.unique(np.append(l0,l1), return_counts=True)\\n v0, c0 = np.unique(l0, return_counts=True)\\n v1, c1 = np.unique(l1, return_counts=True)\\n p = np.zeros(len(y0[0]))\\n p0 = p.copy()\\n p1 = p.copy()\\n p[v] = c / np.sum(c)\\n p0[v0] = c0 / np.sum(c0)\\n p1[v1] = c1 / np.sum(c1)\\n p0[p0==0] = 0.05\\n p1[p1 == 0] = 0.05\\n p[p==0] = 0.05\\n _, p0_value = stat.chisquare(p0, p)\\n _, p1_value = stat.chisquare(p1, p)\\n if 1-p0_value > level or 1-p1_value > level:\\n return False\\n else:\\n return True\",\n \"def calc_torsion_chi(self):\\n return (self.calc_torsion(\\\"chi1\\\"),\\n self.calc_torsion(\\\"chi2\\\"),\\n self.calc_torsion(\\\"chi3\\\"),\\n self.calc_torsion(\\\"chi4\\\"))\",\n \"def chi_squared(*choices):\\n\\n term = lambda expected, observed: float((expected - observed) ** 2) / max(expected, 1)\\n mean_success_rate = float(sum([c.rewards for c in choices])) / max(sum([c.plays for c in choices]), 1)\\n mean_failure_rate = 1 - mean_success_rate\\n\\n return sum([\\n term(mean_success_rate * c.plays, c.rewards)\\n + term(mean_failure_rate * c.plays, c.plays - c.rewards\\n ) for c in choices])\",\n \"def chi_squared(model, y, y_err):\\n\\n chi2 = np.sum(((model - y)**2)/(y_err**2))\\n return chi2\",\n \"def chi_squared(actual, predicted):\\n perturb = np.vectorize(lambda x: x if x != 0 else config.decision_boundary)\\n return np.sum((predicted - actual)**2 / perturb(actual))\",\n \"def chi_sq_test(v, alpha, k):\\n v = np.asarray(v).flatten()\\n n = v.shape[0]\\n # разделили на k интервалов\\n hist, bins = np.histogram(v, k)\\n dlt = bins[1] - bins[0]\\n\\n v_mean = np.sum(hist*bins[1:])/n\\n v_mean_sq = np.sum(hist*bins[1:]**2)/n\\n v_std = np.sqrt(v_mean_sq - v_mean**2)\\n print('mean: {}, std: {}'.format(v_mean, v_std))\\n\\n v_t = list(map(lambda x: n*norm_dist((x - v_mean)/v_std)*dlt/v_std, bins[1:]))\\n v_t = np.array(v_t)\\n chi_sq = np.sum(np.divide((hist - v_t)**2, v_t))\\n\\n q_right = stats.chi.ppf(1 - alpha*0.5, k - 1)\\n q_left = stats.chi.ppf(alpha*0.5, k - 1)\\n print(chi_sq)\\n print(q_left, q_right)\\n if q_left < chi_sq < q_right or chi_sq < q_left:\\n print('Не можем отвергать H0')\\n else:\\n print('H0 отвергается')\",\n \"def test_chao1(self):\\n self.assertEqual(chao1(self.TestData), 9.75)\\n self.assertEqual(chao1(self.TestData,bias_corrected=False),10.5)\\n self.assertEqual(chao1(self.NoSingles), 4)\\n self.assertEqual(chao1(self.NoSingles,bias_corrected=False),4)\\n self.assertEqual(chao1(self.NoDoubles), 5)\\n self.assertEqual(chao1(self.NoDoubles,bias_corrected=False),5)\",\n \"def chi_squared_of_fit(y_data, fitted_y_data):\\n\\t# note that in the typical definition of Chi-squared, it is assumed that \\n\\t# nature is wrong and our formula is theoretically perfect, but here we \\n\\t# are testing a model against emperical data, so the \\\"expected\\\" values \\n\\t# are the data we measured and the \\\"observed\\\" values are the values \\n\\t# generated by a fitting formula, and therefore we swap these variables \\n\\t# in the stats.chisquare(...) invocation\\n\\treturn stats.chisquare(fitted_y_data,y_data)\",\n \"def chi2_test(val0, val1):\\n try:\\n chisq = float((val0 - val1)**2) / float(val0 + val1)\\n if not chisq:\\n return (0, 1)\\n pval = 1.0 - chi2.cdf(chisq, 1)\\n return (chisq, pval)\\n except ZeroDivisionError as errstr:\\n return (0, 1)\",\n \"def chi_square(X, Y, Z, data, **kwargs):\\n\\n if isinstance(Z, (frozenset, list, set, tuple)):\\n Z = list(Z)\\n else:\\n Z = [Z]\\n\\n state_names = kwargs[\\\"state_names\\\"]\\n num_params = (\\n (len(state_names[X]) - 1)\\n * (len(state_names[Y]) - 1)\\n * np.prod([len(state_names[z]) for z in Z])\\n )\\n sufficient_data = len(data) >= num_params * 5\\n\\n if not sufficient_data:\\n warn(\\n \\\"Insufficient data for testing {0} _|_ {1} | {2}. \\\".format(X, Y, Z)\\n + \\\"At least {0} samples recommended, {1} present.\\\".format(\\n 5 * num_params, len(data)\\n )\\n )\\n\\n # compute actual frequency/state_count table:\\n # = P(X,Y,Zs)\\n XYZ_state_counts = pd.crosstab(\\n index=data[X], columns=[data[Y]] + [data[z] for z in Z]\\n )\\n # reindex to add missing rows & columns (if some values don't appear in data)\\n row_index = state_names[X]\\n column_index = pd.MultiIndex.from_product(\\n [state_names[Y]] + [state_names[z] for z in Z], names=[Y] + Z\\n )\\n if not isinstance(XYZ_state_counts.columns, pd.MultiIndex):\\n XYZ_state_counts.columns = pd.MultiIndex.from_arrays([XYZ_state_counts.columns])\\n XYZ_state_counts = XYZ_state_counts.reindex(\\n index=row_index, columns=column_index\\n ).fillna(0)\\n\\n # compute the expected frequency/state_count table if X _|_ Y | Zs:\\n # = P(X|Zs)*P(Y|Zs)*P(Zs) = P(X,Zs)*P(Y,Zs)/P(Zs)\\n if Z:\\n XZ_state_counts = XYZ_state_counts.sum(axis=1, level=Z) # marginalize out Y\\n YZ_state_counts = XYZ_state_counts.sum().unstack(Z) # marginalize out X\\n else:\\n XZ_state_counts = XYZ_state_counts.sum(axis=1)\\n YZ_state_counts = XYZ_state_counts.sum()\\n Z_state_counts = YZ_state_counts.sum() # marginalize out both\\n\\n XYZ_expected = pd.DataFrame(\\n index=XYZ_state_counts.index, columns=XYZ_state_counts.columns\\n )\\n for X_val in XYZ_expected.index:\\n if Z:\\n for Y_val in XYZ_expected.columns.levels[0]:\\n XYZ_expected.loc[X_val, Y_val] = (\\n XZ_state_counts.loc[X_val]\\n * YZ_state_counts.loc[Y_val]\\n / Z_state_counts\\n ).values\\n else:\\n for Y_val in XYZ_expected.columns:\\n XYZ_expected.loc[X_val, Y_val] = (\\n XZ_state_counts.loc[X_val]\\n * YZ_state_counts.loc[Y_val]\\n / float(Z_state_counts)\\n )\\n\\n observed = XYZ_state_counts.values.flatten()\\n expected = XYZ_expected.fillna(0).values.flatten()\\n # remove elements where the expected value is 0;\\n # this also corrects the degrees of freedom for chisquare\\n observed, expected = zip(\\n *((o, e) for o, e in zip(observed, expected) if not e == 0)\\n )\\n\\n chi2, significance_level = stats.chisquare(observed, expected)\\n\\n return chi2, significance_level\",\n \"def stat_test(self, counts):\\n\\n vals_list = list(counts.values())\\n\\n # account for bitstring with zero counts\\n numqubits = len(list(counts)[0])\\n numzeros = 2 ** numqubits - len(counts)\\n vals_list.extend([0] * numzeros)\\n\\n chisq, pval = chisquare(vals_list)\\n passed = bool(pval >= self._pcrit)\\n return (chisq, pval, passed)\",\n \"def chi_expected_values(contingency):\\n #Deprecated\\n total_responses = contingency.column(contingency.num_columns - 1).item(-1)\\n expected_values = []\\n for col_index in range(1, contingency.num_columns - 1):\\n for row_index in range(0, contingency.num_rows - 1):\\n column_total = contingency.column(col_index).item(-1)\\n row_total = contingency.row(row_index).item(-1)\\n expected_values.append((column_total*row_total)/total_responses)\\n return np.array(expected_values)\",\n \"def chi2(self):\\n return np.sum((np.dot(self.mmatrix,self.acoeff) - self.bvec)**2)\",\n \"def chi_2_test(magnitudes, errors):\\n num_obs = magnitudes.shape[0]\\n errors_sq = np.square(errors)\\n\\n m_bar = np.sum(np.divide(magnitudes, errors_sq)) /\\\\\\n np.sum(np.divide(np.ones(num_obs), errors_sq))\\n\\n chi_2 = np.sum(np.divide(np.square(magnitudes - m_bar), errors_sq))\\n return chi_2\",\n \"def f_test(chi1,df1,chi2,df2,red_chi = True):\\n\\n# if chi1/df1 > chi2/df2:\\n#\\tprob = 2. * f.cdf(chi1/df1, chi2/df2, df1, df2)\\n# else:\\n#\\tprob = 2. * f.cdf(chi2/df2, chi1/df1, df2, df1)\\n if red_chi:\\n\\tfval = (chi1/df1) / (chi2/df2)\\n else:\\n\\tfval = chi1 / chi2\\n prob = 2. * f.cdf((chi1/df1) / (chi2/df2), df1, df2)\\n if prob > 1.: \\n\\treturn 2. - prob\\n else:\\n\\treturn prob\",\n \"def calculate_chi_square_p_value(A):\\n nonzero_columns = np.where(A.any(axis=0))[0]\\n A_nonzero_columns = A[:, nonzero_columns]\\n _, p_value, _, _ = scipy.stats.chi2_contingency(A_nonzero_columns)\\n return p_value\",\n \"def chi2sf(x, k):\",\n \"def chisquare(obs, exp=None):\\n obs = N.array(obs)\\n\\n # get total number of observations\\n nobs = N.sum(obs)\\n\\n # if no expected value are supplied assume equal distribution\\n if exp == None:\\n exp = N.ones(obs.shape) * nobs / N.prod(obs.shape)\\n\\n # make sure to have floating point data\\n exp = exp.astype(float)\\n\\n # compute chisquare value\\n chisq = N.sum((obs - exp )**2 / exp)\\n\\n # return chisq and probability (upper tail)\\n return chisq, stats.chisqprob(chisq, N.prod(obs.shape) - 1)\",\n \"def _compute_chi_squared(confmat: Tensor, bias_correction: bool) ->Tensor:\\n expected_freqs = _compute_expected_freqs(confmat)\\n df = expected_freqs.numel() - sum(expected_freqs.shape) + expected_freqs.ndim - 1\\n if df == 0:\\n return torch.tensor(0.0, device=confmat.device)\\n if df == 1 and bias_correction:\\n diff = expected_freqs - confmat\\n direction = diff.sign()\\n confmat += direction * torch.minimum(0.5 * torch.ones_like(direction), direction.abs())\\n return torch.sum((confmat - expected_freqs) ** 2 / expected_freqs)\",\n \"def chisq(self, expected=None):\\n if expected is None:\\n expected = self.indep()\\n if self.y == expected.y and self.x == expected.x:\\n tot = 0.0\\n for y,x in self.coords(False):\\n tot += float(self.retrieve(y,x)-expected.retrieve(y,x))**2.0/float(expected.retrieve(y,x))\\n return tot\\n else:\\n raise IndexError(\\\"Matrix Chi Squared invalid for dimensions \\\"+str(self.y)+\\\"x\\\"+str(self.x)+\\\" and \\\"+str(other.y)+\\\"x\\\"+str(other.x))\",\n \"def calculate_chi2(target_data, source_data, q_min, q_max):\\n\\n matched_source_I = match_scatter_curves(target_data, source_data)\\n\\n # Get average I for experimental and calculated values over matched q\\n # range\\n matched_no = len(matched_source_I)\\n expt_avg = np.mean(target_data[0:matched_no, 1])\\n calc_avg = np.mean(matched_source_I)\\n\\n # Initial guess of the concentration:\\n # ratio of experimental and calculated average intensities\\n con = expt_avg / calc_avg\\n\\n if np.count_nonzero(target_data[:, 1]) == 0:\\n print(\\\"Chi^2 calculations cannot proceed without target data\\\")\\n sys.exit()\\n else:\\n \\n if (target_data.shape[1] > 2) and (\\n np.count_nonzero(target_data[:, 2]) != 0):\\n \\n # Call fortran code to calculate the reduced Chi2\\n chi2 = sjp_util.calc_chi2(\\n target_data[\\n :, 0], target_data[\\n :, 1], target_data[\\n :, 2], matched_source_I, matched_no, q_min, q_max, con, False)\\n \\n else:\\n #print \\\"For Chi^2 calculations an error column must be present\\\"\\n #sys.exit()\\n # Call fortran code to calculate the Pearson Chi2\\n chi2 = sjp_util.calc_pearson(target_data[:,0],\\n target_data[:,1],\\n matched_source_I,\\n matched_no,\\n q_min,\\n q_max,\\n con,\\n False)\\n \\n # 1/con is the scaling factor needed to multiply experimental I values\\n # to compare with calculated data\\n return chi2, 1.0 / con\",\n \"def test_action_of_choi_operator():\\n krauss = initialize_pauli_examples(0.1, 0.2, 0.3)\\n choi = sum([np.outer(np.ravel(x, \\\"F\\\"),\\n np.conj(np.ravel(x, \\\"F\\\").T)) for x in krauss])\\n choi_obj = ChoiQutip(choi, numb_qubits=[1, 1], dim_in=2, dim_out=2)\\n\\n for _ in range(0, 1000):\\n rho = np.array(rand_dm_ginibre(2).data.todense())\\n actual = choi_obj.channel(rho)\\n desired = sum([k.dot(rho).dot(np.conj(k).T) for k in krauss])\\n assert np.all(np.abs(actual - desired) < 1e-3)\\n\\n # Test number of qubits being 2.\\n krauss = np.kron(krauss, krauss)\\n choi = sum([np.outer(np.ravel(x, \\\"F\\\"),\\n np.conj(np.ravel(x, \\\"F\\\"))) for x in krauss])\\n choi_obj = ChoiQutip(choi, numb_qubits=[2, 2], dim_in=2, dim_out=2)\\n\\n for _ in range(0, 1000):\\n rho = np.array(rand_dm_ginibre(4).data.todense())\\n actual = choi_obj.channel(rho)\\n desired = sum([k.dot(rho).dot(np.conj(k).T) for k in krauss])\\n assert np.all(np.abs(actual - desired) < 1e-3)\\n\\n # Test Dephrasure Channe\\n krauss = set_up_dephrasure_conditions(0.1, 0.2)\\n choi = sum([np.outer(np.ravel(x, \\\"F\\\"),\\n np.conj(np.ravel(x, \\\"F\\\"))) for x in krauss])\\n choi_obj = ChoiQutip(choi, [1, 1], 2, 3)\\n\\n for _ in range(0, 1000):\\n rho = np.array(rand_dm_ginibre(2).data.todense())\\n actual = choi_obj.channel(rho)\\n desired = sum([k.dot(rho).dot(np.conj(k).T) for k in krauss])\\n assert np.all(np.abs(actual - desired) < 1e-3)\",\n \"def _update_chi2(self):\\n n_cols = len(self._profile)\\n # Fill matrix with nan initially\\n chi2_mat = np.full((n_cols, n_cols), np.nan)\\n # Compute chi_sq for each\\n for i in range(n_cols):\\n data_stats_compiler1 = self._profile[i].profiles[\\\"data_stats_profile\\\"]\\n profiler1 = data_stats_compiler1._profiles[\\\"category\\\"]\\n if not profiler1.is_match:\\n continue\\n for j in range(i, n_cols):\\n if i == j:\\n chi2_mat[i][j] = 1\\n continue\\n data_stats_compiler2 = self._profile[j].profiles[\\\"data_stats_profile\\\"]\\n profiler2 = data_stats_compiler2._profiles[\\\"category\\\"]\\n if not profiler2.is_match:\\n continue\\n\\n results = utils.perform_chi_squared_test_for_homogeneity(\\n profiler1.categorical_counts,\\n profiler1.sample_size,\\n profiler2.categorical_counts,\\n profiler2.sample_size\\n )\\n chi2_mat[i][j] = results[\\\"p-value\\\"]\\n chi2_mat[j][i] = results[\\\"p-value\\\"]\\n\\n return chi2_mat\",\n \"def assoc(X, Y, Zs):\\n return 1 - chi_square(X, Y, Zs, self.data, boolean=False)[1]\",\n \"def test(self):\\n return self._test(result_count=1, failure_amount=1)\",\n \"def test(self):\\n return self._test(result_count=1, failure_amount=1)\",\n \"def chi_squared(normalization, model, data, data_err):\\n model = np.array(model) * normalization\\n\\n # degrees of freedom = # observations - # params\\n dof = len(data) - 1.\\n\\n # for detections, get usual negative log-likelihood\\n detections = 0.5 * (data - model)**2 / data_err**2\\n\\n # for nondetections, use survival analysis likelihood, e.g., \\n # Feigelson & Nelson (1985)\\n #nondetections = 0.5 * (1 + erf(model / (np.sqrt(2) * data_err)))\\n\\n # UPDATE: we'll instead use a normal distribution centered on \\n # zero since it gives the intuitively correct answer when fitting. \\n nondetections = 0.5 * (0 - model)**2 / data_err**2\\n\\n # For a better treatment, we may want to use the survival function\\n # for a non-normal distribution... i.e., if we know the \\n # completeness as a function of flux, we may be able to create a \\n # log-likelihood of some non-detection for any model prediction.\\n\\n return np.sum(np.where(np.isfinite(data), detections, nondetections)) / dof\",\n \"def stat_test(self, counts):\\n q0len = len(self._qubit0)\\n q1len = len(self._qubit1)\\n cont_table = np.ones((2 ** q0len, 2 ** q1len))\\n\\n for (key, value) in counts.items():\\n key_rev = key[::-1]\\n q0index = int(key_rev[:q0len], 2)\\n q1index = int(key_rev[q0len:], 2)\\n cont_table[q0index][q1index] = value\\n\\n chisq, pval, _, _ = chi2_contingency(cont_table)\\n passed = bool(pval >= self._pcrit)\\n return (chisq, pval, passed)\",\n \"def tests_truth():\\n circ_m = ccxtest(4)\\n print(circ_m)\\n circ_m = crootnxtest(4)\\n print(circ_m)\\n circ_m = oracletest(4)\\n print(circ_m)\\n circ_m = ccx_otest(4)\\n print(circ_m)\",\n \"def testcheatTrue(self):\\n import Cheat\\n res = Cheat.cheatclass.cheatT(self)\\n exp = Cheat.cheatclass.cheatingR(self)\\n\\n self.assertTrue(res, exp)\",\n \"def chi_test_goodness_of_fit(dimension1, dimension2):\\n total_len = (dimension1 + dimension2) / 2\\n\\n X = (dimension1 - total_len) ** 2 / total_len + (dimension2 - total_len) ** 2 / total_len\\n return 1 - chi2.cdf(X, df=1)\",\n \"def chi2s(h1s, h2s):\\n return np.sum((h1s-h2s)**2/(h1s+h2s+1e-10), axis=1)\",\n \"def chi(self, theta):\\n yf = self.predict(self.t, theta)\\n sse = np.sum(np.square((yf - self.y) / self.dy))\\n return sse\",\n \"def chi2(actual_values, expected_values):\\n if actual_values.shape != expected_values.shape:\\n raise ValueError(\\n 'Shape mismatch: actual_values.shape = %s,'\\n ' expected_values.shape = %s'\\n % (actual_values.shape, expected_values.shape)\\n )\\n\\n # Convert to simple numpy arrays containing floats\\n if not isbarenumeric(actual_values):\\n actual_values = unp.nominal_values(actual_values)\\n if not isbarenumeric(expected_values):\\n expected_values = unp.nominal_values(expected_values)\\n\\n with np.errstate(invalid='ignore'):\\n # Mask off any nan expected values (these are assumed to be ok)\\n actual_values = np.ma.masked_invalid(actual_values)\\n expected_values = np.ma.masked_invalid(expected_values)\\n\\n # TODO: this check (and the same for `actual_values`) should probably\\n # be done elsewhere... maybe?\\n if np.any(actual_values < 0):\\n msg = ('`actual_values` must all be >= 0...\\\\n'\\n + maperror_logmsg(actual_values))\\n raise ValueError(msg)\\n\\n if np.any(expected_values < 0):\\n msg = ('`expected_values` must all be >= 0...\\\\n'\\n + maperror_logmsg(expected_values))\\n raise ValueError(msg)\\n\\n # TODO: Is this okay to do? Mathematically suspect at best, and can\\n # still destroy a minimizer's hopes and dreams...\\n\\n # Replace 0's with small positive numbers to avoid inf in division\\n np.clip(expected_values, a_min=SMALL_POS, a_max=np.inf,\\n out=expected_values)\\n\\n\\n delta = actual_values - expected_values\\n\\n if np.all(np.abs(delta) < 5*FTYPE_PREC):\\n return np.zeros_like(delta, dtype=FTYPE)\\n\\n chi2_val = np.square(delta) / expected_values\\n assert np.all(chi2_val >= 0), str(chi2_val[chi2_val < 0])\\n return chi2_val\",\n \"def test_hermitian(self, nqubits):\\n # better might be (arXiv:1405.6741)\\n dim = 2**nqubits\\n umat = scipy.stats.unitary_group.rvs(dim, random_state=750)\\n dmat = np.diag(np.exp(1j * np.random.normal(size=dim)))\\n mat = umat.T.conjugate() @ dmat @ umat\\n circ = self.qsd(mat, opt_a1=True, opt_a2=False)\\n ccirc = transpile(circ, basis_gates=[\\\"u\\\", \\\"cx\\\"], optimization_level=0)\\n self.assertTrue(np.allclose(mat, Operator(ccirc).data))\\n if nqubits > 1:\\n expected_cx = self._qsd_l2_cx_count(nqubits) - self._qsd_l2_a1_mod(nqubits)\\n self.assertLessEqual(ccirc.count_ops().get(\\\"cx\\\"), expected_cx)\",\n \"def chi2_adequacy_test (Y, Z, S, D):\\n\\tnum_models = Z.shape[0]\\n\\n\\tD = np.asarray(D)\\n\\tassert_is_shape(D, (num_models,))\\n\\n\\t# Squared Mahalanobis distance\\n\\tmahaf1 = lambda d, is2: np.sum( d * np.matmul(is2, d) )\\n\\t# Mahalanobis distances for all test points\\n\\tmahaf2 = lambda Y, Z, iS: [ mahaf1(y-z, is2) for y,z,is2 in zip(Y,Z,iS) ]\\n\\n\\tiS = np.linalg.inv(S)\\n\\tmaha = [ np.sum(mahaf2(Y,z,is2)) for z,is2 in zip(Z, iS)]\\n\\tmaha = np.array( maha )\\n\\n\\t# Degrees of freedom\\n\\tdof = Y.shape[0]*Y.shape[1] - np.asarray(D)\\n\\n\\tif np.any(dof <= 0):\\n\\t\\traise RuntimeWarning('Degrees of freedom not greater than zero.')\\n\\treturn 1. - chi2.cdf(maha, dof)\",\n \"def chi2_test(df, sample1, sample2, correction=True, alpha=0.05,\\n show_graph=True, **kwargs):\\n hypothesis = {\\n 'two-sided_H0': \\\"the samples are independent\\\",\\n 'two-sided_H1': \\\"the samples are dependent\\\"\\n }\\n expected, observed, stats = pg.chi2_independence(df, sample1, sample2,\\n correction)\\n p_value = stats.loc[stats['test'] == 'pearson']['pval'][0]\\n statistic = stats.loc[stats['test'] == 'pearson']['chi2'][0]\\n df_result = (\\n pd.DataFrame(\\n data={'statistic': [statistic],\\n 'p-val': [p_value]})\\n .rename({0: 'chi2'})\\n )\\n df_result['Expected Distribution'] = str(expected.values.tolist())\\n df_result['Observed Distribution'] = str(observed.values.tolist())\\n if show_graph:\\n pd.crosstab(df[sample1], df[sample2], normalize='index').plot(\\n kind='bar',\\n color=['r', 'b'],\\n **kwargs\\n )\\n return HypothesisTester.test_alternative(df_result, hypothesis,\\n alpha=alpha).T\",\n \"def _p_value(self):\\n p_value = chi2.sf(self.test_statistic, 2)\\n\\n return p_value\",\n \"def afriedmanchisquare(*args):\\r\\n k = len(args)\\r\\n if k < 3:\\r\\n raise ValueError, '\\\\nLess than 3 levels. Friedman test not appropriate.\\\\n'\\r\\n n = len(args[0])\\r\\n data = apply(pstats.aabut,args)\\r\\n data = data.astype(N.float_)\\r\\n for i in range(len(data)):\\r\\n data[i] = arankdata(data[i])\\r\\n ssbn = asum(asum(args,1)**2)\\r\\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\\r\\n return chisq, achisqprob(chisq,k-1)\",\n \"def chi2(self, pars = [], returnParameters = False):\\n\\t\\tif not self.chi2init:\\n\\t\\t\\traise RuntimeError(\\\"chi2 not inited, cannot evaluate\\\")\\n\\t\\t\\tprint pars\\n\\t\\tif len(pars) is not 0:\\n\\t\\t\\tself.setShapeParameters(pars)\\n\\t\\tA,B,C = self.getOwnTheoryABC()\\n\\n#\\t\\tprint B\\n#\\t\\tprint A\\n\\n\\t\\tif self.ownPinv:\\n\\t\\t\\tzmPars = -np.dot(B, utils.pinv(A + np.transpose(A), numLim = self.numLim))\\n\\t\\telse:\\n\\t\\t\\tzmPars = -np.dot(B, la.pinv(A + np.transpose(A)))\\n\\n\\n\\t\\tchi2 = np.dot(zmPars,np.dot(A,zmPars)) + np.dot(zmPars,B) + C\\n\\n\\t\\tif returnParameters:\\n\\t\\t\\treturn chi2, zmPars\\n\\t\\telse:\\n\\t\\t\\treturn chi2\",\n \"def make_chi_sq(data, errors, fit_range):\\n\\n def chi_sq(m, c):\\n ff = pp_flat(fit_range, m, c)\\n return sum((data - ff)**2 / errors**2) / len(fit_range)\\n # return sum([(data[t] - pp_flat(t, m, c))**2 / (errors[t])**2\\n # for t in fit_range]) / len(fit_range)\\n\\n return chi_sq\",\n \"def lfriedmanchisquare(*args):\\r\\n k = len(args)\\r\\n if k < 3:\\r\\n raise ValueError, 'Less than 3 levels. Friedman test not appropriate.'\\r\\n n = len(args[0])\\r\\n data = apply(pstats.abut,tuple(args))\\r\\n for i in range(len(data)):\\r\\n data[i] = rankdata(data[i])\\r\\n ssbn = 0\\r\\n for i in range(k):\\r\\n ssbn = ssbn + sum(args[i])**2\\r\\n chisq = 12.0 / (k*n*(k+1)) * ssbn - 3*n*(k+1)\\r\\n return chisq, chisqprob(chisq,k-1)\",\n \"def chi2(u,v):\\n\\n u[u==0] = 1e-6\\n v[v==0] = 1e-6\\n r = np.sum(((u-v)**2).astype(np.float)/(u+v))\\n\\n # m = (u != 0) & (v != 0)\\n # r = np.sum(((u[m]-v[m])**2).astype(np.float)/(u[m]+v[m]))\\n\\n # r = np.nansum(((u-v)**2).astype(np.float)/(u+v))\\n return r\",\n \"def test_cci(self):\\n q = qufilab.cci(self.close, self.high, self.low, 200)\\n t = talib.CCI(self.high, self.low, self.close, 200)\\n np.testing.assert_allclose(q, t, rtol = self.tolerance)\",\n \"def wrap_chi_sq(gcalc, gobs):\\n rw, scale = get_chi_sq(gobs, gcalc)\\n return rw, scale\",\n \"def c_test_fitness_function(self, function):\\r\\n return 1\",\n \"def c_test_fitness_function(self, function):\\r\\n return 1\",\n \"def test_hessian():\\n x, y = fwd.Variable(), fwd.Variable()\\n rosen = 100.0*(y - x**2)**2 + (1 - x)**2.0\\n rosen_hessian = lambda x, y: \\\\\\n np.array([[1200*x**2-400*x+2, -400*x],\\n [-400*x, 200]])\\n rosen_hessian_returned = rosen.hessian_at({x: 1.0, y: 1.0})\\n rosen_hessian_expected = rosen_hessian(1.0, 1.0)\\n for i in range(2):\\n for j in range(2):\\n assert equals(rosen_hessian_returned[i, j],\\n rosen_hessian_expected[i, j])\",\n \"def get_chi2(a, b):\\n off = (a - b)**2\\n return np.sqrt(np.sum(off)) / b.sum()\",\n \"def test_result(self):\\n result = compute()\\n self.assertEqual(result, '4782')\\n print(\\\"eulpy25Test passed\\\")\",\n \"def test_score():\\n print(\\\"Tests for 'score' function\\\")\\n test_suite = TestSuite()\\n\\n # Testing with empty hand\\n result = score([])\\n test_suite.run_test(result, 0, '0')\\n # Testing with non-empty hand\\n result = score([1, 3])\\n test_suite.run_test(result, 3, '1')\\n # Testing with non-empty hand\\n result = score([1, 3, 1, 1])\\n test_suite.run_test(result, 3, '2')\\n # Testing with non-empty hand\\n result = score([4, 3, 4, 3, 3])\\n test_suite.run_test(result, 9, '3')\\n\\n # Show report\\n test_suite.report_results()\",\n \"def test_single_hessian(self):\\n self.options.hes_method = [\\\"analytic\\\"]\\n self.controller.minimizer = \\\"general\\\"\\n _ = loop_over_hessians(self.controller,\\n options=self.options,\\n grabbed_output=self.grabbed_output,\\n checkpointer=self.cp)\\n self.assertEqual(self.controller.count, 1)\",\n \"def test_dichotomous_scores(dichotomous_Contingency, method, expected):\\n xs_score = getattr(dichotomous_Contingency, method)().item()\\n npt.assert_almost_equal(xs_score, expected)\",\n \"def test_suite():\\n test(sum_of_squares([2, 3, 4]) == 29)\\n test(sum_of_squares([ ]) == 0)\\n test(sum_of_squares([2, -3, 4]) == 29)\",\n \"def testSpeciesRichness(self):\\n self.assertEqual(66, self.coal.get_species_richness(1))\\n self.assertEqual(56, self.coal.get_species_richness(2))\\n self.assertEqual(125, self.coal.get_species_richness(3))\\n self.assertEqual(168, self.coal.get_species_richness(4))\\n self.assertEqual(102, self.coal.get_species_richness(5))\\n self.assertEqual(80, self.coal.get_species_richness(6))\\n self.assertEqual(169, self.coal.get_species_richness(7))\\n self.assertEqual(244, self.coal.get_species_richness(8))\\n self.assertEqual(126, self.coal.get_species_richness(9))\\n self.assertEqual(100, self.coal.get_species_richness(10))\\n self.assertEqual(196, self.coal.get_species_richness(11))\\n self.assertEqual(299, self.coal.get_species_richness(12))\\n self.assertEqual(145, self.coal.get_species_richness(13))\\n self.assertEqual(118, self.coal.get_species_richness(14))\\n self.assertEqual(218, self.coal.get_species_richness(15))\\n self.assertEqual(345, self.coal.get_species_richness(16))\",\n \"def test_quick_answer(self):\\n pass\",\n \"def test_entropy_complementary_channel_of_choi_operator():\\n # Dephrasure\\n krauss = set_up_dephrasure_conditions(0.1, 0.2)\\n choi = sum([np.outer(np.ravel(x, \\\"F\\\"),\\n np.conj(np.ravel(x, \\\"F\\\"))) for x in krauss])\\n choi_obj = ChoiQutip(choi, [1, 1], 2, 3)\\n\\n for _ in range(0, 1000):\\n # Random rho\\n rho = rand_dm_ginibre(2).data.todense()\\n # Get eigenvalues\\n desired = np.linalg.eigvalsh(entropyexchange(krauss, rho))\\n actual = np.linalg.eigvalsh(choi_obj.complementary_channel(rho))\\n\\n # Assert that eigenvalues are the same.\\n i = 0\\n for x in actual:\\n if np.abs(x) > 1e-8:\\n assert np.abs(desired[i] - x) < 1e-5\\n i += 1\",\n \"def test_cosine_mixture(self):\\n fun = get_problem('cosine_mixture', dimension=2, lower=-1, upper=1)\\n self.assertAlmostEqual(fun(np.zeros(2)), -0.2)\",\n \"def compute(real_data, synthetic_data):\\n f_obs, f_exp = get_frequencies(real_data, synthetic_data)\\n if len(f_obs) == len(f_exp) == 1:\\n pvalue = 1.0\\n else:\\n _, pvalue = chisquare(f_obs, f_exp)\\n\\n return pvalue\",\n \"def test_quintic(self):\\n fun = get_problem('quintic', self.dimension, -10.0, 10.0)\\n self.assertEqual(fun(self.array6), 0.0)\",\n \"def test_handcrafted_examples(self):\\n for i in range(1000):\\n self.assertEqual(perfectd(0), True)\\n self.assertEqual(prime(0), False)\\n self.assertEqual(prime(2), True)\\n self.assertEqual(prime(7), True)\\n self.assertEqual(prime(15), False)\\n self.assertEqual(perfectd(6), True)\\n self.assertEqual(perfectd(15), False)\",\n \"def cmh_test(*args):\\n import pandas, math\\n from statsmodels.stats.contingency_tables import StratifiedTable as cmh\\n\\n # set up data logging\\n ignored = {}\\n\\n # get contingency tables for pops with case and control data\\n tables = create_tables(*args)\\n\\n # fill in a dataframe with cmh test results, one locus at a time\\n results = pandas.DataFrame(columns=['locus', 'odds_ratio', 'p-value',\\n 'lower_confidence', 'upper_confidence', 'num_pops'])\\n for locus,table in tables.items():\\n if len(table) == 0:\\n # if none of the populations for a locus provide a contingency table (due to missing data)\\n # ... then continue to the next locus.\\n ignored[locus] = 'there were no populations that provided contingency tables'\\n continue\\n # cmh results for stratified contingency tables (called \\\"table\\\" = an array of tables)\\n cmh_res = cmh(table)\\n res = cmh_res.test_null_odds(True) # statistic and p-value\\n odds_ratio = cmh_res.oddsratio_pooled # odds ratio\\n conf = cmh_res.oddsratio_pooled_confint() # lower and upper confidence\\n locus_results = locus, odds_ratio, res.pvalue, *conf, len(table)\\n\\n # look for fixed states across all tables\\n\\n if sum([math.isnan(x) for x in conf]) > 0:\\n # if the upper and lower estimat of the confidence interval are NA, ignore\\n # this can happen when all of the tables returned for a specific locus are fixed\\n # ... for either the REF or ALT. This happens rarely for loci with low MAF, where\\n # ... the populations that have variable case or control, do not have a frequency\\n # ... estimated for the other treatment (case or control) and therefore don't\\n # ... make it into the list of stratified tables and the remaining tables\\n # ... (populations) are all fixed for the REF or ALT - again, this happens for\\n # ... some low MAF loci and may happen if input file has few pops to stratify.\\n\\n # log reason\\n ignored[locus] = 'the upper and lower confidence interval for the odds ratio was NA'\\n ignored[locus] = ignored[locus] + '\\\\t' + '\\\\t'.join(map(str, locus_results[1:]))\\n\\n continue\\n\\n results.loc[len(results.index), :] = locus_results\\n\\n return results, ignored\",\n \"def chi(self, theta, star_params=None):\\n if star_params is None:\\n star_params = []\\n theta = np.append(star_params, theta)\\n error = self.y - self.solve(theta)\\n return np.sum(np.square(error / self.dy))\",\n \"def test_print_result(capsys):\\n assert \\\"\\\"\\\"Total 5 hands solved\\nTotal 4 hands solved with hint\\nTotal 4 hands failed to solve\\\"\\\"\\\" in hl.test_help_print_result(capsys)\",\n \"def test_integration(self, ix, iy, iz, zx, zy, zz):\\n sigma = 20\\n toff = np.sqrt(2 * np.pi) * sigma * 1e-9\\n\\n backend = CrossResonanceHamiltonianBackend(toff, ix, iy, iz, zx, zy, zz)\\n durations = np.linspace(0, 700, 50)\\n expr = cr_hamiltonian.CrossResonanceHamiltonian(\\n qubits=(0, 1), flat_top_widths=durations, sigma=sigma, risefall=2\\n )\\n exp_data = expr.run(backend, shots=1000)\\n exp_data.block_for_results()\\n\\n self.assertAlmostEqual(exp_data.analysis_results(\\\"omega_ix\\\").value.value, ix, delta=1e3)\\n self.assertAlmostEqual(exp_data.analysis_results(\\\"omega_iy\\\").value.value, iy, delta=1e3)\\n self.assertAlmostEqual(exp_data.analysis_results(\\\"omega_iz\\\").value.value, iz, delta=1e3)\\n self.assertAlmostEqual(exp_data.analysis_results(\\\"omega_zx\\\").value.value, zx, delta=1e3)\\n self.assertAlmostEqual(exp_data.analysis_results(\\\"omega_zy\\\").value.value, zy, delta=1e3)\\n self.assertAlmostEqual(exp_data.analysis_results(\\\"omega_zz\\\").value.value, zz, delta=1e3)\",\n \"def test_stat(df,ivar,tvar,equal_var=True,ddof=0):\\n ivar_uniques = df[ivar].unique().shape[0]\\n tvar_uniques = df[tvar].unique().shape[0]\\n if tvar_uniques < 2:\\n print \\\"Only one sample can be generated\\\"\\n return None\\n if ivar_uniques <= 10: #This the case of a categorical independant variable. We use chisquare\\n ss = pd.crosstab(df[ivar],df[tvar])\\n ss = (ss.T/ss.sum(axis=1)).T\\n s0,s1 = ss[0].values,ss[1].values\\n\\n return chisquare(s1,s0,ddof=ddof)\\n\\n if ivar_uniques >10: #Consider using ttest\\n s0 = df[ivar][df[tvar] == 0]\\n s1 = df[ivar][df[tvar] == 1]\\n return ttest_ind(s1,s0,equal_var=equal_var)\",\n \"def fit_chi(fit,data,errs,dof):\\n\\tif len(fit)!=len(data) or len(data)!=len(errs):\\n\\t\\traise ValueError('Input vectors have unequal lengths.')\\n\\tsquared_err = np.power(np.subtract(fit,data),2)\\n\\treturn np.sum(np.divide(squared_err,np.power(errs,2)))/dof\",\n \"def test_secant(testFunctions, tol, printFlag): \\n pass\",\n \"def test_secant_system(testFunctions, tol, printFlag): \\n pass\",\n \"def _calculate_chi_squared (desc_rolls_tuples) :\\n \\n results = { }\\n \\n for desc_str, obs_roll_array in desc_rolls_tuples :\\n \\n # we aren't providing expected values because we expect the sides\\n # of the die to be rolled with equal frequency,\\n # and that's the default for the scipy version of chi squared;\\n # scipy's chi squared method also calculates the degrees of\\n # freedom based on the length of our array, which works in this case\\n chi_sq_stat, p_value = chisquare(numpy.array(obs_roll_array))\\n results[desc_str] = (chi_sq_stat, p_value)\\n \\n return results\",\n \"def _test_evaluate(self, format_only, outfile_predix=None):\\n metric = MOTChallengeMetric(\\n metric=['HOTA', 'CLEAR', 'Identity'],\\n format_only=format_only,\\n outfile_prefix=outfile_predix)\\n metric.dataset_meta = {'classes': ('pedestrian', )}\\n data_batch = dict(input=None, data_samples=None)\\n predictions = self._get_predictions_demo()\\n metric.process(data_batch, predictions)\\n eval_results = metric.evaluate()\\n return eval_results\",\n \"def test(self, session, num_tests):\\n score_list = np.zeros(num_tests)\\n for n in range(num_tests):\\n game = tetris.Game(self.rows, self.columns, self.tetriminos, self.end_at)\\n while not game.game_over:\\n # Pass state to network - perform best action and add reward to log\\n state = [game.state()]\\n q_values = session.run(self.net.q_out, feed_dict={self.net.inputs: state})\\n mask = validity_mask(game.next_tetrimino, self.columns)\\n q_masked = np.where(mask, q_values, -1000)\\n action = np.argmax(q_masked, 1)[0]\\n rotation, column = action_to_rc(action, self.columns)\\n score_list[n] += game.place_tetrimino(rotation, column)\\n return np.mean(score_list), np.std(score_list)\",\n \"def test_fun_result(self):\\n x = CArray([3, 5])\\n correct_result = x[0] ** 2 + x[1] ** 2\\n self._test_fun_result(self.fun, x, correct_result.item())\",\n \"def test_menhinick(self):\\n self.assertEqual(menhinick(self.TestData), 9/sqrt(22))\",\n \"def main():\\r\\n _evaluative_test(5)\\r\\n _fuzz_test(1)\\r\\n _fuzz_test(1, 512)\\r\\n _fuzz_test(1, 1512)\\r\\n _fuzz_test(1000)\\r\\n _fuzz_test(1000, 512)\\r\\n _fuzz_test(1000, 4077)\",\n \"def test_multifit_num_results(self, perform_fit):\\n cost_func = make_cost_function('multifit_set/multifit.txt')\\n problem = cost_func.problem\\n cost_func.jacobian = Scipy(problem)\\n cost_func.jacobian.method = '2-point'\\n controller = DummyController(cost_func=cost_func)\\n options = problem.options\\n options.table_type = ['acc', 'runtime', 'compare', 'local_min']\\n grabbed_output = output_grabber.OutputGrabber(options)\\n controller.final_params = [[0.1, 0.1], [0.1, 0.1]]\\n controller.parameter_set = 0\\n perform_fit.return_value = ([0.1, 0.2],\\n [0.1, 0.01],\\n [10e-3, 10e-4])\\n results = loop_over_hessians(controller=controller,\\n options=options,\\n grabbed_output=grabbed_output,\\n checkpointer=self.cp)\\n self.assertTrue(len(results) == 2)\",\n \"def test(self, c):\\n\\tc.sort()\\n\\n # If we had this test before, return its result\\n if self.cache_outcomes:\\n cached_result = self.outcome_cache.lookup(c)\\n if cached_result is not None:\\n return cached_result\\n\\n if self.monotony:\\n # Check whether we had a passing superset of this test before\\n cached_result = self.outcome_cache.lookup_superset(c)\\n if cached_result == self.PASS:\\n return self.PASS\\n \\n cached_result = self.outcome_cache.lookup_subset(c)\\n if cached_result == self.FAIL:\\n return self.FAIL\\n\\n\\tif self.debug_test:\\n print\\n\\t print \\\"test(\\\" + self.coerce(c) + \\\")...\\\"\\n\\n\\toutcome = self._test(c)\\n\\n #Statistics about actually executed tests\\n self.n_tests +=1\\n if outcome == self.FAIL:\\n self.n_fails +=1\\n elif outcome == self.PASS:\\n self.n_passes +=1\\n elif outcome == self.UNRESOLVED:\\n self.n_unres +=1\\n\\n\\tif self.debug_test:\\n\\t print \\\"test(\\\" + self.coerce(c) + \\\") = \\\" + `outcome`\\n\\n if self.cache_outcomes:\\n self.outcome_cache.add(c, outcome)\\n\\n\\treturn outcome\",\n \"def chi(nuc, temp=300.0, group_struct=None, phi_g=None, xs_cache=None, eres=101):\\n xs_cache = cache.xs_cache if xs_cache is None else xs_cache\\n _prep_cache(xs_cache, group_struct, phi_g)\\n if isinstance(nuc, collectionsAbc.Iterable) and not isinstance(nuc, basestring):\\n return _atom_mass_channel(chi, nuc, temp=temp, xs_cache=xs_cache, eres=eres)\\n nuc = nucname.id(nuc)\\n key = (nuc, \\\"chi\\\", temp)\\n\\n # Don't recalculate anything if you don't have to\\n if key in xs_cache:\\n return xs_cache[key]\\n\\n # Get the the set of nuclides we know we need chi for.\\n if \\\"fissionable_nucs\\\" not in xs_cache:\\n with tb.open_file(nuc_data, \\\"r\\\") as f:\\n if \\\"/neutron/cinder_xs/fission\\\" in f:\\n fn = set(f.root.neutron.cinder_xs.fission.cols.nuc)\\n else:\\n fn = set()\\n xs_cache[\\\"fissionable_nucs\\\"] = fn\\n fissionable_nucs = xs_cache[\\\"fissionable_nucs\\\"]\\n if (nuc not in fissionable_nucs) and (86 <= nucname.znum(nuc)):\\n fissionable_nucs.add(nuc)\\n\\n # Perform the group collapse on a continuous chi\\n E_g = xs_cache[\\\"E_g\\\"]\\n G = len(E_g) - 1\\n chi_g = np.zeros(G, dtype=\\\"f8\\\")\\n if nuc in fissionable_nucs:\\n for g in range(G):\\n E_space = np.logspace(np.log10(E_g[g]), np.log10(E_g[g + 1]), eres)\\n dnumer = models.chi(E_space)\\n numer = scipy.integrate.trapz(dnumer, E_space)\\n denom = E_g[g + 1] - E_g[g]\\n chi_g[g] = numer / denom\\n # renormalize chi\\n chi_g = chi_g / chi_g.sum()\\n # Put this value back into the cache, with the appropriate label\\n xs_cache[key] = chi_g\\n return chi_g\",\n \"def __getChiSq(self, wMP):\\n\\t\\t\\n\\t\\t# Calculate reconstructed spectrum\\n\\t\\trecSp = np.dot(self.specTemplates, wMP)\\n\\t\\t\\n\\t\\t# Determine residual and transpose\\n\\t\\tres = (recSp-self.flux).reshape(self.nBins,1)\\n\\t\\tresT = np.transpose(res)\\n\\t\\t\\n\\t\\t# Determine chi-squared value.\\n\\t\\tchiSq = 0.5*np.dot((resT * self.covInv), res)[0][0]\\n\\t\\t\\t\\t\\n\\t\\treturn chiSq\",\n \"def test_square(self, board, row, col, test):\\n if row < 0 or row > 7:\\n return False\\n if col < 0 or col > 7:\\n return False\\n \\n return test(board[row][col])\",\n \"def testGetsPresentRichness(self):\\n self.assertEqual(37, self.coal.get_species_richness(1))\\n self.assertEqual(53, self.coal.get_species_richness(3))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69860387","0.6974439","0.692027","0.6900534","0.68230224","0.68178236","0.68107116","0.6658554","0.6568164","0.6543013","0.64838725","0.6453995","0.63928324","0.63667536","0.6342304","0.6342304","0.6321123","0.6321073","0.6294361","0.624833","0.6242034","0.62416893","0.62046456","0.62013286","0.6167822","0.6139616","0.61162317","0.60766035","0.60621","0.6051655","0.6025946","0.59860086","0.59750426","0.5972494","0.59541094","0.59534746","0.5890691","0.58553034","0.58541894","0.58350694","0.5818343","0.58136445","0.58022195","0.58008736","0.58008736","0.579986","0.57763606","0.5774272","0.5747373","0.57451755","0.5733744","0.5707739","0.570452","0.57000786","0.5687106","0.5679159","0.56716216","0.56615615","0.5651289","0.5641812","0.5605357","0.5589254","0.5585419","0.55770904","0.5561093","0.5561093","0.55465126","0.55440617","0.5540793","0.5530321","0.5526562","0.55153847","0.55118454","0.5502306","0.5486186","0.54851174","0.5483781","0.5482803","0.5469691","0.54616624","0.5460189","0.5456204","0.5454715","0.5444649","0.54225194","0.54145294","0.54143053","0.53875536","0.5384675","0.5362787","0.535104","0.5328508","0.53096473","0.5308481","0.53047657","0.53044873","0.53031385","0.52955014","0.52938676","0.52928245"],"string":"[\n \"0.69860387\",\n \"0.6974439\",\n \"0.692027\",\n \"0.6900534\",\n \"0.68230224\",\n \"0.68178236\",\n \"0.68107116\",\n \"0.6658554\",\n \"0.6568164\",\n \"0.6543013\",\n \"0.64838725\",\n \"0.6453995\",\n \"0.63928324\",\n \"0.63667536\",\n \"0.6342304\",\n \"0.6342304\",\n \"0.6321123\",\n \"0.6321073\",\n \"0.6294361\",\n \"0.624833\",\n \"0.6242034\",\n \"0.62416893\",\n \"0.62046456\",\n \"0.62013286\",\n \"0.6167822\",\n \"0.6139616\",\n \"0.61162317\",\n \"0.60766035\",\n \"0.60621\",\n \"0.6051655\",\n \"0.6025946\",\n \"0.59860086\",\n \"0.59750426\",\n \"0.5972494\",\n \"0.59541094\",\n \"0.59534746\",\n \"0.5890691\",\n \"0.58553034\",\n \"0.58541894\",\n \"0.58350694\",\n \"0.5818343\",\n \"0.58136445\",\n \"0.58022195\",\n \"0.58008736\",\n \"0.58008736\",\n \"0.579986\",\n \"0.57763606\",\n \"0.5774272\",\n \"0.5747373\",\n \"0.57451755\",\n \"0.5733744\",\n \"0.5707739\",\n \"0.570452\",\n \"0.57000786\",\n \"0.5687106\",\n \"0.5679159\",\n \"0.56716216\",\n \"0.56615615\",\n \"0.5651289\",\n \"0.5641812\",\n \"0.5605357\",\n \"0.5589254\",\n \"0.5585419\",\n \"0.55770904\",\n \"0.5561093\",\n \"0.5561093\",\n \"0.55465126\",\n \"0.55440617\",\n \"0.5540793\",\n \"0.5530321\",\n \"0.5526562\",\n \"0.55153847\",\n \"0.55118454\",\n \"0.5502306\",\n \"0.5486186\",\n \"0.54851174\",\n \"0.5483781\",\n \"0.5482803\",\n \"0.5469691\",\n \"0.54616624\",\n \"0.5460189\",\n \"0.5456204\",\n \"0.5454715\",\n \"0.5444649\",\n \"0.54225194\",\n \"0.54145294\",\n \"0.54143053\",\n \"0.53875536\",\n \"0.5384675\",\n \"0.5362787\",\n \"0.535104\",\n \"0.5328508\",\n \"0.53096473\",\n \"0.5308481\",\n \"0.53047657\",\n \"0.53044873\",\n \"0.53031385\",\n \"0.52955014\",\n \"0.52938676\",\n \"0.52928245\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5677939"},"document_rank":{"kind":"string","value":"56"}}},{"rowIdx":86094,"cells":{"query":{"kind":"string","value":"Perform a rvalue test. Only positive data (intensities). Returns"},"document":{"kind":"string","value":"def run_rvalue(self, silent_run=False):\n odata = np.sqrt(self.obs.data)\n edata = np.sqrt(self.exp.data)\n self.rvalue = np.sqrt((odata - edata)**2.).sum()\n self.rvalue /= edata.sum()\n if not silent_run:\n return self.rvalue"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_of_with_args(self) -> None:\n assert Result.of(lambda x: bool(x > 0), 1).unwrap() is True","def test_pos():\n # Test for positive special method with scalar Rnode object\n x = Rnode(5)\n z = +x\n try:\n assert z.value == 1 * x.value\n except AssertionError as e:\n print(e)\n raise AssertionError","def is_lvalue(*args):\n return _ida_hexrays.is_lvalue(*args)","def test_neg():\n # Test for negation with scalar Rnode object\n x = Rnode(5.0)\n z = -x\n try:\n assert z.value == -1 * x.value\n except AssertionError as e:\n print(e)\n raise AssertionError","def calc_rvalue_type(self, *args):\n return _ida_hexrays.cfunc_parentee_t_calc_rvalue_type(self, *args)","def test_rightHandArgumentImplementsUnequality(self):\n self.assertFalse(Record(1, 2) != EqualToEverything())\n self.assertTrue(Record(1, 2) != EqualToNothing())","def test_get_squarerect_ltz_all_int(self):\n result = get_squarerectangle_type(-1, -1, -1, -1)\n self.assertEqual(result, 'invalid')","def test_findXCoordinateFromDirection_right(self):\n actual_result = rules.findXCoordinateFromDirection(3)\n expected_result = 2\n self.assertEqual(actual_result, expected_result)","def test_true_is_armstrong(number: int):\n assert is_armstrong(number)","def test_function(my_data):\n return my_data == 42","def check_nondiff_rop(self, y):\r\n raised = False\r\n try:\r\n tmp = tensor.Rop(y, self.x, self.v)\r\n except ValueError:\r\n raised = True\r\n if not raised:\r\n self.fail((\r\n 'Op did not raise an error even though the function'\r\n ' is not differentiable'))","def forward(self, x):\n return self.simple_test(x)","def test_get_r():\n\n assert get_r(100, 143, 255) == 100\n assert get_r(100, 143, 255) != 143\n assert get_r(100, 143, 255) != 255","def test_rsub():\n # Test for reverse subtraction with scalar Rnode object and float value\n x = Rnode(0.5)\n z = 0.1 - x\n try:\n assert z.value == x.value - 0.1\n except AssertionError as e:\n print(e)\n raise AssertionError","def test_positive_value_exists(self):\n #######################################\n # Test for True\n value_to_test = 1\n self.assertEqual(positive_value_exists(value_to_test), True,\n \"Testing value: {value_to_test}, True expected\".format(value_to_test=value_to_test))\n\n value_to_test = 100\n self.assertEqual(positive_value_exists(value_to_test), True,\n \"Testing value: {value_to_test}, True expected\".format(value_to_test=value_to_test))\n\n value_to_test = 'hello'\n self.assertEqual(positive_value_exists(value_to_test), True,\n \"Testing value: {value_to_test}, True expected\".format(value_to_test=value_to_test))\n\n value_to_test = True\n self.assertEqual(positive_value_exists(value_to_test), True,\n \"Testing value: {value_to_test}, True expected\".format(value_to_test=value_to_test))\n\n value_to_test = {\n 'success': True\n }\n self.assertEqual(positive_value_exists(value_to_test), True,\n \"Testing value: {value_to_test}, True expected\".format(value_to_test=value_to_test))\n\n value_to_test = [\n 'success'\n ]\n self.assertEqual(positive_value_exists(value_to_test), True,\n \"Testing value: {value_to_test}, True expected\".format(value_to_test=value_to_test))\n\n #######################################\n # Test for False\n value_to_test = 0\n self.assertEqual(positive_value_exists(value_to_test), False,\n \"Testing value: {value_to_test}, False expected\".format(value_to_test=value_to_test))\n\n value_to_test = -1\n self.assertEqual(positive_value_exists(value_to_test), False,\n \"Testing value: {value_to_test}, False expected\".format(value_to_test=value_to_test))\n\n value_to_test = ''\n self.assertEqual(positive_value_exists(value_to_test), False,\n \"Testing value: {value_to_test}, False expected\".format(value_to_test=value_to_test))\n\n value_to_test = '0'\n self.assertEqual(positive_value_exists(value_to_test), False,\n \"Testing value: {value_to_test}, False expected\".format(value_to_test=value_to_test))\n\n value_to_test = False\n self.assertEqual(positive_value_exists(value_to_test), False,\n \"Testing value: {value_to_test}, False expected\".format(value_to_test=value_to_test))\n\n value_to_test = {}\n self.assertEqual(positive_value_exists(value_to_test), False,\n \"Testing value: {value_to_test}, False expected\".format(value_to_test=value_to_test))\n\n value_to_test = []\n self.assertEqual(positive_value_exists(value_to_test), False,\n \"Testing value: {value_to_test}, False expected\".format(value_to_test=value_to_test))","def test_badxvaluewithbools(self):\n Rectangle.reset_objects()\n with self.assertRaises(TypeError) as e:\n r1 = Square(1, False, 2, 3)\n self.assertEqual(str(e.exception), 'x must be an integer')","def requires_lvalue(self, *args):\n return _ida_hexrays.cexpr_t_requires_lvalue(self, *args)","def test_cdef_return_object(x: object) -> object:\n if x:\n return x\n else:\n raise RuntimeError()","def test_copy_non_bool_error(self):\n\n with pytest.raises(ValueError):\n\n BaseTransformer(copy=1)","def sift_rest(x):\n return True","def valid(rv:Optional[int])->bool:\n # return False # stub\n # template from optional\n if rv is None:\n return False\n else:\n return True\n \n \n\n\n start_testing()","def check_result(context, expected):\n assert context.result == expected, \"Wrong result: {r} != {e}\".format(\n r=context.result, e=expected\n )","def test_fasle_is_armstrongs(number: int):\n assert is_armstrong(number) is False","def test_pos():\n value = -42\n num_a = param.Integer(value=value)\n assert +num_a.value == +value","def validate(self):\n # rVal = False\n # return rVal\n return True","def __call__(self): # run test\n\n try: # Check if any errors were raised during calling of self.func\n return abs(self.func(*self.args, **self.kwargs) - self.res) < self._tolerance\n\n except IndexError:\n return False","def test_badyvaluewithbools(self):\n Rectangle.reset_objects()\n with self.assertRaises(TypeError) as e:\n r1 = Square(1, 2, True, 3)\n self.assertEqual(str(e.exception), 'y must be an integer')","def _check_returned_tracer(return_val):\n if (isinstance(return_val, int)):\n check(return_val)\n tr = None\n else:\n tr, _ = return_val\n return tr","def test_rschematic_negative(self):\n args_q = [\n # Invalid string as type\n (\"name\", \"str\", False),\n # Invalid string tuple for types\n (\"name\", (\"str\", int), False),\n # Invalid string tuple for types\n (\"name\", (\"str\", int), False),\n # Invalid string as nullable\n (\"name\", str, \"False\"),\n # Invalid int as nullable\n (\"name\", (str, int), 0),\n ]\n for args in args_q:\n self.rschematic_negative(args)","def main() -> None:\r\n _: Stage = Stage(background_color='#333')\r\n\r\n any_value_1: AnyValue = AnyValue(10)\r\n any_value_1 = any_value_1 + 10\r\n assert_equal(expected=20, actual=any_value_1)\r\n\r\n any_value_2: AnyValue = AnyValue(20)\r\n int_1: Int = Int(10)\r\n any_value_2 = any_value_2 - int_1\r\n assert_equal(expected=10, actual=any_value_2)\r\n\r\n any_value_3: AnyValue = AnyValue(10)\r\n any_value_3 = any_value_3 * 3\r\n assert_equal(expected=30, actual=any_value_3)\r\n\r\n any_value_4: AnyValue = AnyValue(50)\r\n any_value_4 = any_value_4 / 2\r\n assert_equal(expected=25, actual=any_value_4)\r\n\r\n any_value_5: AnyValue = AnyValue(10)\r\n any_value_5 = any_value_5 // 3\r\n assert_equal(expected=3, actual=any_value_5)\r\n\r\n any_value_6: AnyValue = AnyValue(20)\r\n any_value_6 += 30\r\n assert_equal(expected=50, actual=any_value_6)\r\n\r\n any_value_7: AnyValue = AnyValue(60)\r\n any_value_7 -= 25\r\n assert_equal(expected=35, actual=(any_value_7))\r\n\r\n any_value_8: AnyValue = AnyValue(3)\r\n any_value_8 *= 10\r\n assert_equal(expected=30, actual=any_value_8)\r\n\r\n any_value_9: AnyValue = AnyValue(20)\r\n any_value_9 /= 4\r\n assert_equal(expected=5, actual=any_value_9)\r\n\r\n any_value_10: AnyValue = AnyValue(10)\r\n result: Boolean = any_value_10 == 10\r\n assert_true(result)\r\n result = any_value_10 == 11\r\n assert_false(result)\r\n\r\n result = any_value_10 != 11\r\n assert_true(result)\r\n result = any_value_10 != 10\r\n assert_false(result)\r\n\r\n result = any_value_10 < 11\r\n assert_true(result)\r\n result = any_value_10 < 10\r\n assert_false(result)\r\n\r\n result = any_value_10 <= 10\r\n assert_true(result)\r\n result = any_value_10 <= 9\r\n assert_false(result)\r\n\r\n result = any_value_10 > 9\r\n assert_true(result)\r\n result = any_value_10 > 10\r\n assert_false(result)\r\n\r\n result = any_value_10 >= 10\r\n assert_true(result)\r\n result = any_value_10 >= 11\r\n assert_false(result)\r\n\r\n save_overall_html(dest_dir_path=_DEST_DIR_PATH)","def test_r():\n y, x = np.indices((10,20))\n\n default_use_numexpr = accel_math._USE_NUMEXPR\n\n accel_math._USE_NUMEXPR = True\n r1 = accel_math._r(x,y)\n\n accel_math._USE_NUMEXPR = False\n r2 = accel_math._r(x,y)\n\n np.testing.assert_almost_equal(r1,r2)\n\n accel_math._USE_NUMEXPR = default_use_numexpr","def test_running_sum_multi_positives(self):\n\n argument = [4,2,3,6]\n expected = [4,6,9,15]\n sums.running_sum(argument)\n self.assertEqual(expected,argument,\"the list contains only positive values\")","def assert_positive(x):\n \n assert(all(x) >= 0)","def test_is_rock_valid():\n\n\tassert game.is_val('rock') is True # muze byt jenom 'True', vsechny True stejne ID i False","def testfn(arg):\n if arg == 42:\n raise ValueError('Oh noes')\n return arg","def test_rodrigues(self):\n quat = np.random.rand(4)\n quat = quaternion.from_float_array(quat / np.linalg.norm(quat))\n\n r_vec = quaternion.as_rotation_vector(quat)\n r_mat_targ = quaternion.as_rotation_matrix(quat)\n\n r_norm = np.linalg.norm(r_vec)\n r_axis = r_vec / r_norm\n r = rodrigues(r_axis, r_norm)\n self.assertTrue(np.allclose(r, r_mat_targ, rtol=1e-5, atol=1e-5))","def test_regular_result(self):\n passthrough = self.make_wrapped_function()\n result = passthrough(123)\n self.assertEqual(result, 123)","def test_peek_single(values, expected_value):\n test_stack = stack.Stack()\n for value in values:\n test_stack.push(value)\n\n returned_value = test_stack.peek()\n\n assert returned_value == expected_value\n\n for value in reversed(values):\n assert test_stack.pop() == value","def test_radd():\n # Test for reverse addition with scalar Rnode object and float value\n x = Rnode(0.11)\n z = 0.5 + x\n z.grad_value = 1.0\n\n try:\n assert z.value == x.value + 0.5\n except AssertionError as e:\n print(e)","def test_bit_rscan_value_not_found(self):\n value = False\n ops = [bitwise_operations.bit_rscan(self.five_255_bin, 0, 40, value)]\n\n expected_value = -1\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[self.five_255_bin] == expected_value","def test_unary_op_support():\n check_peval_expression(\"+(2)\", {}, \"2\", fully_evaluated=True, expected_value=2)\n check_peval_expression(\"-(-3)\", {}, \"3\", fully_evaluated=True, expected_value=3)\n check_peval_expression_bool(\"not 0\", {}, True)\n check_peval_expression(\"~(-4)\", {}, \"3\", fully_evaluated=True, expected_value=3)","def test_right_turn_true(self):\n point1 = np.array([1, 1])\n point2 = np.array([2, 2])\n point3 = np.array([3, 1])\n\n right_angle1 = convex_hull.right_turn(point1, point2, point3) # first right turn angle (boolean)\n right_angle2 = convex_hull.right_turn(point1, point3, point2) # second right turn angle (boolean)\n\n self.assertTrue(right_angle1 and not right_angle2)","def testIsNullFalseAgain(self):\n val = is_null(5) \n self.assertFalse(val)","def check(self):\n raise NotImplementedError()\n #return (value, **kw)","def test_le():\n # Test for less than or equal to special method with scalar Rnode object and float value\n x = Rnode(2.0)\n try:\n assert (x <= 3) == True\n assert (x <= 2) == True\n assert (x <= 1) == False\n except AssertionError as e:\n print(e)\n raise AssertionError\n\n # Test for less than or equal to special method with two scalar Rnode object\n a = Rnode(2.0)\n b = Rnode(2.0)\n c = Rnode(1.0)\n d = Rnode(1.0)\n try:\n assert (a <= b) == True\n assert (a <= c) == False\n assert (a <= d) == False\n except AssertionError as e:\n print(e)\n raise AssertionError","def any(self) -> int:","def any(self) -> int:","def test_absolute_truth():\n assert True","def obj_func(x):\n assert(False)","def test_03_pass(self):\n if x==1:\n pass","def test_rightHandArgumentImplementsEquality(self):\n self.assertTrue(Record(1, 2) == EqualToEverything())\n self.assertFalse(Record(1, 2) == EqualToNothing())","def not_equals_success_func(target, result):\n if result is None:\n return False\n return target != result","def validate(self):\n\t\trVal = False\n\t\t#return rVal\n\t\treturn True","def test_return_value(self):\n self.assertEqual(self.r0.from_json_string(self.string), self.d)","def test_evaluates_correctly_true(self, test_generator):\n self.assertTrue(test_generator())\n self.assertTrue(bool(test_generator()))\n if not test_generator():\n self.fail(\"did not evaluate true\")","def should_return(self, value):\n \n return False","def test04_boolean_operator(self):\n\n import _cppyy\n number = _cppyy.gbl.number\n\n n = number(20)\n assert n\n\n n = number(0)\n assert not n","def test_is_empty_single(values, expected_result):\n test_stack = stack.Stack()\n for value in values:\n test_stack.push(value)\n\n result = test_stack.is_empty()\n\n assert result == expected_result","def __call__(self, observation):\n delta = super(BinarizedScalarDeltaReward, self).__call__(observation)\n # Validate that delta is a scalar.\n _ = float(delta)\n if delta == 0:\n return None\n return int(delta > 0)","def test_isACaptureP_bad_direction(self, mock_captureHelper):\n mock_captureHelper.return_value = True\n rules_obj = rules.Rules(test_mode=True)\n board = gamenode.GameNode()\n foxCoordinate = coordinate.Coordinate(3, 3)\n direction = 20\n actual_result = rules_obj.isACaptureP(board, foxCoordinate, direction)\n expected_result = False\n self.assertEqual(actual_result, expected_result)","def does_it_return(func, args):\n \n if args is None:\n assert(func() is not None)\n else:\n assert(func(*args) is not None)","def test_no_user_argument_but_passed(self):\n @converters.wrap\n def inner_test():\n \"\"\"If this runs without error, the test has passed.\"\"\"\n pass\n inner_test(user=object())","def test_pressure_increasing_check_all_pass(mocker, pressure_values):\n profile = mocker.patch.object(argortqcpy.profile, \"Profile\")\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\n\n pic = PressureIncreasingCheck(profile, None)\n output = pic.run()\n\n assert np.all(output.get_output_flags_for_property(\"PRES\").data == ArgoQcFlag.GOOD.value)","def value(self) -> bool:","async def assert_await(source, values, exception=None):\n exception_type = type(exception) if exception else ()\n try:\n result = await source\n except StreamEmpty:\n assert values == []\n assert exception is None\n except exception_type as exc:\n assert compare_exceptions(exc, exception)\n else:\n assert result == values[-1]\n assert exception is None","def test_candidatesubr_value(self):\n\n expected_value = (348, 374, 'rmoveto')\n\n self.assertEqual(self.cand_subr.value(), expected_value)","def succeed(self,args):\n code, msg, val = args\n if code != 1:\n raise ROSParamException(msg)\n return val","def test_rarefy_to_list(self):\r\n maker = RarefactionMaker(self.otu_table_fp, 0, 1, 1, 1)\r\n res = maker.rarefy_to_list(include_full=True)\r\n self.assertItemsEqual(res[-1][2].SampleIds, self.otu_table.SampleIds)\r\n self.assertItemsEqual(\r\n res[-1][2].ObservationIds,\r\n self.otu_table.ObservationIds)\r\n self.assertEqual(res[-1][2], self.otu_table)\r\n\r\n sample_value_sum = []\r\n for val in res[1][2].iterSampleData():\r\n sample_value_sum.append(val.sum())\r\n assert_almost_equal(sample_value_sum, [1.0, 1.0])","def test_neg():\n value = -42\n num_a = param.Integer(value=value)\n assert -num_a.value == -value","def test_findXCoordinateFromDirection_up(self):\n actual_result = rules.findXCoordinateFromDirection(1)\n expected_result = 0\n self.assertEqual(actual_result, expected_result)","def over(self):\n return self.result is not None","def test_rmul():\n # Test for reverse multiplication with scalar Rnode object and float value\n x = Rnode(0.11)\n z = 0.5 * x\n\n try:\n assert z.value == x.value * 0.5\n except AssertionError as e:\n print(e)","def pytest_pyfunc_call(pyfuncitem): # type:ignore\n outcome = yield\n try:\n outcome.get_result()\n except InvalidArgument as exc:\n pytest.fail(exc.args[0])","def test_not_left_value_1(self):\n input = (Program([FuncDecl(Id(\"main\"),[],VoidType(),Block([BinaryOp(\"=\",BinaryOp(\"+\",IntLiteral(1),IntLiteral(2)),IntLiteral(3)),Return()]))]))\n expect = \"Not Left Value: BinaryOp(+,IntLiteral(1),IntLiteral(2))\"\n self.assertTrue(TestChecker.test(input,expect,470))","def test_robbins(self):\n c = array([1,2,3,0,1])\n r = robbins(c)\n self.assertEqual(r,2./7)","def test_unchecked_args():\n\n @type_checked\n def _run_test(something:str, something_else):\n assert isinstance(something, str)\n assert isinstance(something_else, bool)\n\n _run_test(1234, True)","def evaluate(self, *args, **kwargs) -> Union[str, int, float, bool]:\n return True","def test_rshift():\n value = 42\n num_a = param.Integer(value=value)\n assert num_a.value == value\n\n new_value = operator.rshift(value, 1)\n num_a.value >>= 1\n assert num_a.value == new_value","def test_02_pass(self):\n if x==1:\n pass","def test_get_sqrrect_length_all_int(self):\n result = get_squarerectangle_type(1, 2, 1, 3)\n self.assertEqual(result, 'invalid')","def test_check_x(self):\n r1 = Rectangle(10, 2)\n self.assertEqual(r1.x, 0)\n\n r2 = Rectangle(2, 10, 6)\n self.assertEqual(r2.x, 6)\n\n r3 = Rectangle(5, 2, 3, 9, 12)\n self.assertEqual(r3.x, 3)\n\n r4 = Rectangle(5, 2, 0, 3, 12)\n self.assertEqual(r4.x, 0)","def test_push_pop(values):\n test_stack = stack.Stack()\n\n for value in values:\n test_stack.push(value)\n\n for expected_value in reversed(values):\n value = test_stack.pop()\n assert value == expected_value\n\n with pytest.raises(stack.StackEmptyError):\n test_stack.pop()","def test_squared_moving_integration_valuechecks(x, window_length):\n from sleepecg._heartbeat_detection import _squared_moving_integration\n with pytest.raises(ValueError):\n _squared_moving_integration(x, window_length)","def _check_support(X: np.ndarray, **kwargs) -> None:\n\n assert (X >= 0).all() & isinteger(\n X\n ), \"x should be greater or equal to 0 and integer.\"","def test_special_RR(self):\n self.check_oneq_special_cases(U3Gate(0.0, 0.1, -0.1).to_matrix(), \"RR\", {})\n self.check_oneq_special_cases(U3Gate(0.0, 0.1, 0.2).to_matrix(), \"RR\", {\"r\": 2})\n self.check_oneq_special_cases(U3Gate(-np.pi, 0.2, 0.0).to_matrix(), \"RR\", {\"r\": 1})\n self.check_oneq_special_cases(U3Gate(np.pi, 0.0, 0.2).to_matrix(), \"RR\", {\"r\": 1})\n self.check_oneq_special_cases(U3Gate(0.1, 0.2, 0.3).to_matrix(), \"RR\", {\"r\": 2})","def rschematic_negative(self, args):\n try:\n schematic = rdata.RSchematic(*args)\n except rdata.RSchematicError as re:\n return True\n raise TestRdataError(\"Instantiaed an RSchematic when it should have failed\")","def _is_no_result(obj: Any) -> bool:\n return obj is NO_RESULT","def bool(x) -> bool:\n pass","def test_negativeyvalue(self):\n Square.reset_objects()\n with self.assertRaises(ValueError) as e:\n s1 = Square(1, 2, -2)\n self.assertEqual(str(e.exception), \"y must be >= 0\")","def testReturn(self):\n\t\tx = BaseAction('x')\n\t\tself.failUnless(x.record() == x)","def test_goal_reached(self):\n board = ss.Board(goal=100)\n assert board.goal_reached(5) is False\n assert board.goal_reached(90) is False\n assert board.goal_reached(100) is True\n\n board = ss.Board()\n assert board.goal_reached(90) is True","def test_pressure_increasing_check_some_bad(mocker, pressure_values, expected):\n profile = mocker.patch.object(argortqcpy.profile, \"Profile\")\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\n\n pic = PressureIncreasingCheck(profile, None)\n output = pic.run()\n\n assert np.all(output.get_output_flags_for_property(\"PRES\").data == expected)","def validate_moves(moves):\n valid_coords = []\n for move in moves:\n if move[0] in cc.VALID_RANKS and move[1] in cc.VALID_RANKS:\n valid_coords.append(True)\n else:\n valid_coords.append(False)\n return tuple(valid_coords)","def test_gt():\n # Test for greater than special method with scalar Rnode object and float value\n x = Rnode(2.0)\n try:\n assert (x > 3) == False\n assert (x > 1) == True\n except AssertionError as e:\n print(e)\n raise AssertionError\n\n # Test for greater than special method with two scalar Rnode object\n a = Rnode(2.0)\n b = Rnode(2.0)\n c = Rnode(1.0)\n d = Rnode(1.0)\n try:\n assert (a > b) == False\n assert (a > c) == True\n assert (a > d) == True\n except AssertionError as e:\n print(e)\n raise AssertionError","def test_add_all_args_less_zero(self):\n try:\n self.assertEqual(add(-7, -11), -18)\n except Exception as error:\n print(error)","def test_validate_on_invalid_value(self):\n args = (0, enums.OpaqueDataType.NONE)\n self.assertRaises(TypeError, objects.OpaqueObject, *args)","def evaluate(self, test_data):\r\n test_results = [(np.argmax(self.feedforward(x)), y)\r\n for (x, y) in test_data]\r\n #print(self.feedforward(test_data[0][0]))\r\n #print(test_data[0][1])\r\n return sum(int(x == y) for (x, y) in test_results)","def test_01_pass(self):\n if x==1:\n pass","def test_01_pass(self):\n if x==1:\n pass","def test_rr_basic(model):\n results = model.fit()\n assert isinstance(results, RCRResults)"],"string":"[\n \"def test_of_with_args(self) -> None:\\n assert Result.of(lambda x: bool(x > 0), 1).unwrap() is True\",\n \"def test_pos():\\n # Test for positive special method with scalar Rnode object\\n x = Rnode(5)\\n z = +x\\n try:\\n assert z.value == 1 * x.value\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\",\n \"def is_lvalue(*args):\\n return _ida_hexrays.is_lvalue(*args)\",\n \"def test_neg():\\n # Test for negation with scalar Rnode object\\n x = Rnode(5.0)\\n z = -x\\n try:\\n assert z.value == -1 * x.value\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\",\n \"def calc_rvalue_type(self, *args):\\n return _ida_hexrays.cfunc_parentee_t_calc_rvalue_type(self, *args)\",\n \"def test_rightHandArgumentImplementsUnequality(self):\\n self.assertFalse(Record(1, 2) != EqualToEverything())\\n self.assertTrue(Record(1, 2) != EqualToNothing())\",\n \"def test_get_squarerect_ltz_all_int(self):\\n result = get_squarerectangle_type(-1, -1, -1, -1)\\n self.assertEqual(result, 'invalid')\",\n \"def test_findXCoordinateFromDirection_right(self):\\n actual_result = rules.findXCoordinateFromDirection(3)\\n expected_result = 2\\n self.assertEqual(actual_result, expected_result)\",\n \"def test_true_is_armstrong(number: int):\\n assert is_armstrong(number)\",\n \"def test_function(my_data):\\n return my_data == 42\",\n \"def check_nondiff_rop(self, y):\\r\\n raised = False\\r\\n try:\\r\\n tmp = tensor.Rop(y, self.x, self.v)\\r\\n except ValueError:\\r\\n raised = True\\r\\n if not raised:\\r\\n self.fail((\\r\\n 'Op did not raise an error even though the function'\\r\\n ' is not differentiable'))\",\n \"def forward(self, x):\\n return self.simple_test(x)\",\n \"def test_get_r():\\n\\n assert get_r(100, 143, 255) == 100\\n assert get_r(100, 143, 255) != 143\\n assert get_r(100, 143, 255) != 255\",\n \"def test_rsub():\\n # Test for reverse subtraction with scalar Rnode object and float value\\n x = Rnode(0.5)\\n z = 0.1 - x\\n try:\\n assert z.value == x.value - 0.1\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\",\n \"def test_positive_value_exists(self):\\n #######################################\\n # Test for True\\n value_to_test = 1\\n self.assertEqual(positive_value_exists(value_to_test), True,\\n \\\"Testing value: {value_to_test}, True expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = 100\\n self.assertEqual(positive_value_exists(value_to_test), True,\\n \\\"Testing value: {value_to_test}, True expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = 'hello'\\n self.assertEqual(positive_value_exists(value_to_test), True,\\n \\\"Testing value: {value_to_test}, True expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = True\\n self.assertEqual(positive_value_exists(value_to_test), True,\\n \\\"Testing value: {value_to_test}, True expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = {\\n 'success': True\\n }\\n self.assertEqual(positive_value_exists(value_to_test), True,\\n \\\"Testing value: {value_to_test}, True expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = [\\n 'success'\\n ]\\n self.assertEqual(positive_value_exists(value_to_test), True,\\n \\\"Testing value: {value_to_test}, True expected\\\".format(value_to_test=value_to_test))\\n\\n #######################################\\n # Test for False\\n value_to_test = 0\\n self.assertEqual(positive_value_exists(value_to_test), False,\\n \\\"Testing value: {value_to_test}, False expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = -1\\n self.assertEqual(positive_value_exists(value_to_test), False,\\n \\\"Testing value: {value_to_test}, False expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = ''\\n self.assertEqual(positive_value_exists(value_to_test), False,\\n \\\"Testing value: {value_to_test}, False expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = '0'\\n self.assertEqual(positive_value_exists(value_to_test), False,\\n \\\"Testing value: {value_to_test}, False expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = False\\n self.assertEqual(positive_value_exists(value_to_test), False,\\n \\\"Testing value: {value_to_test}, False expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = {}\\n self.assertEqual(positive_value_exists(value_to_test), False,\\n \\\"Testing value: {value_to_test}, False expected\\\".format(value_to_test=value_to_test))\\n\\n value_to_test = []\\n self.assertEqual(positive_value_exists(value_to_test), False,\\n \\\"Testing value: {value_to_test}, False expected\\\".format(value_to_test=value_to_test))\",\n \"def test_badxvaluewithbools(self):\\n Rectangle.reset_objects()\\n with self.assertRaises(TypeError) as e:\\n r1 = Square(1, False, 2, 3)\\n self.assertEqual(str(e.exception), 'x must be an integer')\",\n \"def requires_lvalue(self, *args):\\n return _ida_hexrays.cexpr_t_requires_lvalue(self, *args)\",\n \"def test_cdef_return_object(x: object) -> object:\\n if x:\\n return x\\n else:\\n raise RuntimeError()\",\n \"def test_copy_non_bool_error(self):\\n\\n with pytest.raises(ValueError):\\n\\n BaseTransformer(copy=1)\",\n \"def sift_rest(x):\\n return True\",\n \"def valid(rv:Optional[int])->bool:\\n # return False # stub\\n # template from optional\\n if rv is None:\\n return False\\n else:\\n return True\\n \\n \\n\\n\\n start_testing()\",\n \"def check_result(context, expected):\\n assert context.result == expected, \\\"Wrong result: {r} != {e}\\\".format(\\n r=context.result, e=expected\\n )\",\n \"def test_fasle_is_armstrongs(number: int):\\n assert is_armstrong(number) is False\",\n \"def test_pos():\\n value = -42\\n num_a = param.Integer(value=value)\\n assert +num_a.value == +value\",\n \"def validate(self):\\n # rVal = False\\n # return rVal\\n return True\",\n \"def __call__(self): # run test\\n\\n try: # Check if any errors were raised during calling of self.func\\n return abs(self.func(*self.args, **self.kwargs) - self.res) < self._tolerance\\n\\n except IndexError:\\n return False\",\n \"def test_badyvaluewithbools(self):\\n Rectangle.reset_objects()\\n with self.assertRaises(TypeError) as e:\\n r1 = Square(1, 2, True, 3)\\n self.assertEqual(str(e.exception), 'y must be an integer')\",\n \"def _check_returned_tracer(return_val):\\n if (isinstance(return_val, int)):\\n check(return_val)\\n tr = None\\n else:\\n tr, _ = return_val\\n return tr\",\n \"def test_rschematic_negative(self):\\n args_q = [\\n # Invalid string as type\\n (\\\"name\\\", \\\"str\\\", False),\\n # Invalid string tuple for types\\n (\\\"name\\\", (\\\"str\\\", int), False),\\n # Invalid string tuple for types\\n (\\\"name\\\", (\\\"str\\\", int), False),\\n # Invalid string as nullable\\n (\\\"name\\\", str, \\\"False\\\"),\\n # Invalid int as nullable\\n (\\\"name\\\", (str, int), 0),\\n ]\\n for args in args_q:\\n self.rschematic_negative(args)\",\n \"def main() -> None:\\r\\n _: Stage = Stage(background_color='#333')\\r\\n\\r\\n any_value_1: AnyValue = AnyValue(10)\\r\\n any_value_1 = any_value_1 + 10\\r\\n assert_equal(expected=20, actual=any_value_1)\\r\\n\\r\\n any_value_2: AnyValue = AnyValue(20)\\r\\n int_1: Int = Int(10)\\r\\n any_value_2 = any_value_2 - int_1\\r\\n assert_equal(expected=10, actual=any_value_2)\\r\\n\\r\\n any_value_3: AnyValue = AnyValue(10)\\r\\n any_value_3 = any_value_3 * 3\\r\\n assert_equal(expected=30, actual=any_value_3)\\r\\n\\r\\n any_value_4: AnyValue = AnyValue(50)\\r\\n any_value_4 = any_value_4 / 2\\r\\n assert_equal(expected=25, actual=any_value_4)\\r\\n\\r\\n any_value_5: AnyValue = AnyValue(10)\\r\\n any_value_5 = any_value_5 // 3\\r\\n assert_equal(expected=3, actual=any_value_5)\\r\\n\\r\\n any_value_6: AnyValue = AnyValue(20)\\r\\n any_value_6 += 30\\r\\n assert_equal(expected=50, actual=any_value_6)\\r\\n\\r\\n any_value_7: AnyValue = AnyValue(60)\\r\\n any_value_7 -= 25\\r\\n assert_equal(expected=35, actual=(any_value_7))\\r\\n\\r\\n any_value_8: AnyValue = AnyValue(3)\\r\\n any_value_8 *= 10\\r\\n assert_equal(expected=30, actual=any_value_8)\\r\\n\\r\\n any_value_9: AnyValue = AnyValue(20)\\r\\n any_value_9 /= 4\\r\\n assert_equal(expected=5, actual=any_value_9)\\r\\n\\r\\n any_value_10: AnyValue = AnyValue(10)\\r\\n result: Boolean = any_value_10 == 10\\r\\n assert_true(result)\\r\\n result = any_value_10 == 11\\r\\n assert_false(result)\\r\\n\\r\\n result = any_value_10 != 11\\r\\n assert_true(result)\\r\\n result = any_value_10 != 10\\r\\n assert_false(result)\\r\\n\\r\\n result = any_value_10 < 11\\r\\n assert_true(result)\\r\\n result = any_value_10 < 10\\r\\n assert_false(result)\\r\\n\\r\\n result = any_value_10 <= 10\\r\\n assert_true(result)\\r\\n result = any_value_10 <= 9\\r\\n assert_false(result)\\r\\n\\r\\n result = any_value_10 > 9\\r\\n assert_true(result)\\r\\n result = any_value_10 > 10\\r\\n assert_false(result)\\r\\n\\r\\n result = any_value_10 >= 10\\r\\n assert_true(result)\\r\\n result = any_value_10 >= 11\\r\\n assert_false(result)\\r\\n\\r\\n save_overall_html(dest_dir_path=_DEST_DIR_PATH)\",\n \"def test_r():\\n y, x = np.indices((10,20))\\n\\n default_use_numexpr = accel_math._USE_NUMEXPR\\n\\n accel_math._USE_NUMEXPR = True\\n r1 = accel_math._r(x,y)\\n\\n accel_math._USE_NUMEXPR = False\\n r2 = accel_math._r(x,y)\\n\\n np.testing.assert_almost_equal(r1,r2)\\n\\n accel_math._USE_NUMEXPR = default_use_numexpr\",\n \"def test_running_sum_multi_positives(self):\\n\\n argument = [4,2,3,6]\\n expected = [4,6,9,15]\\n sums.running_sum(argument)\\n self.assertEqual(expected,argument,\\\"the list contains only positive values\\\")\",\n \"def assert_positive(x):\\n \\n assert(all(x) >= 0)\",\n \"def test_is_rock_valid():\\n\\n\\tassert game.is_val('rock') is True # muze byt jenom 'True', vsechny True stejne ID i False\",\n \"def testfn(arg):\\n if arg == 42:\\n raise ValueError('Oh noes')\\n return arg\",\n \"def test_rodrigues(self):\\n quat = np.random.rand(4)\\n quat = quaternion.from_float_array(quat / np.linalg.norm(quat))\\n\\n r_vec = quaternion.as_rotation_vector(quat)\\n r_mat_targ = quaternion.as_rotation_matrix(quat)\\n\\n r_norm = np.linalg.norm(r_vec)\\n r_axis = r_vec / r_norm\\n r = rodrigues(r_axis, r_norm)\\n self.assertTrue(np.allclose(r, r_mat_targ, rtol=1e-5, atol=1e-5))\",\n \"def test_regular_result(self):\\n passthrough = self.make_wrapped_function()\\n result = passthrough(123)\\n self.assertEqual(result, 123)\",\n \"def test_peek_single(values, expected_value):\\n test_stack = stack.Stack()\\n for value in values:\\n test_stack.push(value)\\n\\n returned_value = test_stack.peek()\\n\\n assert returned_value == expected_value\\n\\n for value in reversed(values):\\n assert test_stack.pop() == value\",\n \"def test_radd():\\n # Test for reverse addition with scalar Rnode object and float value\\n x = Rnode(0.11)\\n z = 0.5 + x\\n z.grad_value = 1.0\\n\\n try:\\n assert z.value == x.value + 0.5\\n except AssertionError as e:\\n print(e)\",\n \"def test_bit_rscan_value_not_found(self):\\n value = False\\n ops = [bitwise_operations.bit_rscan(self.five_255_bin, 0, 40, value)]\\n\\n expected_value = -1\\n _, _, result = self.as_connection.operate(self.test_key, ops)\\n assert result[self.five_255_bin] == expected_value\",\n \"def test_unary_op_support():\\n check_peval_expression(\\\"+(2)\\\", {}, \\\"2\\\", fully_evaluated=True, expected_value=2)\\n check_peval_expression(\\\"-(-3)\\\", {}, \\\"3\\\", fully_evaluated=True, expected_value=3)\\n check_peval_expression_bool(\\\"not 0\\\", {}, True)\\n check_peval_expression(\\\"~(-4)\\\", {}, \\\"3\\\", fully_evaluated=True, expected_value=3)\",\n \"def test_right_turn_true(self):\\n point1 = np.array([1, 1])\\n point2 = np.array([2, 2])\\n point3 = np.array([3, 1])\\n\\n right_angle1 = convex_hull.right_turn(point1, point2, point3) # first right turn angle (boolean)\\n right_angle2 = convex_hull.right_turn(point1, point3, point2) # second right turn angle (boolean)\\n\\n self.assertTrue(right_angle1 and not right_angle2)\",\n \"def testIsNullFalseAgain(self):\\n val = is_null(5) \\n self.assertFalse(val)\",\n \"def check(self):\\n raise NotImplementedError()\\n #return (value, **kw)\",\n \"def test_le():\\n # Test for less than or equal to special method with scalar Rnode object and float value\\n x = Rnode(2.0)\\n try:\\n assert (x <= 3) == True\\n assert (x <= 2) == True\\n assert (x <= 1) == False\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\\n\\n # Test for less than or equal to special method with two scalar Rnode object\\n a = Rnode(2.0)\\n b = Rnode(2.0)\\n c = Rnode(1.0)\\n d = Rnode(1.0)\\n try:\\n assert (a <= b) == True\\n assert (a <= c) == False\\n assert (a <= d) == False\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\",\n \"def any(self) -> int:\",\n \"def any(self) -> int:\",\n \"def test_absolute_truth():\\n assert True\",\n \"def obj_func(x):\\n assert(False)\",\n \"def test_03_pass(self):\\n if x==1:\\n pass\",\n \"def test_rightHandArgumentImplementsEquality(self):\\n self.assertTrue(Record(1, 2) == EqualToEverything())\\n self.assertFalse(Record(1, 2) == EqualToNothing())\",\n \"def not_equals_success_func(target, result):\\n if result is None:\\n return False\\n return target != result\",\n \"def validate(self):\\n\\t\\trVal = False\\n\\t\\t#return rVal\\n\\t\\treturn True\",\n \"def test_return_value(self):\\n self.assertEqual(self.r0.from_json_string(self.string), self.d)\",\n \"def test_evaluates_correctly_true(self, test_generator):\\n self.assertTrue(test_generator())\\n self.assertTrue(bool(test_generator()))\\n if not test_generator():\\n self.fail(\\\"did not evaluate true\\\")\",\n \"def should_return(self, value):\\n \\n return False\",\n \"def test04_boolean_operator(self):\\n\\n import _cppyy\\n number = _cppyy.gbl.number\\n\\n n = number(20)\\n assert n\\n\\n n = number(0)\\n assert not n\",\n \"def test_is_empty_single(values, expected_result):\\n test_stack = stack.Stack()\\n for value in values:\\n test_stack.push(value)\\n\\n result = test_stack.is_empty()\\n\\n assert result == expected_result\",\n \"def __call__(self, observation):\\n delta = super(BinarizedScalarDeltaReward, self).__call__(observation)\\n # Validate that delta is a scalar.\\n _ = float(delta)\\n if delta == 0:\\n return None\\n return int(delta > 0)\",\n \"def test_isACaptureP_bad_direction(self, mock_captureHelper):\\n mock_captureHelper.return_value = True\\n rules_obj = rules.Rules(test_mode=True)\\n board = gamenode.GameNode()\\n foxCoordinate = coordinate.Coordinate(3, 3)\\n direction = 20\\n actual_result = rules_obj.isACaptureP(board, foxCoordinate, direction)\\n expected_result = False\\n self.assertEqual(actual_result, expected_result)\",\n \"def does_it_return(func, args):\\n \\n if args is None:\\n assert(func() is not None)\\n else:\\n assert(func(*args) is not None)\",\n \"def test_no_user_argument_but_passed(self):\\n @converters.wrap\\n def inner_test():\\n \\\"\\\"\\\"If this runs without error, the test has passed.\\\"\\\"\\\"\\n pass\\n inner_test(user=object())\",\n \"def test_pressure_increasing_check_all_pass(mocker, pressure_values):\\n profile = mocker.patch.object(argortqcpy.profile, \\\"Profile\\\")\\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\\n\\n pic = PressureIncreasingCheck(profile, None)\\n output = pic.run()\\n\\n assert np.all(output.get_output_flags_for_property(\\\"PRES\\\").data == ArgoQcFlag.GOOD.value)\",\n \"def value(self) -> bool:\",\n \"async def assert_await(source, values, exception=None):\\n exception_type = type(exception) if exception else ()\\n try:\\n result = await source\\n except StreamEmpty:\\n assert values == []\\n assert exception is None\\n except exception_type as exc:\\n assert compare_exceptions(exc, exception)\\n else:\\n assert result == values[-1]\\n assert exception is None\",\n \"def test_candidatesubr_value(self):\\n\\n expected_value = (348, 374, 'rmoveto')\\n\\n self.assertEqual(self.cand_subr.value(), expected_value)\",\n \"def succeed(self,args):\\n code, msg, val = args\\n if code != 1:\\n raise ROSParamException(msg)\\n return val\",\n \"def test_rarefy_to_list(self):\\r\\n maker = RarefactionMaker(self.otu_table_fp, 0, 1, 1, 1)\\r\\n res = maker.rarefy_to_list(include_full=True)\\r\\n self.assertItemsEqual(res[-1][2].SampleIds, self.otu_table.SampleIds)\\r\\n self.assertItemsEqual(\\r\\n res[-1][2].ObservationIds,\\r\\n self.otu_table.ObservationIds)\\r\\n self.assertEqual(res[-1][2], self.otu_table)\\r\\n\\r\\n sample_value_sum = []\\r\\n for val in res[1][2].iterSampleData():\\r\\n sample_value_sum.append(val.sum())\\r\\n assert_almost_equal(sample_value_sum, [1.0, 1.0])\",\n \"def test_neg():\\n value = -42\\n num_a = param.Integer(value=value)\\n assert -num_a.value == -value\",\n \"def test_findXCoordinateFromDirection_up(self):\\n actual_result = rules.findXCoordinateFromDirection(1)\\n expected_result = 0\\n self.assertEqual(actual_result, expected_result)\",\n \"def over(self):\\n return self.result is not None\",\n \"def test_rmul():\\n # Test for reverse multiplication with scalar Rnode object and float value\\n x = Rnode(0.11)\\n z = 0.5 * x\\n\\n try:\\n assert z.value == x.value * 0.5\\n except AssertionError as e:\\n print(e)\",\n \"def pytest_pyfunc_call(pyfuncitem): # type:ignore\\n outcome = yield\\n try:\\n outcome.get_result()\\n except InvalidArgument as exc:\\n pytest.fail(exc.args[0])\",\n \"def test_not_left_value_1(self):\\n input = (Program([FuncDecl(Id(\\\"main\\\"),[],VoidType(),Block([BinaryOp(\\\"=\\\",BinaryOp(\\\"+\\\",IntLiteral(1),IntLiteral(2)),IntLiteral(3)),Return()]))]))\\n expect = \\\"Not Left Value: BinaryOp(+,IntLiteral(1),IntLiteral(2))\\\"\\n self.assertTrue(TestChecker.test(input,expect,470))\",\n \"def test_robbins(self):\\n c = array([1,2,3,0,1])\\n r = robbins(c)\\n self.assertEqual(r,2./7)\",\n \"def test_unchecked_args():\\n\\n @type_checked\\n def _run_test(something:str, something_else):\\n assert isinstance(something, str)\\n assert isinstance(something_else, bool)\\n\\n _run_test(1234, True)\",\n \"def evaluate(self, *args, **kwargs) -> Union[str, int, float, bool]:\\n return True\",\n \"def test_rshift():\\n value = 42\\n num_a = param.Integer(value=value)\\n assert num_a.value == value\\n\\n new_value = operator.rshift(value, 1)\\n num_a.value >>= 1\\n assert num_a.value == new_value\",\n \"def test_02_pass(self):\\n if x==1:\\n pass\",\n \"def test_get_sqrrect_length_all_int(self):\\n result = get_squarerectangle_type(1, 2, 1, 3)\\n self.assertEqual(result, 'invalid')\",\n \"def test_check_x(self):\\n r1 = Rectangle(10, 2)\\n self.assertEqual(r1.x, 0)\\n\\n r2 = Rectangle(2, 10, 6)\\n self.assertEqual(r2.x, 6)\\n\\n r3 = Rectangle(5, 2, 3, 9, 12)\\n self.assertEqual(r3.x, 3)\\n\\n r4 = Rectangle(5, 2, 0, 3, 12)\\n self.assertEqual(r4.x, 0)\",\n \"def test_push_pop(values):\\n test_stack = stack.Stack()\\n\\n for value in values:\\n test_stack.push(value)\\n\\n for expected_value in reversed(values):\\n value = test_stack.pop()\\n assert value == expected_value\\n\\n with pytest.raises(stack.StackEmptyError):\\n test_stack.pop()\",\n \"def test_squared_moving_integration_valuechecks(x, window_length):\\n from sleepecg._heartbeat_detection import _squared_moving_integration\\n with pytest.raises(ValueError):\\n _squared_moving_integration(x, window_length)\",\n \"def _check_support(X: np.ndarray, **kwargs) -> None:\\n\\n assert (X >= 0).all() & isinteger(\\n X\\n ), \\\"x should be greater or equal to 0 and integer.\\\"\",\n \"def test_special_RR(self):\\n self.check_oneq_special_cases(U3Gate(0.0, 0.1, -0.1).to_matrix(), \\\"RR\\\", {})\\n self.check_oneq_special_cases(U3Gate(0.0, 0.1, 0.2).to_matrix(), \\\"RR\\\", {\\\"r\\\": 2})\\n self.check_oneq_special_cases(U3Gate(-np.pi, 0.2, 0.0).to_matrix(), \\\"RR\\\", {\\\"r\\\": 1})\\n self.check_oneq_special_cases(U3Gate(np.pi, 0.0, 0.2).to_matrix(), \\\"RR\\\", {\\\"r\\\": 1})\\n self.check_oneq_special_cases(U3Gate(0.1, 0.2, 0.3).to_matrix(), \\\"RR\\\", {\\\"r\\\": 2})\",\n \"def rschematic_negative(self, args):\\n try:\\n schematic = rdata.RSchematic(*args)\\n except rdata.RSchematicError as re:\\n return True\\n raise TestRdataError(\\\"Instantiaed an RSchematic when it should have failed\\\")\",\n \"def _is_no_result(obj: Any) -> bool:\\n return obj is NO_RESULT\",\n \"def bool(x) -> bool:\\n pass\",\n \"def test_negativeyvalue(self):\\n Square.reset_objects()\\n with self.assertRaises(ValueError) as e:\\n s1 = Square(1, 2, -2)\\n self.assertEqual(str(e.exception), \\\"y must be >= 0\\\")\",\n \"def testReturn(self):\\n\\t\\tx = BaseAction('x')\\n\\t\\tself.failUnless(x.record() == x)\",\n \"def test_goal_reached(self):\\n board = ss.Board(goal=100)\\n assert board.goal_reached(5) is False\\n assert board.goal_reached(90) is False\\n assert board.goal_reached(100) is True\\n\\n board = ss.Board()\\n assert board.goal_reached(90) is True\",\n \"def test_pressure_increasing_check_some_bad(mocker, pressure_values, expected):\\n profile = mocker.patch.object(argortqcpy.profile, \\\"Profile\\\")\\n profile.get_property_data = mocker.Mock(return_value=ma.masked_array(pressure_values))\\n\\n pic = PressureIncreasingCheck(profile, None)\\n output = pic.run()\\n\\n assert np.all(output.get_output_flags_for_property(\\\"PRES\\\").data == expected)\",\n \"def validate_moves(moves):\\n valid_coords = []\\n for move in moves:\\n if move[0] in cc.VALID_RANKS and move[1] in cc.VALID_RANKS:\\n valid_coords.append(True)\\n else:\\n valid_coords.append(False)\\n return tuple(valid_coords)\",\n \"def test_gt():\\n # Test for greater than special method with scalar Rnode object and float value\\n x = Rnode(2.0)\\n try:\\n assert (x > 3) == False\\n assert (x > 1) == True\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\\n\\n # Test for greater than special method with two scalar Rnode object\\n a = Rnode(2.0)\\n b = Rnode(2.0)\\n c = Rnode(1.0)\\n d = Rnode(1.0)\\n try:\\n assert (a > b) == False\\n assert (a > c) == True\\n assert (a > d) == True\\n except AssertionError as e:\\n print(e)\\n raise AssertionError\",\n \"def test_add_all_args_less_zero(self):\\n try:\\n self.assertEqual(add(-7, -11), -18)\\n except Exception as error:\\n print(error)\",\n \"def test_validate_on_invalid_value(self):\\n args = (0, enums.OpaqueDataType.NONE)\\n self.assertRaises(TypeError, objects.OpaqueObject, *args)\",\n \"def evaluate(self, test_data):\\r\\n test_results = [(np.argmax(self.feedforward(x)), y)\\r\\n for (x, y) in test_data]\\r\\n #print(self.feedforward(test_data[0][0]))\\r\\n #print(test_data[0][1])\\r\\n return sum(int(x == y) for (x, y) in test_results)\",\n \"def test_01_pass(self):\\n if x==1:\\n pass\",\n \"def test_01_pass(self):\\n if x==1:\\n pass\",\n \"def test_rr_basic(model):\\n results = model.fit()\\n assert isinstance(results, RCRResults)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.56166077","0.52924556","0.49803373","0.49245155","0.49001187","0.48983425","0.48789844","0.48493248","0.48468444","0.48117045","0.4811189","0.48032174","0.480225","0.47236064","0.4706626","0.47004962","0.46803305","0.46701148","0.4667749","0.46482965","0.46353322","0.46301582","0.4622674","0.46019837","0.4595487","0.45947573","0.45834392","0.4566247","0.45520562","0.45411524","0.45275855","0.45230988","0.45192015","0.45188317","0.45163125","0.45121044","0.4504304","0.44993874","0.44816616","0.44769722","0.44668952","0.44659308","0.44554466","0.44530997","0.44525644","0.4446501","0.4446501","0.44375202","0.44349825","0.44195622","0.44166487","0.44106454","0.4402607","0.44014385","0.43934256","0.43816873","0.4374866","0.4365385","0.4363924","0.43626598","0.43573302","0.4357163","0.43498653","0.4349187","0.43450284","0.43445438","0.43426973","0.4335098","0.4334327","0.43309125","0.43256918","0.43211275","0.43201858","0.43186992","0.43120098","0.43118355","0.43108383","0.4307131","0.4304578","0.4301089","0.4296042","0.4294518","0.42939854","0.42914292","0.42905998","0.42812797","0.42802626","0.42795113","0.4279012","0.42781976","0.42772993","0.42748535","0.42655265","0.42645347","0.42632556","0.42631936","0.42629024","0.42619365","0.42619365","0.42618668"],"string":"[\n \"0.56166077\",\n \"0.52924556\",\n \"0.49803373\",\n \"0.49245155\",\n \"0.49001187\",\n \"0.48983425\",\n \"0.48789844\",\n \"0.48493248\",\n \"0.48468444\",\n \"0.48117045\",\n \"0.4811189\",\n \"0.48032174\",\n \"0.480225\",\n \"0.47236064\",\n \"0.4706626\",\n \"0.47004962\",\n \"0.46803305\",\n \"0.46701148\",\n \"0.4667749\",\n \"0.46482965\",\n \"0.46353322\",\n \"0.46301582\",\n \"0.4622674\",\n \"0.46019837\",\n \"0.4595487\",\n \"0.45947573\",\n \"0.45834392\",\n \"0.4566247\",\n \"0.45520562\",\n \"0.45411524\",\n \"0.45275855\",\n \"0.45230988\",\n \"0.45192015\",\n \"0.45188317\",\n \"0.45163125\",\n \"0.45121044\",\n \"0.4504304\",\n \"0.44993874\",\n \"0.44816616\",\n \"0.44769722\",\n \"0.44668952\",\n \"0.44659308\",\n \"0.44554466\",\n \"0.44530997\",\n \"0.44525644\",\n \"0.4446501\",\n \"0.4446501\",\n \"0.44375202\",\n \"0.44349825\",\n \"0.44195622\",\n \"0.44166487\",\n \"0.44106454\",\n \"0.4402607\",\n \"0.44014385\",\n \"0.43934256\",\n \"0.43816873\",\n \"0.4374866\",\n \"0.4365385\",\n \"0.4363924\",\n \"0.43626598\",\n \"0.43573302\",\n \"0.4357163\",\n \"0.43498653\",\n \"0.4349187\",\n \"0.43450284\",\n \"0.43445438\",\n \"0.43426973\",\n \"0.4335098\",\n \"0.4334327\",\n \"0.43309125\",\n \"0.43256918\",\n \"0.43211275\",\n \"0.43201858\",\n \"0.43186992\",\n \"0.43120098\",\n \"0.43118355\",\n \"0.43108383\",\n \"0.4307131\",\n \"0.4304578\",\n \"0.4301089\",\n \"0.4296042\",\n \"0.4294518\",\n \"0.42939854\",\n \"0.42914292\",\n \"0.42905998\",\n \"0.42812797\",\n \"0.42802626\",\n \"0.42795113\",\n \"0.4279012\",\n \"0.42781976\",\n \"0.42772993\",\n \"0.42748535\",\n \"0.42655265\",\n \"0.42645347\",\n \"0.42632556\",\n \"0.42631936\",\n \"0.42629024\",\n \"0.42619365\",\n \"0.42619365\",\n \"0.42618668\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4604436"},"document_rank":{"kind":"string","value":"23"}}},{"rowIdx":86095,"cells":{"query":{"kind":"string","value":"Measure RMSE^2 in real and reciprocal space. Returns"},"document":{"kind":"string","value":"def run_rmse_check(self):\n\n # Shift the intensities to compare\n obs = self.obs.data - self.obs.data.mean()\n exp = self.exp.data - self.exp.data.mean()\n\n # Experimental RMSE2 in real space\n rmse_real = (obs - exp)\n rmse_real = rmse_real**2\n\n # Experimental RMSE2 in reciprocal space\n ftdiff = np.fft.fft2(obs.data,norm='ortho') - np.fft.fft2(exp.data,norm='ortho')\n rmse_fourier = np.real(np.abs(ftdiff)**2.)\n\n # Return\n rmse_ij = self.obs.deepcopy()\n rmse_ij.data = rmse_real\n\n rmse_kl = ModifiedImage(rmse_fourier)\n return rmse_ij, rmse_kl"},"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 compute_RMSE(e):\n \"\"\"Corresponds to sqrt(2*MSE)\"\"\"\n \n return np.sqrt(2*compute_MSE(e))","def rrse(self) -> float:\n return float(np.sqrt(self.rse()))","def measure_rmse(self):\n try:\n assert self.residuals_forecast is not None\n except AssertionError:\n self._uvts_cls_logger.exception(\"AssertionError occurred, Cannot compute RMSE! Check your object mode\")\n\n self.rmse = np.sqrt(sum(np.square(self.residuals_forecast)) / len(self.residuals_forecast))\n \"\"\"\n if self._mode == 'test':\n self.rmse_test = self.rmse\n elif self._mode == 'test and validate':\n self.rmse_val = self.rmse - self.rmse_test\n elif self._mode == 'validate':\n self.rmse_val = self.rmse\n \"\"\"","def nrmse(self) -> float:\n return float(self.rmse() / (np.max(self.true) - np.min(self.true)))","def rsr(self) -> float:\n return float(self.rmse() / np.std(self.true))","def rmse (lmse) :\n return np.sqrt(2*lmse)","def rmse(actual, predicted):\n rms = (actual-predicted)**2\n\n # Returning the sqaure root of the root mean square\n return float(np.sqrt(rms.mean()))","def relative_rmse(self) -> float:\n rrmse = self.rmse() / np.mean(self.true)\n return float(rrmse)","def irmse(self) -> float:\n # Getting the gradient of the observed data\n obs_len = self.true.size\n obs_grad = self.true[1:obs_len] - self.true[0:obs_len - 1]\n\n # Standard deviation of the gradient\n obs_grad_std = np.std(obs_grad, ddof=1)\n\n # Divide RMSE by the standard deviation of the gradient of the observed data\n return float(self.rmse() / obs_grad_std)","def RMSE(obs, sim):\n obs = obs.flatten()\n sim = sim.flatten()\n\n return np.sqrt(np.mean((obs - sim) ** 2))","def rmse(self, weights=None) -> float:\n return sqrt(np.average((self.true - self.predicted) ** 2, axis=0, weights=weights))","def rmse(self):\n y_pred, y_true = self._finalize_labels_and_prediction()\n\n return np.sqrt(F.mse_loss(y_pred, y_true).cpu().item())","def rmse(self):\n y_pred, y_true = self._finalize_labels_and_prediction()\n\n return np.sqrt(F.mse_loss(y_pred, y_true).cpu().item())","def get_rmse(self, y_true, y_pred):\r\n return np.sqrt(np.mean((np.array(y_true) - np.array(y_pred)) ** 2))","def _compute_rmse(self, data):\n actual = data.rating.values\n pred = self._predict_all(data)\n rmse = np.sqrt(np.sum((actual - pred) **2) /len(pred))\n return rmse","def _calc_r2(self):\n sse = np.sum((self.data.y - self.predict(self.data.x))**2)\n sst = np.sum((self.data.y - self.data.y.mean())**2)\n return (1. - sse/sst)","def evaluate_rmse(y_true, y_pred):\n\n mse_eval = mean_squared_error(y_true, y_pred)\n\n rmse_eval = np.sqrt(mse_eval)\n\n return rmse_eval","def rmse(a,b):\n \n ### Import modules\n import numpy as np\n \n ### Calculate RMSE\n rmse_stat = np.sqrt(np.mean((a - b)**2))\n \n return rmse_stat","def rmse(self, X, y) -> float:\n return np.sqrt(np.sum(self.l2_error(X, y)))","def rmse(y_preds: ndarray, y_actual: ndarray) -> float:\n\n return np.sqrt(np.mean(np.power(y_preds - y_actual, 2)))","def RMSE(actual, noisy):\n # print len(actual)\n # print len(noisy)\n tmp = mean_squared_error(actual, noisy)\n # print \"Tmp\", tmp\n return math.sqrt(float(tmp))\n\n # noisy_vals = []\n # actual_vals = []\n # print len(actual), actual\n # print len(noisy), noisy\n # for lid in noisy.keys():\n # noisy_vals.append(noisy.get(lid))\n # if not actual.has_key(lid):\n # print lid\n # actual_vals.append(actual.get(lid))\n\n # print len(actual_vals), actual_vals\n # print len(noisy_vals), noisy_vals","def rmse(self):\n return (self.model_error()**2).mean()**.5","def compute_RMSE(true_val, predicted_val, p_output=True) -> float:\n from sklearn.metrics import mean_squared_error\n rms = np.sqrt(mean_squared_error(np.array(true_val), predicted_val))\n if p_output:\n print('RMSE: {0}'.format(rms))\n return rms","def rms_error(self, X, y) :\n ### ========== TODO : START ========== ###\n # part h: compute RMSE\n n, d = X.shape\n error = np.sqrt(self.cost(X,y)/n)\n ### ========== TODO : END ========== ###\n return error","def rmse(self):\n lam = self.lam()\n weights = lam / lam.sum()\n weighted_var = self.var() * weights\n rmse = np.sqrt(weighted_var.sum())\n return rmse","def getRMSE(image1, image2):\n im1 = readImage(image1, grayscale=False)\n im2 = readImage(image2, grayscale=False)\n return np.sqrt( ((im1 - im2)**2).mean() )","def r2(self) -> float:\n zx = (self.true - np.mean(self.true)) / np.std(self.true, ddof=1)\n zy = (self.predicted - np.mean(self.predicted)) / np.std(self.predicted, ddof=1)\n r = np.sum(zx * zy) / (len(self.true) - 1)\n return float(r ** 2)","def root_mean_square_error(y_real, y_pred):\n y_real, y_pred = check_arrays(y_real, y_pred)\n\n dim = y_real.shape[0]\n\n solution = np.zeros(dim)\n solution = solution.astype(np.float32)\n \n mod = SourceModule(\"\"\"\n #include <math.h>\n \n __global__ void rmse(int *x, int *y, float *solution, int dim) {\n int idx = threadIdx.x;\n solution[idx] = pow((x[idx*2] - y[idx*2]) * 1.0, 2);\n }\n \"\"\")\n\n func = mod.get_function('rmse')\n func(drv.In(y_real), drv.In(y_pred), drv.Out(solution), np.int32(dim), block=(dim, 1, 1))\n\n return np.sqrt(np.sum(solution) / dim)","def calc_rmse(y: np.ndarray, y_hat: np.ndarray) -> float:\n return np.sqrt(np.mean((y - y_hat)**2))","def _rsq(self):\n return self._ss_reg / self._ss_tot","def RMSE(observed: np.ndarray, targets: np.ndarray) -> np.float64:\n\treturn np.sqrt(np.mean((observed-targets)**2))","def rmse(sim, obs):\n sim = np.asarray(sim)\n obs = np.asarray(obs)\n obs, sim = remove_nans(obs, sim)\n\n return np.sqrt(np.mean((sim - obs)**2))","def pseudo_r2(self):\n y_reg = self.time_series(len(self.data))\n SSres = ((self.data - y_reg)**2).sum()\n SStot = ((self.data - self.data.mean())**2).sum()\n return 1 - SSres/SStot","def rmse(x1, x2, axis=0):\n x1 = np.asanyarray(x1)\n x2 = np.asanyarray(x2)\n return np.sqrt(mse(x1, x2, axis=axis))","def r2(y: np.ndarray, y_hat: np.ndarray) -> float:\n n = y.shape[0]\n sse = n * mse(y, y_hat)\n y_mean = np.mean(y)\n sst = np.sum((y - y_mean)**2)\n r2_value = 1 - sse / sst\n return r2_value","def rmse(actual: np.ndarray, predicted: np.ndarray):\n return np.sqrt(np.mean(np.square(_error(actual, predicted))))","def rmse(y_true, y_pred):\n\treturn backend.sqrt(backend.mean(backend.square(y_pred - y_true), axis=-1))","def rmse(sim, obs, dim=\"time\"):\n rmse = np.sqrt(mse(sim, obs, dim=dim))\n rmse.name = \"rmse\"\n return rmse","def rmse(y_true, y_pred):\n return backend.sqrt(backend.mean(backend.square(y_pred - y_true), axis=-1))","def rmse(y_true: np.ndarray, y_pred: np.ndarray):\n return np.sqrt(np.mean(np.power(y_true - y_pred, 2)))","def rmse(y_true, y_pred):\n return np.sqrt(metrics.mean_squared_error(y_true, y_pred))","def ivrmse(self):\n return (self.model_error_iv()**2).mean()**.5","def rmse(X, Y):\n\n assert X.shape == Y.shape\n\n N = X.shape[0]\n\n if N < 9:\n print(\"Not enough points. {} datapoints given. At least 9 is required\".format(N))\n return\n\n diff = X - Y\n diff = diff**2\n rmse = np.sqrt(diff.mean())\n\n le = rmse * (1.0 - np.sqrt(1-1.96*np.sqrt(2.0)/np.sqrt(N-1)))\n ue = rmse * (np.sqrt(1 + 1.96*np.sqrt(2.0)/np.sqrt(N-1))-1)\n\n return rmse, le, ue","def rmse_calc(arr1, arr2):\n assert arr1.shape==arr2.shape\n \n return np.sqrt(np.mean((arr2-arr1)**2))","def RMSE(y,yhat):\r\n return(np.sqrt(MSE(y,yhat)))","def nrmse_mean(self) -> float:\n return float(self.rmse() / np.mean(self.true))","def rrse(x, y):\n return rse(x, y) ** .5","def rmse(self, tmin=None, tmax=None):\n res = self.ml.residuals(tmin=tmin, tmax=tmax)\n N = res.size\n return np.sqrt(sum(res ** 2) / N)","def calc_error(y_real, y_pred):\n if len(y_real) > 0:\n curr_err = rmse(y_pred, y_real)\n else:\n curr_err = np.nan\n return curr_err","def rmse(predicted, actual):\n #maybe make some assertions, assume have same length & in right order\n interm_total = 0\n for i in range(len(predicted)):\n interm_total += (predicted[i] - actual[i]) ** 2\n return sqrt(interm_total / len(predicted))","def get_rmsse(self, valid_preds) -> pd.Series:\n\n score = ((self.valid_series - valid_preds) ** 2).mean(axis = 1)\n rmsse = (score / self.scale).map(np.sqrt)\n\n return rmsse","def computeRmse(model, data, n):\n predictions = model.predictAll(data.map(lambda x: (x[0], x[1])))\n predictionsAndRatings = predictions.map(lambda x: ((x[0], x[1]), x[2])) \\\n .join(data.map(lambda x: ((x[0], x[1]), x[2]))) \\\n .values()\n return sqrt(predictionsAndRatings.map(lambda x: (x[0] - x[1]) ** 2).reduce(add) / float(n))","def rmse_from_mse (mse):\n return np.sqrt(2*mse)","def calc_rmse(data1, data2):\n num_users = len(data1)\n\n SE = 0 #the accumulated Squared Error\n num_total = 0 #the accumulated number of ratings evaluated\n for i in range(num_users):\n data1_dict = dict(data1[i])\n for movie, rating2 in data2[i]:\n #Make one of the datasets into a dictionary to make the search more efficient\n rating1 = data1_dict.get(movie, -1)\n SE += (rating1-rating2)**2\n num_total += 1\n\n if rating1 == -1:\n print('Could not find rating for movie %i at user %i in data1'%(movie, i))\n rmse = np.sqrt(SE/num_total)\n return rmse","def calc_nrmse(y: np.ndarray, y_hat: np.ndarray) -> float:\n pass","def rmse(x, y):\n return mse(x, y) ** .5","def RMSE(self, y_true, y_pred):\n try:\n l = y_true.shape[1]\n except:\n y_true.shape += (1,) # avoiding (l,) shape problem\n y_pred.shape += (1,) # avoiding (l,) shape problem\n l = 1\n\n rmse = np.zeros(l)\n\n for i in range(l):\n actual, forecast = self.filter(y_true[:,i],y_pred[:,i])\n rmse[i] = np.sqrt(np.mean((actual - forecast) ** 2))\n\n self.rmse = rmse\n return rmse","def rmse_metric(actual, predicted):\r\n sum_error = 0.0\r\n for i in range(len(actual)):\r\n prediction_error = predicted[i] - actual[i]\r\n sum_error += (prediction_error ** 2)\r\n mean_error = sum_error / float(len(actual))\r\n return sqrt(mean_error)","def computeRmse(model, data, n):\n print \"RESULT_data:%s \" % ((data.map(lambda x: (x[0], x[1]))).take(50))\n predictions1 = model.predictAll(data.map(lambda x: (x[0], x[1])))\n print \"RESULT1: %s\" % predictions1\n predictionsAndRatings = predictions1.map(lambda x: ((x[0], x[1]), x[2])) \\\n .join(data.map(lambda x: ((x[0], x[1]), x[2]))) \\\n .values()\n #print \"RESULT2: %s\" % predictions1.take(11)\n return sqrt(predictionsAndRatings.map(lambda x: (x[0] - x[1]) ** 2).reduce(add) / float(n))","def nrmse_range(self) -> float:\n\n return float(self.rmse() / (np.max(self.true) - np.min(self.true)))","def rmse(s,o):\n s,o = filter_nan(s,o)\n return np.sqrt(np.mean((s-o)**2))","def felm_rmse(y, X, weights, y_test, X_test):\n # Fit model and get predicted values of test data\n mod = sm.WLS(y, X, weights=weights).fit()\n pred = mod.predict(X_test)\n\n #Get residuals from test data\n res = (y_test[:] - pred.values)\n\n # Calculate ttest to check that residuals from test and train are independent\n t_stat, p_val = stats.ttest_ind(mod.resid, res, equal_var=False)\n\n # Return RMSE and t-stat from ttest\n return (np.sqrt(np.mean(res**2)), t_stat)","def mse_r2(true, predicted):\n # Reshaping set of images\n # n_imgs, nx, ny = true.shape\n # true = np.reshape(true, (n_imgs, nx*ny))\n # predicted = np.reshape(predicted, (n_imgs, nx*ny))\n nx = 33\n ny = 33\n\n # Compute MSE\n se = np.sum((true - predicted)**2, axis=1)\n mse = se*(nx*ny)**-1\n\n # Compute R squared\n mean = np.mean(true, axis=1)\n r2 = 1 - se*np.sum((true - np.expand_dims(mean, axis=1))**2, axis=1)**-1\n\n return mse, r2","def err_rmse(x1, x2, axis=0):\n x1 = np.asanyarray(x1)\n x2 = np.asanyarray(x2)\n return np.sqrt(err_mse(x1, x2, axis=axis))","def RMSE(ratings, range):\n\n return sqrt(MSE(ratings, range))","def compute_rmse(y, tx, w):\n return np.sqrt(2*compute_mse(y,tx,w))","def rmse(true, predictions):\n true = np.array(true)\n predictions = np.array(predictions)\n return mean_squared_error(true, predictions) ** 0.5","def calc_rmse(self, data):\n res= data.score- data[['userid','itemid']].apply(lambda row:self.calc_score(row[0], row[1]),axis=1)\n res=[el**2 for el in np.array(res)]\n return np.sqrt(np.sum(res)/data.shape[0])","def rmse(self, R, *args, **kwargs):\n rmse = 0\n for (u, i, r) in zip(R.row, R.col, R.data):\n r_hat = self.predict(u, i, *args, **kwargs)\n rmse += (r - r_hat) ** 2\n rmse = np.sqrt(rmse / R.getnnz())\n return rmse","def evaluate(self, X_test, y_test):\n \n y_pred = self.pipeline.predict(X_test)\n test_rmse = compute_rmse(y_pred, y_test)\n print(\"test rmse:\", test_rmse)\n return test_rmse","def rmse(x: np.ndarray, y: np.ndarray):\n x, y = np.copy(x), np.copy(y)\n if x.ndim > 1:\n return np.sqrt(np.nanmean((x-y)**2, axis=1))\n return np.sqrt(np.nanmean((x-y)**2))","def calculate_R2(self):\n\n d1 = self.T - self.Y\n d2 = self.T - self.T.mean()\n\n self.r2 = 1 - d1.dot(d1) / d2.dot(d2)\n self.r2 = format(self.r2, '.3f')\n\n print \"\"\n print \"R2:\", self.r2","def compute_rmse(y, tx, w):\n return np.sqrt(2 * compute_mse(y, tx, w))","def _RMSE(x, y, xnew, ynew):\n\n inds = np.isnan(ynew) # check if array has NaN values\n inds2 = np.isnan(y)\n if inds.any(): # check is all values are NaN\n return np.nan\n else:\n if inds2.any():\n y = _fillNaN(y)\n ypred2 = np.interp(x, xnew, ynew)\n\n return np.sqrt(mean_squared_error(ypred2, y))","def R_squared(self):\n return 1 - ((self.y - self.y_hat(self.x))**2).sum() / ((self.y - self.y.mean())**2).sum()","def R_squared(y_true, y_pred):\n SSE = K.sum(K.square(y_true - y_pred))\n TSS = K.sum(K.square(y_true - K.mean(y_true)))\n return 1-SSE/(TSS+K.epsilon())","def r2_score(self):\n print('R^2 (coefficient of determination) regression score function: ' +\n str(r2_score(self.model.dataset.get_y_test(), self.model.get_predicted())))","def rmse(y_true, y_pred): # -> Any:\n ...","def evaluate(self, X_test, y_test):\n pipeline = run()\n y_pred = pipeline.predict(X_test)\n rmse = compute_rmse(y_pred, y_test)\n print(rmse)\n return rmse","def RMSE(F1: Array, F2: Array, rel_tol: float = 1e-3, norm=True) -> float:\n x, y = F1.sum(), F2.sum()\n assert abs((x - y) / x) < rel_tol, \"arrays do not have same sum (up to rel. tol.)\"\n # assert np.isclose(F1.sum(), F2.sum()), 'arrays should have same sum'\n\n N = np.prod(F1.shape)\n\n diff = F1 - F2\n power = diff.power(2) if sp.issparse(diff) else np.power(diff, 2)\n out = np.sqrt(power.sum() / N)\n\n if norm:\n out *= N / x\n\n return out","def mse(self):\n xs, ys = self.R.nonzero()\n predicted = self.full_matrix()\n error = 0\n for x, y in zip(xs, ys):\n # print(predicted[x, y], self.R[x, y] )\n error += pow(self.R[x, y] - predicted[x, y], 2)\n return np.sqrt(error)","def R2_ScoreFunction(y_data, y_model):\n\tcounter = np.sum((y_data-y_model)**2)\n\tdenominator = np.sum((y_data-np.mean(y_data))**2)\n\tR_2 = 1 - (counter/denominator)\n\n\treturn R_2","def rmspe(self) -> float:\n return float(np.sqrt(np.mean(np.square(((self.true - self.predicted) / self.true)), axis=0)))","def rmsse(self, seasonality: int = 1) -> float:\n q = np.abs(self._error()) / self.mae(self.true[seasonality:], self._naive_prognose(seasonality))\n return float(np.sqrt(np.mean(np.square(q))))","def mean_absolute_error(y_real, y_pred):\n y_real, y_pred = check_arrays(y_real, y_pred)\n \n dim = y_real.shape[0]\n\n solution = np.zeros(dim)\n solution = solution.astype(np.float32)\n \n mod = SourceModule(\"\"\"\n #include <math.h>\n \n __global__ void rmse(int *x, int *y, float *solution, int dim) {\n int idx = threadIdx.x;\n solution[idx] = abs(x[idx*2] - y[idx*2]);\n }\n \"\"\")\n\n func = mod.get_function('rmse')\n func(drv.In(y_real), drv.In(y_pred), drv.Out(solution), np.int32(dim), block=(dim, 1, 1))\n\n return np.sum(solution) / y_real.size","def _plot_rmse(self, val=False):\n _, ax = plt.subplots()\n ax.plot(self.global_rmse, linewidth=3, color='blue', label='Train RMSE')\n ax.set_title('RMSE vs. Number of Iterations')\n if val is not None:\n ax.plot(self.validation_rmse, linewidth=3, color='green', label='Validation RMSE')\n ax.legend()\n plt.show()","def rmse2 (a, p) :\n s = len(a)\n z = zip(a, p)\n v = 0.0\n for x, y in z :\n v += sqre_diff(x, y)\n return math.sqrt(v / s)","def calc_R2(Fasit, Model):\n # Calculating\n R2 = 1 - sum(np.power(Fasit - Model, 2)) / sum(np.power(Fasit - np.mean(Fasit), 2))\n return R2","def calcRMSE(labelsAndPreds):\n meanOfSqErrors = labelsAndPreds.map(lambda (x,y): squaredError(x,y)).mean()\n \n return math.sqrt(meanOfSqErrors)","def inrse(self) -> float:\n return float(np.sqrt(np.sum(np.square(self._error())) / np.sum(np.square(self.true - np.mean(self.true)))))","def MSE(actual, noisy):\n mean_squared_error(actual, noisy)","def mse(o, r):\r\n\r\n return np.mean(np.square((np.abs(o).astype(float) - np.abs(r).astype(float))))","def rmse(model, ratings):\n predictions = model.predict_all().clip(1, 5)\n predictions = predictions[ratings.nonzero()]\n true_values = ratings[ratings.nonzero()]\n \n return np.sqrt(np.mean((predictions - true_values)**2))","def rmse(labels, predictions):\n n = len(labels)\n differences = numpy.subtract(labels, predictions)\n return numpy.sqrt(1.0/n * (numpy.dot(differences, differences)))","def rmse_over_stdev(y_true, y_pred, train_y=None):\n if train_y is not None:\n stdev = np.std(train_y)\n else:\n stdev = np.std(y_true)\n rmse = root_mean_squared_error(y_true, y_pred)\n return rmse / stdev","def rmse(targets: List[float], preds: List[float]) -> float:\n return math.sqrt(mean_squared_error(targets, preds))","def rmse(targets: List[float], preds: List[float]) -> float:\n return math.sqrt(mean_squared_error(targets, preds))","def rmse(a, b):\n\n n = len(a)\n return np.linalg.norm(a - b) / np.sqrt(n)","def get_rm(self):\n if isinstance(self.value, list):\n return [np.sqrt(x+self.epsilon) for x in self.value]\n else:\n return np.sqrt(self.value + self.epsilon)","def exp_rmspe(y_true, y_pred):\n pct = tf.square((tf.exp(y_true) - tf.exp(y_pred)) / tf.exp(y_true))\n\n # compute mean excluding stores with zero denominator\n x = tf.reduce_sum(tf.where(y_true > 0.001, pct, tf.zeros_like(pct)))\n y = tf.reduce_sum(tf.where(y_true > 0.001, tf.ones_like(pct), tf.zeros_like(pct)))\n return tf.sqrt(x / y)"],"string":"[\n \"def compute_RMSE(e):\\n \\\"\\\"\\\"Corresponds to sqrt(2*MSE)\\\"\\\"\\\"\\n \\n return np.sqrt(2*compute_MSE(e))\",\n \"def rrse(self) -> float:\\n return float(np.sqrt(self.rse()))\",\n \"def measure_rmse(self):\\n try:\\n assert self.residuals_forecast is not None\\n except AssertionError:\\n self._uvts_cls_logger.exception(\\\"AssertionError occurred, Cannot compute RMSE! Check your object mode\\\")\\n\\n self.rmse = np.sqrt(sum(np.square(self.residuals_forecast)) / len(self.residuals_forecast))\\n \\\"\\\"\\\"\\n if self._mode == 'test':\\n self.rmse_test = self.rmse\\n elif self._mode == 'test and validate':\\n self.rmse_val = self.rmse - self.rmse_test\\n elif self._mode == 'validate':\\n self.rmse_val = self.rmse\\n \\\"\\\"\\\"\",\n \"def nrmse(self) -> float:\\n return float(self.rmse() / (np.max(self.true) - np.min(self.true)))\",\n \"def rsr(self) -> float:\\n return float(self.rmse() / np.std(self.true))\",\n \"def rmse (lmse) :\\n return np.sqrt(2*lmse)\",\n \"def rmse(actual, predicted):\\n rms = (actual-predicted)**2\\n\\n # Returning the sqaure root of the root mean square\\n return float(np.sqrt(rms.mean()))\",\n \"def relative_rmse(self) -> float:\\n rrmse = self.rmse() / np.mean(self.true)\\n return float(rrmse)\",\n \"def irmse(self) -> float:\\n # Getting the gradient of the observed data\\n obs_len = self.true.size\\n obs_grad = self.true[1:obs_len] - self.true[0:obs_len - 1]\\n\\n # Standard deviation of the gradient\\n obs_grad_std = np.std(obs_grad, ddof=1)\\n\\n # Divide RMSE by the standard deviation of the gradient of the observed data\\n return float(self.rmse() / obs_grad_std)\",\n \"def RMSE(obs, sim):\\n obs = obs.flatten()\\n sim = sim.flatten()\\n\\n return np.sqrt(np.mean((obs - sim) ** 2))\",\n \"def rmse(self, weights=None) -> float:\\n return sqrt(np.average((self.true - self.predicted) ** 2, axis=0, weights=weights))\",\n \"def rmse(self):\\n y_pred, y_true = self._finalize_labels_and_prediction()\\n\\n return np.sqrt(F.mse_loss(y_pred, y_true).cpu().item())\",\n \"def rmse(self):\\n y_pred, y_true = self._finalize_labels_and_prediction()\\n\\n return np.sqrt(F.mse_loss(y_pred, y_true).cpu().item())\",\n \"def get_rmse(self, y_true, y_pred):\\r\\n return np.sqrt(np.mean((np.array(y_true) - np.array(y_pred)) ** 2))\",\n \"def _compute_rmse(self, data):\\n actual = data.rating.values\\n pred = self._predict_all(data)\\n rmse = np.sqrt(np.sum((actual - pred) **2) /len(pred))\\n return rmse\",\n \"def _calc_r2(self):\\n sse = np.sum((self.data.y - self.predict(self.data.x))**2)\\n sst = np.sum((self.data.y - self.data.y.mean())**2)\\n return (1. - sse/sst)\",\n \"def evaluate_rmse(y_true, y_pred):\\n\\n mse_eval = mean_squared_error(y_true, y_pred)\\n\\n rmse_eval = np.sqrt(mse_eval)\\n\\n return rmse_eval\",\n \"def rmse(a,b):\\n \\n ### Import modules\\n import numpy as np\\n \\n ### Calculate RMSE\\n rmse_stat = np.sqrt(np.mean((a - b)**2))\\n \\n return rmse_stat\",\n \"def rmse(self, X, y) -> float:\\n return np.sqrt(np.sum(self.l2_error(X, y)))\",\n \"def rmse(y_preds: ndarray, y_actual: ndarray) -> float:\\n\\n return np.sqrt(np.mean(np.power(y_preds - y_actual, 2)))\",\n \"def RMSE(actual, noisy):\\n # print len(actual)\\n # print len(noisy)\\n tmp = mean_squared_error(actual, noisy)\\n # print \\\"Tmp\\\", tmp\\n return math.sqrt(float(tmp))\\n\\n # noisy_vals = []\\n # actual_vals = []\\n # print len(actual), actual\\n # print len(noisy), noisy\\n # for lid in noisy.keys():\\n # noisy_vals.append(noisy.get(lid))\\n # if not actual.has_key(lid):\\n # print lid\\n # actual_vals.append(actual.get(lid))\\n\\n # print len(actual_vals), actual_vals\\n # print len(noisy_vals), noisy_vals\",\n \"def rmse(self):\\n return (self.model_error()**2).mean()**.5\",\n \"def compute_RMSE(true_val, predicted_val, p_output=True) -> float:\\n from sklearn.metrics import mean_squared_error\\n rms = np.sqrt(mean_squared_error(np.array(true_val), predicted_val))\\n if p_output:\\n print('RMSE: {0}'.format(rms))\\n return rms\",\n \"def rms_error(self, X, y) :\\n ### ========== TODO : START ========== ###\\n # part h: compute RMSE\\n n, d = X.shape\\n error = np.sqrt(self.cost(X,y)/n)\\n ### ========== TODO : END ========== ###\\n return error\",\n \"def rmse(self):\\n lam = self.lam()\\n weights = lam / lam.sum()\\n weighted_var = self.var() * weights\\n rmse = np.sqrt(weighted_var.sum())\\n return rmse\",\n \"def getRMSE(image1, image2):\\n im1 = readImage(image1, grayscale=False)\\n im2 = readImage(image2, grayscale=False)\\n return np.sqrt( ((im1 - im2)**2).mean() )\",\n \"def r2(self) -> float:\\n zx = (self.true - np.mean(self.true)) / np.std(self.true, ddof=1)\\n zy = (self.predicted - np.mean(self.predicted)) / np.std(self.predicted, ddof=1)\\n r = np.sum(zx * zy) / (len(self.true) - 1)\\n return float(r ** 2)\",\n \"def root_mean_square_error(y_real, y_pred):\\n y_real, y_pred = check_arrays(y_real, y_pred)\\n\\n dim = y_real.shape[0]\\n\\n solution = np.zeros(dim)\\n solution = solution.astype(np.float32)\\n \\n mod = SourceModule(\\\"\\\"\\\"\\n #include <math.h>\\n \\n __global__ void rmse(int *x, int *y, float *solution, int dim) {\\n int idx = threadIdx.x;\\n solution[idx] = pow((x[idx*2] - y[idx*2]) * 1.0, 2);\\n }\\n \\\"\\\"\\\")\\n\\n func = mod.get_function('rmse')\\n func(drv.In(y_real), drv.In(y_pred), drv.Out(solution), np.int32(dim), block=(dim, 1, 1))\\n\\n return np.sqrt(np.sum(solution) / dim)\",\n \"def calc_rmse(y: np.ndarray, y_hat: np.ndarray) -> float:\\n return np.sqrt(np.mean((y - y_hat)**2))\",\n \"def _rsq(self):\\n return self._ss_reg / self._ss_tot\",\n \"def RMSE(observed: np.ndarray, targets: np.ndarray) -> np.float64:\\n\\treturn np.sqrt(np.mean((observed-targets)**2))\",\n \"def rmse(sim, obs):\\n sim = np.asarray(sim)\\n obs = np.asarray(obs)\\n obs, sim = remove_nans(obs, sim)\\n\\n return np.sqrt(np.mean((sim - obs)**2))\",\n \"def pseudo_r2(self):\\n y_reg = self.time_series(len(self.data))\\n SSres = ((self.data - y_reg)**2).sum()\\n SStot = ((self.data - self.data.mean())**2).sum()\\n return 1 - SSres/SStot\",\n \"def rmse(x1, x2, axis=0):\\n x1 = np.asanyarray(x1)\\n x2 = np.asanyarray(x2)\\n return np.sqrt(mse(x1, x2, axis=axis))\",\n \"def r2(y: np.ndarray, y_hat: np.ndarray) -> float:\\n n = y.shape[0]\\n sse = n * mse(y, y_hat)\\n y_mean = np.mean(y)\\n sst = np.sum((y - y_mean)**2)\\n r2_value = 1 - sse / sst\\n return r2_value\",\n \"def rmse(actual: np.ndarray, predicted: np.ndarray):\\n return np.sqrt(np.mean(np.square(_error(actual, predicted))))\",\n \"def rmse(y_true, y_pred):\\n\\treturn backend.sqrt(backend.mean(backend.square(y_pred - y_true), axis=-1))\",\n \"def rmse(sim, obs, dim=\\\"time\\\"):\\n rmse = np.sqrt(mse(sim, obs, dim=dim))\\n rmse.name = \\\"rmse\\\"\\n return rmse\",\n \"def rmse(y_true, y_pred):\\n return backend.sqrt(backend.mean(backend.square(y_pred - y_true), axis=-1))\",\n \"def rmse(y_true: np.ndarray, y_pred: np.ndarray):\\n return np.sqrt(np.mean(np.power(y_true - y_pred, 2)))\",\n \"def rmse(y_true, y_pred):\\n return np.sqrt(metrics.mean_squared_error(y_true, y_pred))\",\n \"def ivrmse(self):\\n return (self.model_error_iv()**2).mean()**.5\",\n \"def rmse(X, Y):\\n\\n assert X.shape == Y.shape\\n\\n N = X.shape[0]\\n\\n if N < 9:\\n print(\\\"Not enough points. {} datapoints given. At least 9 is required\\\".format(N))\\n return\\n\\n diff = X - Y\\n diff = diff**2\\n rmse = np.sqrt(diff.mean())\\n\\n le = rmse * (1.0 - np.sqrt(1-1.96*np.sqrt(2.0)/np.sqrt(N-1)))\\n ue = rmse * (np.sqrt(1 + 1.96*np.sqrt(2.0)/np.sqrt(N-1))-1)\\n\\n return rmse, le, ue\",\n \"def rmse_calc(arr1, arr2):\\n assert arr1.shape==arr2.shape\\n \\n return np.sqrt(np.mean((arr2-arr1)**2))\",\n \"def RMSE(y,yhat):\\r\\n return(np.sqrt(MSE(y,yhat)))\",\n \"def nrmse_mean(self) -> float:\\n return float(self.rmse() / np.mean(self.true))\",\n \"def rrse(x, y):\\n return rse(x, y) ** .5\",\n \"def rmse(self, tmin=None, tmax=None):\\n res = self.ml.residuals(tmin=tmin, tmax=tmax)\\n N = res.size\\n return np.sqrt(sum(res ** 2) / N)\",\n \"def calc_error(y_real, y_pred):\\n if len(y_real) > 0:\\n curr_err = rmse(y_pred, y_real)\\n else:\\n curr_err = np.nan\\n return curr_err\",\n \"def rmse(predicted, actual):\\n #maybe make some assertions, assume have same length & in right order\\n interm_total = 0\\n for i in range(len(predicted)):\\n interm_total += (predicted[i] - actual[i]) ** 2\\n return sqrt(interm_total / len(predicted))\",\n \"def get_rmsse(self, valid_preds) -> pd.Series:\\n\\n score = ((self.valid_series - valid_preds) ** 2).mean(axis = 1)\\n rmsse = (score / self.scale).map(np.sqrt)\\n\\n return rmsse\",\n \"def computeRmse(model, data, n):\\n predictions = model.predictAll(data.map(lambda x: (x[0], x[1])))\\n predictionsAndRatings = predictions.map(lambda x: ((x[0], x[1]), x[2])) \\\\\\n .join(data.map(lambda x: ((x[0], x[1]), x[2]))) \\\\\\n .values()\\n return sqrt(predictionsAndRatings.map(lambda x: (x[0] - x[1]) ** 2).reduce(add) / float(n))\",\n \"def rmse_from_mse (mse):\\n return np.sqrt(2*mse)\",\n \"def calc_rmse(data1, data2):\\n num_users = len(data1)\\n\\n SE = 0 #the accumulated Squared Error\\n num_total = 0 #the accumulated number of ratings evaluated\\n for i in range(num_users):\\n data1_dict = dict(data1[i])\\n for movie, rating2 in data2[i]:\\n #Make one of the datasets into a dictionary to make the search more efficient\\n rating1 = data1_dict.get(movie, -1)\\n SE += (rating1-rating2)**2\\n num_total += 1\\n\\n if rating1 == -1:\\n print('Could not find rating for movie %i at user %i in data1'%(movie, i))\\n rmse = np.sqrt(SE/num_total)\\n return rmse\",\n \"def calc_nrmse(y: np.ndarray, y_hat: np.ndarray) -> float:\\n pass\",\n \"def rmse(x, y):\\n return mse(x, y) ** .5\",\n \"def RMSE(self, y_true, y_pred):\\n try:\\n l = y_true.shape[1]\\n except:\\n y_true.shape += (1,) # avoiding (l,) shape problem\\n y_pred.shape += (1,) # avoiding (l,) shape problem\\n l = 1\\n\\n rmse = np.zeros(l)\\n\\n for i in range(l):\\n actual, forecast = self.filter(y_true[:,i],y_pred[:,i])\\n rmse[i] = np.sqrt(np.mean((actual - forecast) ** 2))\\n\\n self.rmse = rmse\\n return rmse\",\n \"def rmse_metric(actual, predicted):\\r\\n sum_error = 0.0\\r\\n for i in range(len(actual)):\\r\\n prediction_error = predicted[i] - actual[i]\\r\\n sum_error += (prediction_error ** 2)\\r\\n mean_error = sum_error / float(len(actual))\\r\\n return sqrt(mean_error)\",\n \"def computeRmse(model, data, n):\\n print \\\"RESULT_data:%s \\\" % ((data.map(lambda x: (x[0], x[1]))).take(50))\\n predictions1 = model.predictAll(data.map(lambda x: (x[0], x[1])))\\n print \\\"RESULT1: %s\\\" % predictions1\\n predictionsAndRatings = predictions1.map(lambda x: ((x[0], x[1]), x[2])) \\\\\\n .join(data.map(lambda x: ((x[0], x[1]), x[2]))) \\\\\\n .values()\\n #print \\\"RESULT2: %s\\\" % predictions1.take(11)\\n return sqrt(predictionsAndRatings.map(lambda x: (x[0] - x[1]) ** 2).reduce(add) / float(n))\",\n \"def nrmse_range(self) -> float:\\n\\n return float(self.rmse() / (np.max(self.true) - np.min(self.true)))\",\n \"def rmse(s,o):\\n s,o = filter_nan(s,o)\\n return np.sqrt(np.mean((s-o)**2))\",\n \"def felm_rmse(y, X, weights, y_test, X_test):\\n # Fit model and get predicted values of test data\\n mod = sm.WLS(y, X, weights=weights).fit()\\n pred = mod.predict(X_test)\\n\\n #Get residuals from test data\\n res = (y_test[:] - pred.values)\\n\\n # Calculate ttest to check that residuals from test and train are independent\\n t_stat, p_val = stats.ttest_ind(mod.resid, res, equal_var=False)\\n\\n # Return RMSE and t-stat from ttest\\n return (np.sqrt(np.mean(res**2)), t_stat)\",\n \"def mse_r2(true, predicted):\\n # Reshaping set of images\\n # n_imgs, nx, ny = true.shape\\n # true = np.reshape(true, (n_imgs, nx*ny))\\n # predicted = np.reshape(predicted, (n_imgs, nx*ny))\\n nx = 33\\n ny = 33\\n\\n # Compute MSE\\n se = np.sum((true - predicted)**2, axis=1)\\n mse = se*(nx*ny)**-1\\n\\n # Compute R squared\\n mean = np.mean(true, axis=1)\\n r2 = 1 - se*np.sum((true - np.expand_dims(mean, axis=1))**2, axis=1)**-1\\n\\n return mse, r2\",\n \"def err_rmse(x1, x2, axis=0):\\n x1 = np.asanyarray(x1)\\n x2 = np.asanyarray(x2)\\n return np.sqrt(err_mse(x1, x2, axis=axis))\",\n \"def RMSE(ratings, range):\\n\\n return sqrt(MSE(ratings, range))\",\n \"def compute_rmse(y, tx, w):\\n return np.sqrt(2*compute_mse(y,tx,w))\",\n \"def rmse(true, predictions):\\n true = np.array(true)\\n predictions = np.array(predictions)\\n return mean_squared_error(true, predictions) ** 0.5\",\n \"def calc_rmse(self, data):\\n res= data.score- data[['userid','itemid']].apply(lambda row:self.calc_score(row[0], row[1]),axis=1)\\n res=[el**2 for el in np.array(res)]\\n return np.sqrt(np.sum(res)/data.shape[0])\",\n \"def rmse(self, R, *args, **kwargs):\\n rmse = 0\\n for (u, i, r) in zip(R.row, R.col, R.data):\\n r_hat = self.predict(u, i, *args, **kwargs)\\n rmse += (r - r_hat) ** 2\\n rmse = np.sqrt(rmse / R.getnnz())\\n return rmse\",\n \"def evaluate(self, X_test, y_test):\\n \\n y_pred = self.pipeline.predict(X_test)\\n test_rmse = compute_rmse(y_pred, y_test)\\n print(\\\"test rmse:\\\", test_rmse)\\n return test_rmse\",\n \"def rmse(x: np.ndarray, y: np.ndarray):\\n x, y = np.copy(x), np.copy(y)\\n if x.ndim > 1:\\n return np.sqrt(np.nanmean((x-y)**2, axis=1))\\n return np.sqrt(np.nanmean((x-y)**2))\",\n \"def calculate_R2(self):\\n\\n d1 = self.T - self.Y\\n d2 = self.T - self.T.mean()\\n\\n self.r2 = 1 - d1.dot(d1) / d2.dot(d2)\\n self.r2 = format(self.r2, '.3f')\\n\\n print \\\"\\\"\\n print \\\"R2:\\\", self.r2\",\n \"def compute_rmse(y, tx, w):\\n return np.sqrt(2 * compute_mse(y, tx, w))\",\n \"def _RMSE(x, y, xnew, ynew):\\n\\n inds = np.isnan(ynew) # check if array has NaN values\\n inds2 = np.isnan(y)\\n if inds.any(): # check is all values are NaN\\n return np.nan\\n else:\\n if inds2.any():\\n y = _fillNaN(y)\\n ypred2 = np.interp(x, xnew, ynew)\\n\\n return np.sqrt(mean_squared_error(ypred2, y))\",\n \"def R_squared(self):\\n return 1 - ((self.y - self.y_hat(self.x))**2).sum() / ((self.y - self.y.mean())**2).sum()\",\n \"def R_squared(y_true, y_pred):\\n SSE = K.sum(K.square(y_true - y_pred))\\n TSS = K.sum(K.square(y_true - K.mean(y_true)))\\n return 1-SSE/(TSS+K.epsilon())\",\n \"def r2_score(self):\\n print('R^2 (coefficient of determination) regression score function: ' +\\n str(r2_score(self.model.dataset.get_y_test(), self.model.get_predicted())))\",\n \"def rmse(y_true, y_pred): # -> Any:\\n ...\",\n \"def evaluate(self, X_test, y_test):\\n pipeline = run()\\n y_pred = pipeline.predict(X_test)\\n rmse = compute_rmse(y_pred, y_test)\\n print(rmse)\\n return rmse\",\n \"def RMSE(F1: Array, F2: Array, rel_tol: float = 1e-3, norm=True) -> float:\\n x, y = F1.sum(), F2.sum()\\n assert abs((x - y) / x) < rel_tol, \\\"arrays do not have same sum (up to rel. tol.)\\\"\\n # assert np.isclose(F1.sum(), F2.sum()), 'arrays should have same sum'\\n\\n N = np.prod(F1.shape)\\n\\n diff = F1 - F2\\n power = diff.power(2) if sp.issparse(diff) else np.power(diff, 2)\\n out = np.sqrt(power.sum() / N)\\n\\n if norm:\\n out *= N / x\\n\\n return out\",\n \"def mse(self):\\n xs, ys = self.R.nonzero()\\n predicted = self.full_matrix()\\n error = 0\\n for x, y in zip(xs, ys):\\n # print(predicted[x, y], self.R[x, y] )\\n error += pow(self.R[x, y] - predicted[x, y], 2)\\n return np.sqrt(error)\",\n \"def R2_ScoreFunction(y_data, y_model):\\n\\tcounter = np.sum((y_data-y_model)**2)\\n\\tdenominator = np.sum((y_data-np.mean(y_data))**2)\\n\\tR_2 = 1 - (counter/denominator)\\n\\n\\treturn R_2\",\n \"def rmspe(self) -> float:\\n return float(np.sqrt(np.mean(np.square(((self.true - self.predicted) / self.true)), axis=0)))\",\n \"def rmsse(self, seasonality: int = 1) -> float:\\n q = np.abs(self._error()) / self.mae(self.true[seasonality:], self._naive_prognose(seasonality))\\n return float(np.sqrt(np.mean(np.square(q))))\",\n \"def mean_absolute_error(y_real, y_pred):\\n y_real, y_pred = check_arrays(y_real, y_pred)\\n \\n dim = y_real.shape[0]\\n\\n solution = np.zeros(dim)\\n solution = solution.astype(np.float32)\\n \\n mod = SourceModule(\\\"\\\"\\\"\\n #include <math.h>\\n \\n __global__ void rmse(int *x, int *y, float *solution, int dim) {\\n int idx = threadIdx.x;\\n solution[idx] = abs(x[idx*2] - y[idx*2]);\\n }\\n \\\"\\\"\\\")\\n\\n func = mod.get_function('rmse')\\n func(drv.In(y_real), drv.In(y_pred), drv.Out(solution), np.int32(dim), block=(dim, 1, 1))\\n\\n return np.sum(solution) / y_real.size\",\n \"def _plot_rmse(self, val=False):\\n _, ax = plt.subplots()\\n ax.plot(self.global_rmse, linewidth=3, color='blue', label='Train RMSE')\\n ax.set_title('RMSE vs. Number of Iterations')\\n if val is not None:\\n ax.plot(self.validation_rmse, linewidth=3, color='green', label='Validation RMSE')\\n ax.legend()\\n plt.show()\",\n \"def rmse2 (a, p) :\\n s = len(a)\\n z = zip(a, p)\\n v = 0.0\\n for x, y in z :\\n v += sqre_diff(x, y)\\n return math.sqrt(v / s)\",\n \"def calc_R2(Fasit, Model):\\n # Calculating\\n R2 = 1 - sum(np.power(Fasit - Model, 2)) / sum(np.power(Fasit - np.mean(Fasit), 2))\\n return R2\",\n \"def calcRMSE(labelsAndPreds):\\n meanOfSqErrors = labelsAndPreds.map(lambda (x,y): squaredError(x,y)).mean()\\n \\n return math.sqrt(meanOfSqErrors)\",\n \"def inrse(self) -> float:\\n return float(np.sqrt(np.sum(np.square(self._error())) / np.sum(np.square(self.true - np.mean(self.true)))))\",\n \"def MSE(actual, noisy):\\n mean_squared_error(actual, noisy)\",\n \"def mse(o, r):\\r\\n\\r\\n return np.mean(np.square((np.abs(o).astype(float) - np.abs(r).astype(float))))\",\n \"def rmse(model, ratings):\\n predictions = model.predict_all().clip(1, 5)\\n predictions = predictions[ratings.nonzero()]\\n true_values = ratings[ratings.nonzero()]\\n \\n return np.sqrt(np.mean((predictions - true_values)**2))\",\n \"def rmse(labels, predictions):\\n n = len(labels)\\n differences = numpy.subtract(labels, predictions)\\n return numpy.sqrt(1.0/n * (numpy.dot(differences, differences)))\",\n \"def rmse_over_stdev(y_true, y_pred, train_y=None):\\n if train_y is not None:\\n stdev = np.std(train_y)\\n else:\\n stdev = np.std(y_true)\\n rmse = root_mean_squared_error(y_true, y_pred)\\n return rmse / stdev\",\n \"def rmse(targets: List[float], preds: List[float]) -> float:\\n return math.sqrt(mean_squared_error(targets, preds))\",\n \"def rmse(targets: List[float], preds: List[float]) -> float:\\n return math.sqrt(mean_squared_error(targets, preds))\",\n \"def rmse(a, b):\\n\\n n = len(a)\\n return np.linalg.norm(a - b) / np.sqrt(n)\",\n \"def get_rm(self):\\n if isinstance(self.value, list):\\n return [np.sqrt(x+self.epsilon) for x in self.value]\\n else:\\n return np.sqrt(self.value + self.epsilon)\",\n \"def exp_rmspe(y_true, y_pred):\\n pct = tf.square((tf.exp(y_true) - tf.exp(y_pred)) / tf.exp(y_true))\\n\\n # compute mean excluding stores with zero denominator\\n x = tf.reduce_sum(tf.where(y_true > 0.001, pct, tf.zeros_like(pct)))\\n y = tf.reduce_sum(tf.where(y_true > 0.001, tf.ones_like(pct), tf.zeros_like(pct)))\\n return tf.sqrt(x / y)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7872834","0.75949156","0.75894135","0.75683","0.7567819","0.75499594","0.75355643","0.7495896","0.7354617","0.72762173","0.72546834","0.72449005","0.72449005","0.72137094","0.7211572","0.72056526","0.71871936","0.71746224","0.7170366","0.7159166","0.7157043","0.7082244","0.7049858","0.70456904","0.7018523","0.6979603","0.694614","0.69446003","0.69417727","0.69159925","0.6858017","0.6852753","0.6828846","0.68276125","0.68214446","0.6818461","0.68052626","0.6793438","0.6769902","0.6746575","0.6740659","0.6727421","0.67271364","0.669786","0.668767","0.6677422","0.6657129","0.66551787","0.66490597","0.6645239","0.6645111","0.66365784","0.6632868","0.6629857","0.66041344","0.6603004","0.66006327","0.6562115","0.6538911","0.6537023","0.652987","0.65177816","0.6504431","0.65026706","0.649101","0.6473644","0.6473394","0.64682156","0.6455603","0.6443637","0.6440462","0.6432291","0.64220697","0.6383138","0.63657296","0.6356222","0.63546246","0.63485575","0.63459057","0.633668","0.6327338","0.6322187","0.63169575","0.6314263","0.63072896","0.6284143","0.62840366","0.62833774","0.62734044","0.6264269","0.62495726","0.6249018","0.62091494","0.62037945","0.6200247","0.6193091","0.6193091","0.61808544","0.6176576","0.61719674"],"string":"[\n \"0.7872834\",\n \"0.75949156\",\n \"0.75894135\",\n \"0.75683\",\n \"0.7567819\",\n \"0.75499594\",\n \"0.75355643\",\n \"0.7495896\",\n \"0.7354617\",\n \"0.72762173\",\n \"0.72546834\",\n \"0.72449005\",\n \"0.72449005\",\n \"0.72137094\",\n \"0.7211572\",\n \"0.72056526\",\n \"0.71871936\",\n \"0.71746224\",\n \"0.7170366\",\n \"0.7159166\",\n \"0.7157043\",\n \"0.7082244\",\n \"0.7049858\",\n \"0.70456904\",\n \"0.7018523\",\n \"0.6979603\",\n \"0.694614\",\n \"0.69446003\",\n \"0.69417727\",\n \"0.69159925\",\n \"0.6858017\",\n \"0.6852753\",\n \"0.6828846\",\n \"0.68276125\",\n \"0.68214446\",\n \"0.6818461\",\n \"0.68052626\",\n \"0.6793438\",\n \"0.6769902\",\n \"0.6746575\",\n \"0.6740659\",\n \"0.6727421\",\n \"0.67271364\",\n \"0.669786\",\n \"0.668767\",\n \"0.6677422\",\n \"0.6657129\",\n \"0.66551787\",\n \"0.66490597\",\n \"0.6645239\",\n \"0.6645111\",\n \"0.66365784\",\n \"0.6632868\",\n \"0.6629857\",\n \"0.66041344\",\n \"0.6603004\",\n \"0.66006327\",\n \"0.6562115\",\n \"0.6538911\",\n \"0.6537023\",\n \"0.652987\",\n \"0.65177816\",\n \"0.6504431\",\n \"0.65026706\",\n \"0.649101\",\n \"0.6473644\",\n \"0.6473394\",\n \"0.64682156\",\n \"0.6455603\",\n \"0.6443637\",\n \"0.6440462\",\n \"0.6432291\",\n \"0.64220697\",\n \"0.6383138\",\n \"0.63657296\",\n \"0.6356222\",\n \"0.63546246\",\n \"0.63485575\",\n \"0.63459057\",\n \"0.633668\",\n \"0.6327338\",\n \"0.6322187\",\n \"0.63169575\",\n \"0.6314263\",\n \"0.63072896\",\n \"0.6284143\",\n \"0.62840366\",\n \"0.62833774\",\n \"0.62734044\",\n \"0.6264269\",\n \"0.62495726\",\n \"0.6249018\",\n \"0.62091494\",\n \"0.62037945\",\n \"0.6200247\",\n \"0.6193091\",\n \"0.6193091\",\n \"0.61808544\",\n \"0.6176576\",\n \"0.61719674\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7639022"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":86096,"cells":{"query":{"kind":"string","value":"Perform Fourier ring correlation (FRC) test. At the time, only the FRC for 2D images has been implemented. Because this algorithm uses FFT to compare images, it is important to enforce periodic boundary conditions, e.g. by the use of padding."},"document":{"kind":"string","value":"def run_fourier_ring_correlation(self, bin_size=None):\n # This is done in the fourier plane\n exp_ft = self.exp.fft(True)\n obs_ft = self.obs.fft(True)\n\n # Get correlations\n axdict = obs_ft.axes_manager.as_dictionary()\n axdict = [axdict[keys] for keys in axdict.keys()]\n exp_obs_xc = ModifiedImage(np.real(obs_ft * np.conj(exp_ft)), axes=axdict)\n obs_ac = ModifiedImage(obs_ft.amplitude**2, axes=axdict)\n\n axdict = exp_ft.axes_manager.as_dictionary()\n axdict = [axdict[keys] for keys in axdict.keys()]\n exp_ac = ModifiedImage(exp_ft.amplitude**2, axes=axdict)\n\n xc = exp_obs_xc.integrate_radial(bin_size=bin_size, shifted=False, show_progressbar=False)\n ac1 = exp_ac.integrate_radial(bin_size=bin_size, shifted=False, show_progressbar=False)\n ac2 = obs_ac.integrate_radial(bin_size=bin_size, shifted=False, show_progressbar=False)\n\n fsc = xc / np.sqrt(ac1*ac2)\n\n fsc.axes_manager[-1].units = obs_ft.axes_manager[-1].units\n fsc.axes_manager[-1].name = r'|q| = |1/r|'\n\n return fsc"},"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 corrf(u, v, nf):\n V = np.conj(np.fft.fft(v, n=nf))\n U = np.fft.fft(u, n=nf)\n X = U*V\n x = np.real(np.fft.ifft(X, n=nf))\n return x","def frc(im1, im2, annulus_width=1, edgetaper=5, edgeloc=8 / 20.0, loc=(0, 0), smooth=None, working_mask=None, x=None,\n y=None, rmax=None, taper=None):\n\n # 2012-02-25 20:40 IJMC: Empty bins now have numel=0, not nan.\n # 2012-02-04 17:41 IJMC: Added \"SUM\" flag\n # 2010-11-19 16:36 IJC: Updated documentation for Sphinx\n # 2010-03-10 19:22 IJC: Ported to python from Matlab\n # 2005/12/19 Added 'working_region' option (IJC)\n # 2005/12/15 Switched order of outputs (IJC)\n # 2005/12/12 IJC: Removed decifact, changed name, wrote comments.\n # 2005/11/04 by Ian Crossfield at the Jet Propulsion Laboratory\n\n import numpy as ny\n\n class radialDat:\n \"\"\"Empty object container.\n \"\"\"\n\n def __init__(self):\n self.num = None\n self.denom = None\n self.T1bit = None\n self.Thalfbit = None\n\n # ---------------------\n # Set up input parameters\n # ---------------------\n\n if working_mask == None:\n working_mask = ny.ones(im1.shape, bool)\n\n npix, npiy = im1.shape\n if taper is not None:\n taper0 = taper\n else:\n taper0 = tapercircle(im1.shape, edgetaper, edgeloc, loc)\n f, a = plt.subplots()\n a.imshow(imsave(im1 * taper0))\n plt.title('tapered')\n plt.show()\n # taper0 = 1\n F1 = fftshift(fft2(ifftshift(im1 * taper0)))\n F2 = fftshift(fft2(ifftshift(im2 * taper0)))\n F1F2_star = F1 * F2.conj()\n\n if x == None or y == None:\n x1 = ny.arange(-npix / 2., npix / 2.)\n y1 = ny.arange(-npiy / 2., npiy / 2.)\n x, y = ny.meshgrid(y1, x1)\n\n r = abs(x + 1j * y)\n\n if rmax == None:\n rmax = r[working_mask].max()\n\n # ---------------------\n # Prepare the data container\n # ---------------------\n dr = ny.abs([x[0, 0] - x[0, 1]]) * annulus_width\n radial = ny.arange(rmax / dr) * dr + dr / 2.\n nrad = len(radial)\n radialdata = radialDat()\n radialdata.num = ny.zeros(nrad)\n radialdata.denom = ny.zeros(nrad)\n radialdata.T1bit = ny.zeros(nrad)\n radialdata.Thalfbit = ny.zeros(nrad)\n radialdata.r = radial / (npix / 2)\n\n # ---------------------\n # Loop through the bins\n # ---------------------\n for irad in range(nrad): # = 1:numel(radial)\n minrad = irad * dr\n maxrad = minrad + dr\n thisindex = (r >= minrad) * (r < maxrad) * working_mask\n # import pylab as py\n # pdb.set_trace()\n if not thisindex.ravel().any():\n radialdata.num[irad] = ny.nan\n radialdata.denom[irad] = ny.nan\n radialdata.T1bit[irad] = ny.nan\n radialdata.Thalfbit[irad] = ny.nan\n else:\n sqrt_n = np.sqrt(thisindex.astype(np.int).sum())\n radialdata.num[irad] = np.real(F1F2_star[thisindex].sum())\n radialdata.denom[irad] = ny.sqrt((ny.abs(F1[thisindex]) ** 2).sum() * (ny.abs(F2[thisindex]) ** 2).sum())\n radialdata.T1bit[irad] = (0.5 + 2.4142 / sqrt_n) / (1.5 + 1.4142 / sqrt_n)\n radialdata.Thalfbit[irad] = (0.2071 + 1.9102 / sqrt_n) / (1.2071 + 0.9102 / sqrt_n)\n\n # ---------------------\n # Return with data\n # ---------------------\n radialdata.frc = ny.nan_to_num(radialdata.num / radialdata.denom)\n radialdata.frc[radialdata.frc < 0] = 0\n if smooth is not None:\n radialdata.frc = gaussian_filter1d(radialdata.frc, smooth)\n take = radialdata.r <= 1.1\n radialdata.r = radialdata.r[take]\n radialdata.frc = radialdata.frc[take]\n radialdata.T1bit = radialdata.T1bit[take]\n radialdata.Thalfbit = radialdata.Thalfbit[take]\n return radialdata","def flatfield_corr(*args): \n print(len(args), args)\n if len(args)==1:\n \n raster=gdal_array.LoadFile(args[0])\n R=raster[0]\n G=raster[1]\n B=raster[2]\n file_path=os.path.dirname(os.path.abspath(args[0]))+\"/corr/\"+os.path.basename(args[0])[:-4]+\"_corr.tif\"\n elif len(args)==3:\n R=gdal_array.LoadFile(args[0])\n G=gdal_array.LoadFile(args[1])\n B=gdal_array.LoadFile(args[2])\n basename=os.path.basename(args[0])\n basename=basename[:3]+basename[4:]\n file_path=os.path.dirname(os.path.abspath(args[0]))+\"/corr/\"+os.path.basename(args[0])[:-4]+\"_rgb_corr.tif\"\n else:\n print(\"functions takes 1 (rgb file path) or 3 arguments (one filepath per channel)\")\n \n \n flat_file_R, flat_file_G, flat_file_B,_,_=return_flatfield_set_path(2)\n \n # Mfaktor=5\n R=BLUE_simple_flatfield_corr(gdal_array.LoadFile(flat_file_R), R)\n G=BLUE_simple_flatfield_corr(gdal_array.LoadFile(flat_file_G), G)\n B=BLUE_simple_flatfield_corr(gdal_array.LoadFile(flat_file_B), B)\n \n G=np.roll(G, 8, axis=1)\n \n # print(np.max(raster), np.min(raster))\n \n \n plot_raster=np.empty([2050, 2448, 3], dtype=np.int16)\n plot_raster[:,:,0]=R \n plot_raster[:,:,1]=G\n plot_raster[:,:,2]=B\n \n plot_raster=(plot_raster/np.max(plot_raster))*255\n plot_raster=plot_raster.astype(np.uint8)\n plot_raster[:,:,0]=cv2.equalizeHist( plot_raster[:,:,0])\n plot_raster[:,:,1]=cv2.equalizeHist( plot_raster[:,:,1])\n plot_raster[:,:,2]=cv2.equalizeHist( plot_raster[:,:,2])\n \n \n # plt.axis('off')\n\n \n \n # plt.imshow(plot_raster, vmin=0, vmax=65535)\n # plt.show()\n # plt.close()\n \n # max_=np.max(raster)\n\n \n # raster=raster.astype(np.uint16)\n \n driver=osgeo.gdal.GetDriverByName(\"GTiff\")\n options = ['PHOTOMETRIC=RGB', 'PROFILE=GeoTIFF']\n \n dataset=driver.Create(os.path.dirname(os.path.abspath(args[0]))+\"/corr/rgb/\"+os.path.basename(args[0])[:-4]+\"_rgb_corr.tif\"\n , R.shape[1]-8,R.shape[0], 3, osgeo.gdal.GDT_UInt16, options) \n dataset.GetRasterBand(1).WriteArray(R[:,8:])\n dataset.GetRasterBand(2).WriteArray(G[:,8:])\n dataset.GetRasterBand(3).WriteArray(B[:,8:])\n dataset.FlushCache()\n dataset = None\n \n options = ['PROFILE=GeoTIFF']\n\n basename=os.path.basename(args[0])\n basename=basename[:3]+\"R\"+basename[4:]\n file_path=os.path.dirname(os.path.abspath(args[0]))+\"/corr/\"+basename[:-4]+\"_corr.tif\"\n dataset=driver.Create(file_path, R.shape[1]-8,R.shape[0], 1, osgeo.gdal.GDT_UInt16, options) \n dataset.GetRasterBand(1).WriteArray(R[:,8:])\n dataset.FlushCache()\n dataset = None\n \n basename=os.path.basename(args[0])\n basename=basename[:3]+\"G\"+basename[4:]\n file_path=os.path.dirname(os.path.abspath(args[0]))+\"/corr/\"+basename[:-4]+\"_corr.tif\"\n dataset=driver.Create(file_path, R.shape[1]-8,R.shape[0], 1, osgeo.gdal.GDT_UInt16, options) \n dataset.GetRasterBand(1).WriteArray(G[:,8:])\n dataset.FlushCache()\n dataset = None\n \n basename=os.path.basename(args[0])\n basename=basename[:3]+\"B\"+basename[4:]\n file_path=os.path.dirname(os.path.abspath(args[0]))+\"/corr/\"+basename[:-4]+\"_corr.tif\"\n dataset=driver.Create(file_path, R.shape[1]-8,R.shape[0], 1, osgeo.gdal.GDT_UInt16, options) \n dataset.GetRasterBand(1).WriteArray(B[:,8:])\n dataset.FlushCache()\n dataset = None\n \n \n \n # plot_raster = cv2.cvtColor(plot_raster, cv2.COLOR_RGB2BGR)\n # cv2.imwrite(file_path[:-4]+\"_preview.jpg\", plot_raster)\n # plot_raster=NormalizeData(plot_raster)\n # plot_raster=plot_raster/4095\n # plot_raster=plot_raster*512\n # plot_raster=plot_raster.astype(np.uint8)\n \n \n # plt.gca().set_axis_off()\n # plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, \n # hspace = 0, wspace = 0)\n # plt.margins(0,0)\n # plt.gca().xaxis.set_major_locator(plt.NullLocator())\n # plt.gca().yaxis.set_major_locator(plt.NullLocator())\n \n # plt.imshow(plot_raster[:,8:,:])\n # # plt.savefig(file_path[:-4]+\"_previewplot.jpg\", dpi=600, bbox_inches='tight')\n # plt.show()\n # plt.close\n \n \n # # print(img_array.shape)\n \n # # img=Image.fromarray(plot_raster, \"RGB\")\n # # img.save(file_path[:-4]+\"_preview.jpg\")\n \n \n \n # # print(np.max(raster), np.min(raster))","def cross_correlate(rmsynth_pixel, rmsf):\n return np.fft.ifft(np.fft.fft(rmsynth_pixel)*np.fft.fft(rmsf[::-1]))","def correlate(fft1,fft2, maxlag,dt, Nfft, method=\"cross-correlation\"):\n\n if fft1.ndim == 1:\n nwin=1\n elif fft1.ndim == 2:\n nwin= int(fft1.shape[0])\n\n t0=time.time()\n corr=np.zeros(shape=(nwin,Nfft),dtype=np.complex64)\n fft1_globe = cuda.to_device(fft1[:,:Nfft//2].reshape(fft1.size,))\n fft2_globe = cuda.to_device(fft2[:,:Nfft//2].reshape(fft2.size,))\n corr_globe = cuda.device_array(shape=(nwin*(Nfft//2),),dtype=np.complex64)\n \n threadsperblock = 2000\n blockspergrid = math.ceil(fft1_globe.size/threadsperblock)\n \n if method == 'deconv':\n decon_gpu[threadsperblock,blockspergrid](fft1_globe,fft2_globe,corr_globe)\n elif method =='coherence':\n coherence_gpu[threadsperblock,blockspergrid](fft1_globe,fft2_globe,corr_globe)\n\n tcorr = corr_globe.copy_to_host()\n corr = tcorr.reshape(nwin,Nfft//2)\n\n ncorr = np.zeros(shape=Nfft,dtype=np.complex64)\n ncorr[:Nfft//2] = np.mean(corr,axis=0)\n ncorr[-(Nfft//2)+1:]=np.flip(np.conj(ncorr[1:(Nfft//2)]),axis=0)\n ncorr[0]=complex(0,0)\n ncorr = np.real(np.fft.ifftshift(scipy.fftpack.ifft(ncorr, Nfft, axis=0)))\n\n t1=time.time()\n print('it takes '+str(t1-t0)+' s')\n\n tcorr = np.arange(-Nfft//2 + 1, Nfft//2)*dt\n ind = np.where(np.abs(tcorr) <= maxlag)[0]\n ncorr = ncorr[ind]\n tcorr = tcorr[ind]\n\n return ncorr,tcorr","def test_ft_with_pols():\n fake_data = np.zeros((3, 2, 13, 31))\n fake_data[:, 0, 7, 11] += 1.0\n fake_corr = utils.normalized_fourier_transform(\n fake_data, 1 * units.dimensionless_unscaled, taper=windows.boxcar, axis=3\n )\n assert (3, 2, 13, 31) == fake_corr.shape","def test_correlation_spectrum():\r\n # Smoke-test for now - unclear what to test here...\r\n f, c = tsa.correlation_spectrum(x, y, norm=True)","def test_fft_real_2d():\n\ta = np.mgrid[:5, :5, :5][0]\n\tdummy_array = xr.DataArray(a, dims=['x', 'y', 'z'])\n\tchunked_array = dummy_array.chunk(chunks={'x': 2, 'y': 2, 'z': 2})\n\tspectrum_array, spectrum_coords, spectrum_dims = \\\n\t\txfft._fft(chunked_array, nfft={'y': 14, 'z': 18}, dim=['y', 'z'],\n\t\t dx={'y': 0.01, 'z': 0.02}, sym=False)\n\tassert np.allclose(spectrum_array.compute(),\n\t np.fft.rfftn(a, s=(18, 14), axes=(2, 1)))\n\tassert np.array_equal(spectrum_coords['f_y'], np.fft.rfftfreq(14, d=0.01))\n\tassert np.array_equal(spectrum_coords['f_z'], np.fft.fftfreq(18, d=0.02))\n\tassert ('x', 'f_y', 'f_z') == spectrum_dims","def calculate_overf_correlation(amp, index, f0, dt, n_lags):\n \n # Cast inputs as floats as I do a bunch of division.\n dt = float(dt)\n f0 = float(f0)\n index = float(index)\n # Number of points used in calculation needs to be at least 10 times bigger\n # than final number of point returned. This is so we are not affected by\n # the periodicity of the correlation function.\n buff_factor = 64\n n = buff_factor * n_lags\n n_return = n_lags\n # Generate the power spectrum.\n # Need to add a low frequency cut off, since there is an IR divergence.\n # Choose to cut off at 1/2df (so we get a bit of slope mode).\n power = overf_power_spectrum(amp, index, f0, dt, n,\n cut_off=1./n_lags/dt/2.0)\n # FFT it to the correlation function.\n corr = fft.ifft(power)\n # Complex part should be zero.\n corr = corr.real\n # In previous versions of this function, we shifted the output function.\n # however this screws up positive definiteness of the correlation matrix\n # and is unnecessary if you have the IR cut off.\n #corr -= corr[2 * n_return]\n # Trim to return size.\n corr = corr[:n_return]\n # To normalize, need to multiply by twice the bandwidth.\n corr *= 1.0/dt\n return corr","def test_fft_real_3d():\n\ta = np.mgrid[:7, :5, :5][0]\n\tdummy_array = xr.DataArray(a, dims=['x', 'y', 'z'])\n\tchunked_array = dummy_array.chunk(chunks={'x': 7, 'y': 5, 'z': 5})\n\tspectrum_array, spectrum_coords, spectrum_dims = \\\n\t\txfft._fft(chunked_array, nfft={'x': 11, 'y': 14, 'z': 18},\n\t\t dim=['x', 'y', 'z'], dx={'x':12, 'y': 0.01, 'z': 0.02},\n\t\t sym=False)\n\tassert np.allclose(spectrum_array.compute(),\n\t np.fft.rfftn(a.T, s=(18, 14, 11)).T)\n\tassert np.array_equal(spectrum_coords['f_x'], np.fft.rfftfreq(11, d=12))\n\tassert np.array_equal(spectrum_coords['f_y'], np.fft.fftfreq(14, d=0.01))\n\tassert np.array_equal(spectrum_coords['f_z'], np.fft.fftfreq(18, d=0.02))\n\tassert ('f_x', 'f_y', 'f_z') == spectrum_dims","def test_normalized_fourier_transform():\n fake_data = np.zeros((1, 13, 21))\n fake_data[0, 7, 11] += 1\n fake_corr = utils.normalized_fourier_transform(\n fake_data, 1 * units.dimensionless_unscaled, taper=windows.boxcar, axis=2\n )\n test_corr = np.fft.fft(fake_data, axis=-1)\n test_corr = np.fft.fftshift(test_corr, axes=-1)\n fake_corr = fake_corr.value\n assert np.allclose(test_corr, fake_corr)","def xcorr(arr1, arr2, mode = 'full', axes = None):\n if mode not in {'full', 'same'}:\n raise ValueError('Unexpected cross-correlation mode {}'.format(mode))\n \n if axes is None:\n axes = tuple(range(arr1.ndim))\n\n arr1, arr2 = np.asarray(arr1), np.asarray(arr2)\n\n # Determine final size along transformation axes\n # To speed up FFT, shape of Fourier transform might be slightly larger\n # then slice back before returning\n s1 = tuple(arr1.shape[ax] for ax in axes)\n s2 = tuple(arr2.shape[ax] for ax in axes)\n final_shape = tuple( ax1 + ax2 - 1 for ax1, ax2 in zip(s1, s2))\n fast_shape = tuple(map(next_fast_len, final_shape))\n final_slice = tuple([slice(0, int(sz)) for sz in final_shape])\n\n F1 = fftn(arr1, shape = fast_shape, axes = axes)\n F2 = fftn(np.conj(mirror(arr2, axes = axes)), shape = fast_shape, axes = axes)\n xc = ifftn(F1 * F2)[final_slice]\n\n if mode == 'same':\n return _centered(xc, arr1.shape, axes = axes)\n else:\n return xc","def testrescorr():\n tau = np.zeros((2,50))\n tau[0,25] = 2\n tau[1,23] = 3\n tau2 = spec_utils.res_corr(tau, 2, 8)\n #Check flux conserved\n assert np.abs(np.sum(tau2[0,:])/ np.sum(tau[0,:]) -1) < 1e-6\n assert np.abs(np.sum(tau2[1,:])/ np.sum(tau[1,:]) -1) < 1e-6\n #Check expanded by expected amount\n for i in (0,1):\n assert np.size(np.where(tau2[i,:]> 0)) == 15","def circular_cross_correlation(x, y):\n return tf.real(tf.ifft(tf.multiply(tf.conj(tf.fft(tf.cast(x, tf.complex64))) , tf.fft(tf.cast(y, tf.complex64)))))","def toff(self) -> None:\n\n size = self.circ_size\n self._get_random_input_state(self.seed)\n\n remainder = size % 3\n for layer in range(size):\n leftovers = tuple(random.sample(range(size), remainder))\n candidates = [x for x in range(size) if x not in leftovers]\n\n while candidates:\n current_toff = tuple(random.sample(candidates, 3))\n self.ccx(current_toff[0], current_toff[1], current_toff[2])\n candidates = [x for x in candidates if x not in current_toff]\n\n self.decompose().decompose()\n if self.meas: self.measure(self.qr, self.cr)","def cross_correlation(x_ref: np.ndarray, x_target: np.ndarray, fs: Optional[int] = None,\n hilbert_flag: bool = False, normalize_flag: bool = False,\n freq_range: Optional[Union[np.ndarray, list]] = None,\n calc_offset: bool = False, plot_flag: bool = False\n ) -> Tuple[np.ndarray, np.ndarray, Union[float, None]]:\n\n # preliminaries\n assert (x_ref.ndim == 1) & (x_target.ndim == 1)\n len1 = x_ref.size\n len2 = x_target.size\n len_cc = len1 + len2 - 1\n\n # compute\n x1_fft = fft.rfft(x_ref, len_cc)\n x2_fft = fft.rfft(x_target, len_cc)\n cc_fft = x1_fft * np.conj(x2_fft)\n\n # normalize by magnitude of reference signal\n if normalize_flag:\n magnitude_factor = np.abs(x1_fft) ** 2\n cc_fft = (cc_fft / magnitude_factor)\n\n # frequency filtering\n if freq_range is not None:\n f_vec = fft.rfftfreq(len_cc, 1/fs)\n assert np.size(freq_range) == 2\n idx = (f_vec < freq_range[0]) | (f_vec > freq_range[1])\n cc_fft[idx] = 0\n\n # transform back to time domain\n cc = fft.irfft(cc_fft, len_cc)\n cc = np.roll(cc, len2 - 1)\n lags = np.arange(len_cc) - (len2 - 1)\n if fs is not None:\n lags = lags / fs\n\n # hilbert transform\n if hilbert_flag:\n cc = np.abs(hilbert(cc))\n\n # calculate offset\n if calc_offset:\n offset = lags[np.argmax(np.abs(cc))]\n else:\n offset = None\n\n # plot\n if plot_flag:\n fig = px.line(y=cc, x=lags)\n lags_units = \"samples\" if fs is None else \"seconds\"\n fig.update_xaxes(title=f\"Shift [{lags_units}]\")\n fig.update_yaxes(title=\"Processed Cross Correlation\")\n fig.show()\n\n return cc, lags, offset","def corrf(self, refimg_fea, targetimg_fea, maxdisp, fac=1):\n b, c, height, width = refimg_fea.shape\n if refimg_fea.is_cuda:\n cost = Variable(\n torch.cuda.FloatTensor(b, c, 2 * maxdisp + 1, 2 * int(maxdisp // fac) + 1, height, width)).fill_(\n 0.) # b,c,u,v,h,w\n else:\n cost = Variable(torch.FloatTensor(b, c, 2 * maxdisp + 1, 2 * int(maxdisp // fac) + 1, height, width)).fill_(\n 0.) # b,c,u,v,h,w\n # print(cost.shape)\n for i in range(2 * maxdisp + 1):\n ind = i - maxdisp\n for j in range(2 * int(maxdisp // fac) + 1):\n indd = j - int(maxdisp // fac)\n feata = refimg_fea[:, :, max(0, -indd):height - indd, max(0, -ind):width - ind]\n featb = targetimg_fea[:, :, max(0, +indd):height + indd, max(0, ind):width + ind]\n diff = (feata * featb)\n cost[:, :, i, j, max(0, -indd):height - indd, max(0, -ind):width - ind] = diff\n cost = F.leaky_relu(cost, 0.1, inplace=True)\n # print(cost.shape)\n return cost","def test_fft_spectrum_fieldtrip_03():\n ft_complex_dpss = [-0.0335619899491902 - 0.0100985443725351j, 0.0252013706875434 + 0.0436725973183397j, -0.0145928652426528 - 0.0546311601211480j, -0.00364680778007352 + 0.0542853721812055j, 0.0293189825468446 - 0.0554598147669454j, -0.0523346938092935 + 0.0458447745674979j, 0.0739055167896313 - 0.00673071060189224j, -0.0892965233534656 - 0.0698942934418098j, 0.0664933718921557 + 0.148311783870617j, -0.00190172379532472 - 0.160711901636832j]\n f0, Sxx0 = _fft(x, s_freq, detrend=None, taper='dpss', output='complex', sides='two', scaling='fieldtrip', halfbandwidth=3)\n # Note that the DC freq is different\n assert_array_almost_equal(Sxx0[100:110, 0], ft_complex_dpss)","def plot_correlation_fit(img1_ft, img2_ft, frqs, dx, fmax=None, frqs_guess=None, roi_size=31,\n peak_pixels=2, figsize=(20, 10), ttl_str=\"\"):\n\n # get physical parameters\n dy = dx\n\n # get frequency data\n fxs = tools.get_fft_frqs(img1_ft.shape[1], dx)\n fys = tools.get_fft_frqs(img1_ft.shape[0], dy)\n if fmax is None:\n fmax = np.sqrt(np.max(fxs)**2 + np.max(fys)**2)\n\n # power spectrum / cross correlation\n # cc = np.abs(img1_ft * img2_ft.conj())\n # cc = np.abs(scipy.signal.fftconvolve(img1_ft, img2_ft.conj(), mode='same'))\n cc = np.abs(scipy.signal.correlate(img2_ft, img1_ft, mode='same'))\n\n fx_sim, fy_sim = frqs\n # useful info to print\n period = 1 / np.sqrt(fx_sim ** 2 + fy_sim ** 2)\n angle = np.angle(fx_sim + 1j * fy_sim)\n\n peak_cc = tools.get_peak_value(cc, fxs, fys, [fx_sim, fy_sim], peak_pixels)\n\n peak1_dc = tools.get_peak_value(img1_ft, fxs, fys, [0, 0], peak_pixels)\n peak2 = tools.get_peak_value(img2_ft, fxs, fys, [fx_sim, fy_sim], peak_pixels)\n\n extent = tools.get_extent(fys, fxs)\n\n # create figure\n figh = plt.figure(figsize=figsize)\n gspec = matplotlib.gridspec.GridSpec(ncols=14, nrows=2, hspace=0.3, figure=figh)\n\n str = \"\"\n if ttl_str != \"\":\n str += \"%s\\n\" % ttl_str\n # suptitle\n str += ' fit: period %0.1fnm = 1/%0.3fum at %.2fdeg=%0.3frad; f=(%0.3f,%0.3f) 1/um, peak cc=%0.3g at %0.2fdeg' % \\\n (period * 1e3, 1/period, angle * 180 / np.pi, angle, fx_sim, fy_sim, np.abs(peak_cc), np.angle(peak_cc) * 180/np.pi)\n if frqs_guess is not None:\n fx_g, fy_g = frqs_guess\n period_g = 1 / np.sqrt(fx_g ** 2 + fy_g ** 2)\n angle_g = np.angle(fx_g + 1j * fy_g)\n peak_cc_g = tools.get_peak_value(cc, fxs, fys, frqs_guess, peak_pixels)\n\n str += '\\nguess: period %0.1fnm = 1/%0.3fum at %.2fdeg=%0.3frad; f=(%0.3f,%0.3f) 1/um, peak cc=%0.3g at %0.2fdeg' % \\\n (period_g * 1e3, 1/period_g, angle_g * 180 / np.pi, angle_g, fx_g, fy_g, np.abs(peak_cc_g), np.angle(peak_cc_g) * 180/np.pi)\n plt.suptitle(str)\n\n # #######################################\n # plot region of interest\n # #######################################\n roi_cx = np.argmin(np.abs(fx_sim - fxs))\n roi_cy = np.argmin(np.abs(fy_sim - fys))\n roi = tools.get_centered_roi([roi_cy, roi_cx], [roi_size, roi_size])\n\n extent_roi = tools.get_extent(fys[roi[0]:roi[1]], fxs[roi[2]:roi[3]])\n\n ax = plt.subplot(gspec[0, 0:6])\n ax.set_title(\"cross correlation, ROI\")\n im1 = ax.imshow(cc[roi[0]:roi[1], roi[2]:roi[3]], interpolation=None, norm=PowerNorm(gamma=0.1), extent=extent_roi)\n ph1 = ax.scatter(frqs[0], frqs[1], color='r', marker='x')\n if frqs_guess is not None:\n if np.linalg.norm(frqs - frqs_guess) < np.linalg.norm(frqs + frqs_guess):\n ph2 = ax.scatter(frqs_guess[0], frqs_guess[1], color='g', marker='x')\n else:\n ph2 = ax.scatter(-frqs_guess[0], -frqs_guess[1], color='g', marker='x')\n\n if frqs_guess is not None:\n ax.legend([ph1, ph2], ['frq fit', 'frq guess'], loc=\"upper right\")\n else:\n ax.legend([ph1], ['frq fit'], loc=\"upper right\")\n\n circ_max_frq = matplotlib.patches.Circle((0, 0), radius=fmax, color='k', fill=0, ls='--')\n ax.add_artist(circ_max_frq)\n\n ax.set_xlabel('fx (1/um)')\n ax.set_ylabel('fy (1/um)')\n\n\n cbar_ax = figh.add_subplot(gspec[0, 6])\n figh.colorbar(im1, cax=cbar_ax)\n\n ### full image ###\n ax2 = plt.subplot(gspec[0, 7:13])\n im2 = ax2.imshow(cc, interpolation=None, norm=PowerNorm(gamma=0.1), extent=extent)\n ax2.set_xlim([-fmax, fmax])\n ax2.set_ylim([fmax, -fmax])\n\n # plot maximum frequency\n circ_max_frq = matplotlib.patches.Circle((0, 0), radius=fmax, color='k', fill=0)\n ax2.add_artist(circ_max_frq)\n\n roi_rec = matplotlib.patches.Rectangle((fxs[roi[2]], fys[roi[0]]), fxs[roi[3]] - fxs[roi[2]], fys[roi[1]] - fys[roi[0]],\n edgecolor='k', fill=0)\n ax2.add_artist(roi_rec)\n\n ax2.set_title(\"Cross correlation, C(fo) = \\sum_f img_ft1(f) x img_ft2^*(f+fo)\")\n ax2.set_xlabel('fx (1/um)')\n ax2.set_ylabel('fy (1/um)')\n\n cbar_ax = figh.add_subplot(gspec[0, 13])\n figh.colorbar(im2, cax=cbar_ax)\n\n # ft 1\n ax3 = plt.subplot(gspec[1, 0:6])\n ax3.set_title(\"fft 1 PS near DC, peak = %0.3g at %0.2fdeg\" % (np.abs(peak1_dc), np.angle(peak1_dc) * 180/np.pi))\n\n cx_c = np.argmin(np.abs(fxs))\n cy_c = np.argmin(np.abs(fys))\n roi_center = tools.get_centered_roi([cy_c, cx_c], [roi_size, roi_size])\n\n im3 = ax3.imshow(np.abs(img1_ft[roi_center[0]:roi_center[1], roi_center[2]:roi_center[3]])**2,\n interpolation=None, norm=PowerNorm(gamma=0.1), extent=extent)\n ax3.scatter(0, 0, color='r', marker='x')\n\n cbar_ax = figh.add_subplot(gspec[1, 6])\n figh.colorbar(im3, cax=cbar_ax)\n\n # ft 2\n ax4 = plt.subplot(gspec[1, 7:13])\n ttl_str = \"fft 2 PS near fo, peak = %0.3g at %0.2fdeg\" % (np.abs(peak2), np.angle(peak2) * 180 / np.pi)\n if frqs_guess is not None:\n peak2_g = tools.get_peak_value(img2_ft, fxs, fys, frqs_guess, peak_pixels)\n ttl_str += \"\\nguess peak = = %0.3g at %0.2fdeg\" % (np.abs(peak2_g), np.angle(peak2_g) * 180 / np.pi)\n ax4.set_title(ttl_str)\n\n im4 = ax4.imshow(np.abs(img2_ft[roi[0]:roi[1], roi[2]:roi[3]])**2,\n interpolation=None, norm=PowerNorm(gamma=0.1), extent=extent_roi)\n ph1 = ax4.scatter(frqs[0], frqs[1], color='r', marker='x')\n if frqs_guess is not None:\n if np.linalg.norm(frqs - frqs_guess) < np.linalg.norm(frqs + frqs_guess):\n ph2 = ax4.scatter(frqs_guess[0], frqs_guess[1], color='g', marker='x')\n else:\n ph2 = ax4.scatter(-frqs_guess[0], -frqs_guess[1], color='g', marker='x')\n\n cbar_ax = figh.add_subplot(gspec[1, 13])\n figh.colorbar(im4, cax=cbar_ax)\n\n return figh","def test_correlation_test_perfect_correlation(self):\r\n # These results were verified with R.\r\n obs = correlation_test([1, 2, 3, 4], [1, 2, 3, 4])\r\n self.assertFloatEqual(obs[:2],\r\n (0.99999999999999978, 2.2204460492503131e-16))\r\n self.assertEqual(len(obs[2]), 999)\r\n for r in obs[2]:\r\n self.assertTrue(r >= -1.0 and r <= 1.0)\r\n self.assertCorrectPValue(0.06, 0.09, correlation_test,\r\n ([1, 2, 3, 4], [1, 2, 3, 4]), p_val_idx=3)\r\n self.assertFloatEqual(obs[4], (0.99999999999998879, 1.0))","def test_fft_real_1d():\n\ta = [0, 1, 0, 0]\n\tdummy_array = xr.DataArray(a, dims=['x'])\n\tchunked_array = dummy_array.chunk(chunks={'x': 2})\n\tspectrum_array, spectrum_coords, spectrum_dims = \\\n\t\txfft._fft(chunked_array, nfft={'x': 4}, dim=['x'], dx={'x': 0.01},\n\t\t sym=False)\n\tassert np.array_equal(spectrum_array.compute(), np.fft.rfft(a))\n\tassert np.array_equal(spectrum_coords['f_x'], np.fft.rfftfreq(4, d=0.01))\n\tassert 'f_x' in spectrum_dims","def periodic_corr(x, y):\r\n return np.fft.ifft(np.fft.fft(x) * np.fft.fft(y).conj()).real","def get_simple_ccf(flux1, flux2, shift_lst):\n\n n = flux1.size\n ccf_lst = []\n for shift in shift_lst:\n segment1 = flux1[max(0,shift):min(n,n+shift)]\n segment2 = flux2[max(0,-shift):min(n,n-shift)]\n c1 = math.sqrt((segment1**2).sum())\n c2 = math.sqrt((segment2**2).sum())\n corr = np.correlate(segment1, segment2)/c1/c2\n ccf_lst.append(corr)\n return np.array(ccf_lst)","def corr2d_fourier(slip, test, lonslip = [], latslip = [], lontest = [], lattest = [], normalizar = True):\n\n\n if normalizar: \n xcorr2d = signal.correlate(slip/np.size(slip), test/np.size(test), mode='full', method='fft')\n else:\n xcorr2d = signal.correlate(slip, test, mode='full', method='fft')\n \n \n valor_corr = np.sum(xcorr2d)\n\n\n return valor_corr","def correlation_1d(data1, data2):\n\n N = len(data1)\n assert N == len(data2)\n n_fft = select_power_of_two(N)\n\n # Pad the signal with zeros to avoid the periodic images.\n R_data1 = np.zeros(2*n_fft)\n R_data1[:N] = data1\n R_data2 = np.zeros(2*n_fft)\n R_data2[:N] = data2\n F_data1 = np.fft.fft(R_data1)\n F_data2 = np.fft.fft(R_data2)\n result = np.fft.ifft(F_data1.conj()*F_data2)\n positive_time = result[:N].real/(N-np.arange(N))\n negative_time = result[-N+1:][::-1].real/(N-1-np.arange(N-1))\n\n return np.concatenate((negative_time[::-1], positive_time))","def test_correlation(self):\r\n x = [1, 2, 3, 5]\r\n y = [0, 0, 0, 0]\r\n z = [1, 1, 1, 1]\r\n a = [2, 4, 6, 8]\r\n b = [1.5, 1.4, 1.2, 1.1]\r\n c = [15, 10, 5, 20]\r\n\r\n bad = [1, 2, 3] # originally gave r = 1.0000000002\r\n\r\n self.assertFloatEqual(correlation(x, x), (1, 0))\r\n self.assertFloatEqual(correlation(x, y), (0, 1))\r\n self.assertFloatEqual(correlation(y, z), (0, 1))\r\n self.assertFloatEqualAbs(correlation(x, a), (0.9827076, 0.01729), 1e-5)\r\n self.assertFloatEqualAbs(\r\n correlation(x, b), (-0.9621405, 0.03786), 1e-5)\r\n self.assertFloatEqualAbs(correlation(x, c), (0.3779645, 0.622), 1e-3)\r\n self.assertEqual(correlation(bad, bad), (1, 0))","def test_fft_complex_2d():\n\ta, b, c = np.meshgrid([0, 1, 0, 0], [0, 1j, 1j], [0, 1, 1, 1])\n\tdummy_array = xr.DataArray(a * b * c, dims=['x', 'y', 'z'])\n\tchunked_array = dummy_array.chunk(chunks={'x': 2, 'y': 2, 'z': 2})\n\tspectrum_array, spectrum_coords, spectrum_dims = \\\n\t\txfft._fft(chunked_array, nfft={'y': 6, 'z': 8}, dim=['y', 'z'],\n\t\t dx={'y': 0.01, 'z': 0.02})\n\tassert np.allclose(spectrum_array.compute(),\n\t np.fft.fftn(a * b * c, s=(8, 6), axes=(2, 1)))\n\tassert np.array_equal(spectrum_coords['f_y'], np.fft.fftfreq(6, d=0.01))\n\tassert np.array_equal(spectrum_coords['f_z'], np.fft.fftfreq(8, d=0.02))\n\tassert ('x', 'f_y', 'f_z') == spectrum_dims","def _xcorrf(self, profile1, profile2, dx):\n corrf = np.correlate(profile2, profile1, mode = 'same') \\\n /np.sum(profile1**2)\n\n if np.isnan(corrf).any():\n displ = np.nan\n corr = 0\n else:\n displ = (np.where(corrf == np.max(corrf))[0][0] - len(corrf)//2)*dx\n corr = np.max(corrf)\n\n return displ, corr","def calculate_roc(calibration_model, PSF_model, test_images, test_coef, N_iter=3, noise=False, SNR_noise=None):\n\n N_PSF = test_coef.shape[0] # How many PSF cases do we have\n N_eps = 200 # How many thresholds to sample\n percentage = np.linspace(0, 100, N_eps) # Array of percentage thresholds\n roc = np.zeros((N_iter, N_eps)) # ROC array\n\n # get the norm of the test coef at the beginning\n norm_test0 = norm(test_coef, axis=1)\n\n if noise:\n # Add readout noise to the test images\n test_images = calibration_model.noise_effects.add_readout_noise(test_images, RMS_READ=1 / SNR_noise)\n\n # placeholder arrays for the images and coefficients\n psf0, coef0 = test_images, test_coef\n for k in range(N_iter):\n print(\"\\nIteration #%d\" % (k + 1))\n # predict the coefficients\n guess = calibration_model.cnn_model.predict(psf0)\n residual = coef0 - guess\n norm_residual = norm(residual, axis=1)\n # compare the norm of the residual to that of the original coefficients\n ratios = norm_residual / norm_test0 * 100\n\n # calculate the ROC\n for j in range(N_eps):\n # compute the fraction of cases whose ratio norm residual / norm test coef is smaller than threshold\n roc[k, j] = np.sum(ratios < percentage[j]) / N_PSF\n\n # update the PSF images for the next iteration\n new_PSF = np.zeros_like(test_images)\n for i in range(N_PSF):\n if i % 500 == 0:\n print(i)\n psf_nom, s_nom = PSF_model.compute_PSF(residual[i])\n psf_foc, s_foc = PSF_model.compute_PSF(residual[i], diversity=True)\n new_PSF[i, :, :, 0] = psf_nom\n new_PSF[i, :, :, 1] = psf_foc\n\n if noise:\n # Add readout noise to the test images\n new_PSF = calibration_model.noise_effects.add_readout_noise(new_PSF, RMS_READ=1 / SNR_noise)\n\n # Overwrite the placeholder arrays for the next iteration\n psf0 = new_PSF\n coef0 = residual\n\n return roc, percentage, residual","def comb_fc(filepatt):\r\n\r\n\r\n files = glob.glob(os.path.join(savefolder, filepatt))\r\n print(filepatt)\r\n \r\n if files == []:\r\n imgs = []\r\n print('No files found for ' + filepatt)\r\n return\r\n\r\n\r\n imgs = np.empty((600, 600, 3))\r\n for fi, file in enumerate(files):\r\n img = cv2.imread(file)\r\n \r\n if fi == 0:\r\n imgs = img\r\n else:\r\n imgs = np.concatenate((imgs, img), axis = 2)\r\n\r\n idx = filepatt.find('freq')\r\n comb_fcGraph = os.path.join(savefolder, 'comb_' + filepatt[idx: -len('.mat')])\r\n cv2.imwrite(comb_fcGraph, imgs)\r\n print(comb_fcGraph)\r\n\r\n # find lowweight\r\n pvals_vec = []\r\n ciCOH_vec = []\r\n pvals = pvals_fc_overtime(ciCOH = ciCOH, ntrials = ntrials, ntemp = ntemp, f = f, t = t)\r\n\r\n reject, pval_corr = fdr_correction(pvals, alpha=0.05, method='indep')\r\n \r\n\r\n \r\n lowweight = min(ciCOH_vec[rejs])\r\n\r\n return lowweight","def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \n av = akv * 1e3 # Convert kilovots to volts\n cs = cs * 1e7 # Convert spherical aberation from mm to A\n \n # wavelength of electrons\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\n \n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\n wgh2 = dscale*wgh\n\n ix = freqs[:,0]\n iy = freqs[:,1]\n freq_radius = n.sqrt(ix**2 + iy**2)\n\n angle = elambda*freq_radius\n angspt = n.arctan2(iy,ix)\n if rots is not None:\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\n angle = angle.reshape((-1,1)) \n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\n c2 = -c1*cs*angle**2/2.0\n angdif = angspt - angastf\n ccos = n.cos(2.0*angdif)\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\n chi = c1*df + c2\n\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\n \n if bfactor is not None:\n ctf *= envelope_function(freq_radius, bfactor)\n\n return n.require(ctf,dtype = freqs.dtype)","def test_fdr_correction(self):\r\n pvals = array([.1, .7, .5, .3, .9])\r\n exp = array([.5, .7 * 5 / 4., .5 * 5 / 3., .3 * 5 / 2., .9])\r\n obs = fdr_correction(pvals)\r\n self.assertFloatEqual(obs, exp)","def estimate_F_ransac(corr, num_iter, inlier_thresh):\n _, inlier_mask = ransac(corr, estimate_F, sym_epipolar_dist, 8, num_iter, inlier_thresh)\n # inlier_mask = np.ones(9)\n # inlier_mask[0] = 0\n F = estimate_F(corr[inlier_mask.astype(np.bool)])\n return F","def fasper(x, y, ofac, hifac, n_threads, MACC=4):\n # Check dimensions of input arrays\n n = int(len(x))\n if n != len(y):\n print('Incompatible arrays.')\n return\n \n # print x, y, hifac, ofac\n \n nout = int(0.5*ofac*hifac*n)\n nfreqt = int(ofac*hifac*n*MACC) #Size the FFT as next power\n nfreq = 64 # of 2 above nfreqt.\n\n while nfreq < nfreqt:\n nfreq = 2*nfreq\n\n ndim = int(2*nfreq)\n \n # Compute the mean, variance\n ave = y.mean()\n # sample variance because the divisor is N-1\n var = ((y - y.mean())**2).sum()/(len(y) - 1) \n # and range of the data.\n xmin = x.min()\n xmax = x.max()\n xdif = xmax - xmin\n\n # extrapolate the data into the workspaces\n if is_pyfftw:\n wk1 = pyfftw.n_byte_align_empty(int(ndim), 16, 'complex') * 0.\n wk2 = pyfftw.n_byte_align_empty(int(ndim), 16, 'complex') * 0.\n else:\n wk1 = zeros(ndim, dtype='complex')\n wk2 = zeros(ndim, dtype='complex')\n\n fac = ndim/(xdif*ofac)\n fndim = ndim\n ck = ((x - xmin)*fac) % fndim\n ckk = (2.0*ck) % fndim\n \n for j in range(0, n):\n __spread__(y[j] - ave, wk1, ndim, ck[j], MACC)\n __spread__(1.0, wk2, ndim, ckk[j], MACC)\n\n # Take the Fast Fourier Transforms.\n if is_pyfftw:\n fft_wk1 = pyfftw.builders.ifft(wk1, planner_effort='FFTW_ESTIMATE',\n threads=n_threads)\n wk1 = fft_wk1() * len(wk1)\n fft_wk2 = pyfftw.builders.ifft(wk2, planner_effort='FFTW_ESTIMATE',\n threads=n_threads)\n wk2 = fft_wk2() * len(wk2)\n else:\n wk1 = ifft(wk1)*len(wk1)\n wk2 = ifft(wk2)*len(wk1)\n\n wk1 = wk1[1:nout + 1]\n wk2 = wk2[1:nout + 1]\n rwk1 = wk1.real\n iwk1 = wk1.imag\n rwk2 = wk2.real\n iwk2 = wk2.imag\n \n df = 1.0/(xdif*ofac)\n \n # Compute the Lomb value for each frequency\n hypo2 = 2.0*abs(wk2)\n hc2wt = rwk2/hypo2\n hs2wt = iwk2/hypo2\n\n cwt = sqrt(0.5 + hc2wt)\n swt = sign(hs2wt)*(sqrt(0.5 - hc2wt))\n den = 0.5*n + hc2wt*rwk2 + hs2wt*iwk2\n cterm = (cwt*rwk1 + swt*iwk1)**2./den\n sterm = (cwt*iwk1 - swt*rwk1)**2./(n - den)\n\n wk1 = df*(arange(nout, dtype='float') + 1.)\n wk2 = (cterm + sterm)/(2.0*var)\n pmax = wk2.max()\n jmax = wk2.argmax()\n\n # Estimate significance of largest peak value\n expy = exp(-pmax) \n effm = 2.0*(nout)/ofac\n prob = effm*expy\n\n if prob > 0.01: \n prob = 1.0 - (1.0 - expy)**effm\n\n return wk1, wk2, nout, jmax, prob","def correlation_spectrum(x1, x2, Fs=2 * np.pi, norm=False):\r\n\r\n x1 = x1 - np.mean(x1)\r\n x2 = x2 - np.mean(x2)\r\n x1_f = fftpack.fft(x1)\r\n x2_f = fftpack.fft(x2)\r\n D = np.sqrt(np.sum(x1 ** 2) * np.sum(x2 ** 2))\r\n n = x1.shape[0]\r\n\r\n ccn = ((np.real(x1_f) * np.real(x2_f) +\r\n np.imag(x1_f) * np.imag(x2_f)) /\r\n (D * n))\r\n\r\n if norm:\r\n ccn = ccn / np.sum(ccn) * 2 # Only half of the sum is sent back\r\n # because of the freq domain symmetry.\r\n # XXX Does normalization make this\r\n # strictly positive?\r\n\r\n f = utils.get_freqs(Fs, n)\r\n return f, ccn[0:(n / 2 + 1)]","def correlate(array1,array2):\r\n arrayout = np.conj(fft2(array1)) * fft2(array2)\r\n return ifft2(arrayout)","def test(size_timeseries, num_timeseries):\n data = random_data(num_timeseries, size_timeseries)\n correlations_dfe = [0.0] * calc_num_correlations(num_timeseries)\n correlations_cpu = [0.0] * calc_num_correlations(num_timeseries)\n indices_step = [0.0] * calc_num_correlations(num_timeseries) * 2\n\n start_time = time.time()\n correlate_dfe(data, size_timeseries, num_timeseries, correlations_dfe)\n dfe_total = time.time() - start_time\n print 'DFE correlation total time:\\t%.5lfs' % dfe_total\n\n start_time = time.time()\n correlate_cpu(data, num_timeseries, size_timeseries,\n correlations_cpu, indices_step)\n cpu_total = time.time() - start_time\n print 'CPU correlation total time:\\t%.5lfs' % cpu_total\n\n check(correlations_dfe, correlations_cpu, num_timeseries, indices_step)","def test_delay_vals_with_pols():\n fake_data = np.zeros((3, 2, 13, 31))\n fake_data[:, 0, 7, 11] += 1.0\n fake_corr = utils.normalized_fourier_transform(\n fake_data, 1 * units.dimensionless_unscaled, taper=windows.boxcar, axis=3\n )\n test_corr = np.fft.fft(fake_data, axis=-1)\n test_corr = np.fft.fftshift(test_corr, axes=-1)\n fake_corr = fake_corr.value\n assert np.allclose(test_corr, fake_corr)","def test_fftconvolve_numerics(self, leading_dims, lengths, mode):\n L_x, L_y = lengths\n\n x = torch.rand(*(leading_dims + (L_x,)), dtype=self.dtype, device=self.device)\n y = torch.rand(*(leading_dims + (L_y,)), dtype=self.dtype, device=self.device)\n\n actual = F.fftconvolve(x, y, mode=mode)\n\n expected = signal.fftconvolve(x.detach().cpu().numpy(), y.detach().cpu().numpy(), axes=-1, mode=mode)\n expected = torch.tensor(expected)\n\n self.assertEqual(expected, actual)","def test_MFT_MFTwithnumexpr_equivalence(display=False, displaycrop=None):\n\n centering='FFTSTYLE' # needed if you want near-exact agreement of MFT and FFT!\n\n default_use_numexpr = accel_math._USE_NUMEXPR\n\n for useflag in [True,False]:\n accel_math._USE_NUMEXPR = useflag\n\n imgin = optics.ParityTestAperture().sample(wavelength=1e-6, npix=256)\n\n npix = imgin.shape\n nlamD = np.asarray(imgin.shape)\n mft = matrixDFT.MatrixFourierTransform(centering=centering)\n mftout = mft.perform(imgin, nlamD, npix)\n\n fftout = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(imgin))) / np.sqrt(imgin.shape[0] * imgin.shape[1])\n\n\n norm_factor = abs(mftout).sum()\n\n absdiff = abs(mftout-fftout) / norm_factor\n\n assert(np.all(absdiff < 1e-10))\n\n\n accel_math._USE_NUMEXPR = default_use_numexpr","def rolling_circular_correlation(\n data_x: np.ndarray, data_y: np.ndarray, fps: int, time_window: float = 1.0\n ) -> np.ndarray:\n\n data_x, data_y = np.deg2rad(data_x), np.deg2rad(data_y)\n results = np.full((data_x.shape[0]), np.nan)\n window_size = int(time_window * fps)\n for window_start in prange(0, data_x.shape[0] - window_size + 1):\n data_x_window = data_x[window_start : window_start + window_size]\n data_y_window = data_y[window_start : window_start + window_size]\n x_sin = np.sin(\n data_x_window\n - np.angle(np.nansum(np.multiply(1, np.exp(1j * data_x_window))))\n )\n y_sin = np.sin(\n data_y_window\n - np.angle(np.nansum(np.multiply(1, np.exp(1j * data_y_window))))\n )\n r = np.sum(x_sin * y_sin) / np.sqrt(np.sum(x_sin**2) * np.sum(y_sin**2))\n results[window_start + window_size] = (\n np.sqrt(\n (data_x_window.shape[0] * (x_sin**2).mean() * (y_sin**2).mean())\n / np.mean(x_sin**2 * y_sin**2)\n )\n * r\n )\n\n return results","def test_crofton_method(self):\n\n chi_sq = lambda pred, obs: np.sum((obs - pred)**2 / pred)\n\n para_crof = np.arange(0, 9)\n\n crof = PIHM()\n\n # Data from Crofton 1971\n st1_obs = np.array([161, 111, 67, 65, 50, 30, 33, 13, 8])\n st2_obs = np.array([189, 129, 86, 51, 27, 14, 8, 1, 2])\n st3_obs = np.array([458, 81, 40, 22, 19, 4, 6, 3, 0])\n st4_obs = np.array([164, 147, 92, 43, 25, 11, 3, 0, 1])\n st5_obs = np.array([140, 77, 30, 14, 10, 3, 2, 0, 0])\n st6_obs = np.array([153, 29, 6, 2, 1, 0, 0, 0, 0])\n\n # Raw data\n st1_raw = np.repeat(para_crof, st1_obs)\n st2_raw = np.repeat(para_crof, st2_obs)\n st3_raw = np.repeat(para_crof, st3_obs)\n st4_raw = np.repeat(para_crof, st4_obs)\n st5_raw = np.repeat(para_crof, st5_obs)\n st6_raw = np.repeat(para_crof, st6_obs)\n\n # Crofton predicted with truncations!\n st1_pred = {\n 3: np.array([162.2, 103.9, 77.4, 60.4, 48.2, 38.9, 31.7, 26.0, 21.4]),\n 4: np.array([162.4, 103.4, 77.6, 61.2, 49.4, 40.5, 33.5, 27.9, 23.3]),\n 5: np.array([161.2, 107.0, 78.0, 58.7, 44.7, 34.4, 26.6, 20.7, 16.1]),\n 6: np.array([162.1, 104.6, 77.3, 59.5, 46.7, 37.1, 29.7, 23.9, 19.3]),\n 7: np.array([160.2, 108.8, 79.2, 58.9, 44.3, 33.6, 25.5, 19.5, 14.9]),\n 8: np.array([158.4, 111.7, 80.8, 59.0, 43.2, 31.7, 23.3, 17.2, 12.7])}\n\n st2_pred = {\n 3: np.array([188.6, 130.7, 83.6 , 52.0, 31.9, 19.4, 11.7, 7.0, 4.2]),\n 4: np.array([187.9, 133.0, 83.0, 49.4, 28.7, 16.5, 9.3, 5.3, 2.9,]),\n 5: np.array([187.3, 134.5, 83.0, 48.4, 27.4, 15.3, 8.4, 4.6, 2.5]),\n 6: np.array([187.2, 134.8, 83.1, 48.3, 27.3, 15.1, 8.3, 4.5, 2.4]),\n 7: np.array([185.3, 138.1, 84.2, 47.5, 25.7, 13.6, 7.0, 3.6, 1.8]),\n 8: np.array([185.5, 137.9, 84.1, 47.5, 25.8, 13.7, 7.1, 3.7, 1.9])}\n\n st3_pred = {\n 3: np.array([457.9, 81.8, 39.0, 22.5, 14.1, 9.2, 6.3, 4.3, 3.0]),\n 4: np.array([458.1, 79.5, 40.3, 25.0, 16.9, 12.0, 8.8, 6.5, 5.0]),\n 5: np.array([457.5, 83.7, 39.0, 21.9, 13.3, 8.5, 5.5, 3.7, 2.5]),\n 6: np.array([457.0, 83.4, 39.1, 22.0, 13.5, 8.6, 5.7, 3.8, 2.2]),\n 7: np.array([457.4, 84.1, 39.1, 21.8, 13.2, 8.3, 5.4, 3.6, 2.4])}\n\n # Station 1 comparison\n\n trunc = np.arange(3, 9)\n\n crof_st1_ks = [0.754, 0.736, 0.834, 0.776, 0.874, 0.951]\n crof_st1_N = [677, 708, 606, 646, 594, 573]\n our_st1_N = []\n our_st1_ks = []\n crof_st1_compare_ss = []\n\n crof.data = st1_raw\n\n for i in trunc:\n\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\n N, mu, k = crof.crofton_method(bin_edges)\n our_st1_ks.append(k)\n our_st1_N.append(N)\n\n assert_array_almost_equal(crof_st1_ks, our_st1_ks, decimal=1)\n\n # This will fail, but it is close\n # Uncomment and run nosetests to see results\n\n # assert_array_equal(crof_st1_N, our_st1_N)\n\n # Station 2 comparison\n\n crof_st2_ks = [1.182, 1.313, 1.392, 1.407, 1.574, 1.563]\n crof_st2_N = [535, 520, 514, 513, 508, 509]\n our_st2_N = []\n our_st2_ks = []\n crof_st2_compare_ss = []\n\n crof.data = st2_raw\n\n for i in trunc:\n\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\n N, mu, k = crof.crofton_method(bin_edges)\n our_st2_ks.append(k)\n our_st2_N.append(N)\n\n assert_array_almost_equal(crof_st2_ks, our_st2_ks, decimal=1)\n\n assert_array_equal(np.round(crof_st2_N, -1), np.round(our_st2_N, -1))\n\n # Station 3 comparison\n\n trunc = np.arange(3, 8)\n\n crof_st3_ks = [.229, .206, .244, .242, .247]\n crof_st3_N = [646, 670, 642, 643, 641]\n our_st3_N = []\n our_st3_ks = []\n crof_st3_compare_ss = []\n\n crof.data = st3_raw\n\n for i in trunc:\n\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\n N, mu, k = crof.crofton_method(bin_edges)\n our_st3_ks.append(k)\n our_st3_N.append(N)\n\n assert_array_almost_equal(crof_st3_ks, our_st3_ks, decimal=1)\n\n # Close to equal but not quite. Which is ok. We don't expect them\n # to be exactly equal\n # Uncomment and run nosetests to see\n\n # assert_array_equal(crof_st3_N, our_st3_N)","def test_MKDAChi2_fdr(testdata_cbma):\n meta = MKDAChi2()\n results = meta.fit(testdata_cbma, testdata_cbma)\n corr = FDRCorrector(method=\"indep\", alpha=0.001)\n corr_results = corr.transform(results)\n assert isinstance(results, nimare.results.MetaResult)\n assert isinstance(results.description_, str)\n assert isinstance(corr_results, nimare.results.MetaResult)\n assert isinstance(corr_results.description_, str)\n\n methods = FDRCorrector.inspect(results)\n assert methods == [\"indep\", \"negcorr\"]","def test_inv_fft() -> None:\n ntests = 30\n for i in range(ntests):\n input_size = np.random.randint(4, 16, size=(2))\n filter_size = np.random.randint(1, 4, size=(2))\n input_mat = np.random.rand(*input_size)\n filter_mat = np.random.rand(*filter_size)\n # input_mat = np.array([[1, 2], [3, 4]])\n # filter_mat = np.array([[1, 2], [3, 4]])\n # fwd = fwd_conv2d(input_mat, filter_mat)\n fwd_fft = fwd_conv2d_fft(input_mat, filter_mat)\n inv_fwd_fft = inv_conv2d_fft(fwd_fft, filter_mat, None)\n fwd_inv_fwd_fft = fwd_conv2d_fft(inv_fwd_fft, filter_mat)\n # print(input_mat)\n # print(filter_mat)\n # print(fwd)\n # print(fwd_fft)\n # print(inv_fwd_fft)\n # print(fwd_inv_fwd_fft)\n error = np.linalg.norm(fwd_inv_fwd_fft - fwd_fft)\n assert error < 0.05, 'test_inv_fft test #%d failed:\\n' \\\n 'error %f too large!\\n' \\\n 'filter_mat:\\n%s\\ninput_mat:\\n%s\\n' \\\n 'fwd_fft:\\n%s\\n' \\\n 'inv_fwd_fft:\\n%s\\n' % (i,\n error,\n filter_mat,\n input_mat,\n fwd_fft,\n inv_fwd_fft)","def nancrosscorr(\n fr1: np.ndarray,\n fr2: np.ndarray = None,\n thres_n=2,\n fillvalue=np.nan,\n processes=1,\n) -> np.ndarray:\n if fr2 is None:\n fr2 = fr1\n\n is_fr1_ndim2 = fr1.ndim == 2\n if is_fr1_ndim2:\n fr1 = fr1[..., None]\n\n is_fr2_ndim2 = fr2.ndim == 2\n if is_fr2_ndim2:\n fr2 = fr2[..., None]\n\n assert fr1.ndim == 3\n assert fr2.ndim == 3\n assert thres_n >= 2, 'to compute correlation thres_n needs to be >= 2'\n\n fsh1 = np.array(fr1.shape[:2])\n fsh2 = np.array(fr2.shape[:2])\n # csh = fsh1 + fsh2\n\n # NOTE: pad smaller of the two to match max_shape + 2,\n # + 2 to ensure both are padded on both sides to remove smoothing artifact\n max_sh0 = np.amax(np.stack([fsh1, fsh2], axis=0), axis=0)\n max_sh = max_sh0 + 2\n # max_sh = (max_sh // 2) * 2 + 1 # enforce odd numbers so it has a center\n pad1 = max_sh - fsh1\n # pad1 = np.stack([\n # int(np.floor(pad1 / 2))])\n pad2 = max_sh - fsh2\n fr1 = np.pad(fr1, [\n (int(np.floor(pad1[0] / 2)),\n int(np.ceil(pad1[0] / 2))),\n (int(np.floor(pad1[1] / 2)),\n int(np.ceil(pad1[1] / 2))),\n (0, 0)\n ], constant_values=np.nan)\n fr2 = np.pad(fr2, [\n (int(np.floor(pad2[0] / 2)),\n int(np.ceil(pad2[0] / 2))),\n (int(np.floor(pad2[1] / 2)),\n int(np.ceil(pad2[1] / 2))),\n (0, 0)\n ], constant_values=np.nan)\n\n csh = max_sh0 * 2\n cc = np.zeros(tuple(csh) + fr1.shape[2:]) + fillvalue\n # fsh = np.amin(np.stack([fsh1, fsh2], axis=0), axis=0)\n # fsh = np.ceil(max_sh / 2).astype(int)\n fsh = max_sh0\n\n pool = Pool(processes=processes)\n # if processes > 0:\n # pool = Pool(processes=processes)\n # f_map = pool.map\n # else:\n # def f_map(*args, **kwargs):\n # return list(map(*args, **kwargs))\n\n # def ccorrs(dx: int):\n # cc0 = _ccorrs_given_dx(dx, csh, fillvalue, fr1, fr2, fsh, thres_n)\n\n dxs = np.arange(-fsh[0], fsh[0])\n cc[fsh[0] + dxs] = np.array(pool.map(\n _ccorrs_given_dx,\n ((dx, csh, fillvalue, fr1, fr2, fsh, thres_n) for dx in dxs)\n ))\n # cc[fsh[0] + dxs] = np.array(pool.map(ccorrs, dxs))\n\n # if processes > 0:\n # pool.close()\n\n if is_fr1_ndim2 and is_fr2_ndim2:\n assert cc.shape[-1] == 1\n cc = cc[..., 0]\n\n return cc","def coherency(s1, s2, lags, plot=False, window_fraction=None, noise_floor_db=None):\n\n # test for symmetry\n i = len(lags) // 2\n assert lags[i] == 0, \"Midpoint of lags must be zero for coherency!\"\n assert np.sum(-lags[:i] != lags[-i:][::-1]) == 0, \"lags must be symmetric for coherency!\"\n\n window = np.ones([len(lags)], dtype='float')\n if window_fraction is not None:\n assert window_fraction > 0 and window_fraction <= 1, \"window_fraction must be between 0 and 1\"\n # create a gaussian windowing function for the CF and ACFs\n window = np.exp(-lags**2 / (window_fraction*lags.max())**2)\n\n # do an FFT shift to the lags and the window, otherwise the FFT of the ACFs is not equal to the power\n # spectrum for some numerical reason\n window = fftshift(window)\n shift_lags = fftshift(lags)\n if len(lags) % 2 == 1:\n # shift zero from end of shift_lags to beginning\n shift_lags = np.roll(shift_lags, 1)\n window = np.roll(window, 1)\n\n cf = correlation_function(s1, s2, shift_lags)\n acf1 = correlation_function(s1, s1, shift_lags)\n acf2 = correlation_function(s2, s2, shift_lags)\n\n if np.sum(np.isnan(cf)) > 0:\n # print 'len(lags)=%d, len(s1)=%d, len(s2)=%d' % (len(lags), len(s1), len(s2))\n print('signals=',zip(s1, s2))\n print('shift_lags,cf=',zip(shift_lags, cf))\n raise Exception(\"Nans in cf\")\n\n assert np.sum(np.isnan(acf1)) == 0, \"Nans in acf1\"\n assert np.sum(np.isnan(acf2)) == 0, \"Nans in acf2\"\n\n if window_fraction is not None:\n cf *= window\n acf1 *= window\n acf2 *= window\n\n cf_fft = fft(cf)\n acf1_fft = fft(acf1)\n acf2_fft = fft(acf2)\n\n acf1_ps = np.abs(acf1_fft)\n acf2_ps = np.abs(acf2_fft)\n\n # determine which points are noise (with magnitudes too low to be useful) in the acfs\n zeros = np.zeros([len(cf_fft)], dtype='bool')\n if noise_floor_db is not None:\n db1 = 20*np.log10(acf1_ps / acf1_ps.max()) + noise_floor_db\n z1 = db1 <= 0\n\n db2 = 20*np.log10(acf2_ps / acf2_ps.max()) + noise_floor_db\n z2 = db2 <= 0\n zeros = z1 | z2\n\n assert np.abs(acf1_fft.imag).max() < 1e-8, \"acf1_fft.imag.max()=%f\" % np.abs(acf1_fft.imag).max()\n assert np.abs(acf2_fft.imag).max() < 1e-8, \"acf2_fft.imag.max()=%f\" % np.abs(acf2_fft.imag).max()\n\n cpre = cf_fft / np.sqrt(acf1_ps*acf2_ps)\n cpre[zeros] = 0\n c = ifft(cpre)\n assert np.abs(c.imag).max() < 1e-8, \"np.abs(c.imag).max()=%f\" % np.abs(c.imag).max()\n\n coh = fftshift(c.real)\n freq = fftshift(fftfreq(len(lags)))\n fi = freq >= 0\n\n if np.sum(np.abs(coh) > 1) > 0:\n print('Warning: coherency is > 1!')\n\n if plot:\n plt.figure()\n plt.subplot(2, 3, 1)\n plt.plot(s1, 'r-')\n plt.plot(s2, 'b-')\n plt.legend(['s1', 's2'])\n plt.xlabel('Time')\n plt.axis('tight')\n plt.title('Signals')\n\n plt.subplot(2, 3, 2)\n plt.axvline(0, c='k')\n plt.axhline(0, c='k')\n l1 = plt.plot(lags, fftshift(acf1), 'r-')\n l2 = plt.plot(lags, fftshift(acf2), 'b-')\n l3 = plt.plot(lags, fftshift(cf), 'g-')\n plt.title('Correlation Functions')\n plt.xlabel('Lags')\n plt.legend(['', '', 'ACF1', 'ACF2', 'CF12'])\n plt.axis('tight')\n plt.ylim(-0.5, 1.0)\n\n plt.subplot(2, 3, 3)\n plt.axhline(0, c='k', alpha=0.75)\n plt.axvline(0, c='k', alpha=0.75)\n plt.plot(lags, coh, 'm-')\n plt.ylabel('Coherency')\n plt.xlabel('Lag')\n plt.axis('tight')\n plt.title('Coherency')\n\n plt.subplot(2, 3, 4)\n plt.plot(freq[fi], fftshift(acf1_ps)[fi], 'r')\n plt.plot(freq[fi], fftshift(acf2_ps)[fi], 'b')\n cf_ps = fftshift(np.abs(cf_fft))\n cf_pre_ps = fftshift(np.abs(cpre))\n plt.plot(freq[fi], cf_ps[fi], 'g--')\n plt.plot(freq[fi], cf_pre_ps[fi], 'm-')\n plt.legend(['ACF1', 'ACF2', 'CF12', 'CPRE'])\n plt.ylabel('Power (raw)')\n plt.xlabel('Frequency')\n plt.axis('tight')\n plt.title('Raw Power Spectra')\n\n if noise_floor_db:\n plt.subplot(2, 3, 5)\n plt.axhline(0, c='k')\n plt.plot(freq[fi], fftshift(db1)[fi], 'r')\n plt.plot(freq[fi], fftshift(db2)[fi], 'b')\n plt.legend(['ACF1', 'ACF2'])\n plt.ylabel('Power (dB)')\n plt.xlabel('Frequency')\n plt.axis('tight')\n plt.title('Log Power Spectra')\n\n plt.show()\n\n return coh","def rfft(pix, tcl):\n nx, dx, ny, dy = pix.nx, pix.dx, pix.ny, pix.dy\n \n ret = maps.rfft(nx, dx, ny=ny, dy=dy)\n ret.fft[:,:] = (np.random.standard_normal((ny,nx/2+1)) + 1.j * np.random.standard_normal((ny,nx/2+1))) / np.sqrt(2.)\n ret.fft[0,0] = np.sqrt(2.) * np.real(ret.fft[0,0])\n ret.fft[ny/2+1:, 0] = np.conj( ret.fft[1:ny/2,0][::-1] )\n\n ret.fft[:,:] *= np.interp( ret.get_ell().flatten(), np.arange(0,len(tcl)), np.sqrt(tcl), right=0 ).reshape( ret.fft.shape )\n return ret","def msd_Correlation(allX):\n M = allX.shape[0]\n # numpy with MKL (i.e. intelpython distribution), the fft wont be\n # accelerated unless axis along 0 or -1\n # perform FT along n_frame axis\n # (n_frams, n_particles, n_dim) -> (n_frames_Ft, n_particles, n_dim)\n allFX = np.fft.rfft(allX, axis=0, n=M*2)\n # sum over n_dim axis\n corr = np.sum(abs(allFX)**2, axis=(1, -1)) # (n_frames_ft,)\n # IFT over n_frame_ft axis (axis=0), whole operation euqals to\n # fx = fft(_.T[0]), fy =... for _ in\n # allX.swapaxes(0,1) -> (n_particles, n_frames, n_dim)\n # then sum fx, fy, fz...fndim\n # rfft for real inputs, higher eff\n return np.fft.irfft(corr, n=2 * M)[:M].real/np.arange(M, 0, -1)\n # (n_frames,), the n_particles dimension is added out","def fasper_py(x,y,ofac,hifac, MACC=4):\n #Check dimensions of input arrays\n n = long(len(x))\n if n != len(y):\n print 'Incompatible arrays.'\n return\n\n nout = 0.5*ofac*hifac*n\n nfreqt = long(ofac*hifac*n*MACC) #Size the FFT as next power\n nfreq = 64L # of 2 above nfreqt.\n\n while nfreq < nfreqt: \n nfreq = 2*nfreq\n\n ndim = long(2*nfreq)\n \n #Compute the mean, variance\n ave = y.mean()\n ##sample variance because the divisor is N-1\n var = ((y-y.mean())**2).sum()/(len(y)-1) \n # and range of the data.\n xmin = x.min()\n xmax = x.max()\n xdif = xmax-xmin\n\n #extirpolate the data into the workspaces\n wk1 = np.zeros(ndim, dtype='complex')\n wk2 = np.zeros(ndim, dtype='complex')\n\n fac = ndim/(xdif*ofac)\n fndim = ndim\n ck = ((x-xmin)*fac) % fndim\n ckk = (2.0*ck) % fndim\n\n for j in range(0L, n):\n __spread__(y[j]-ave,wk1,ndim,ck[j],MACC)\n __spread__(1.0,wk2,ndim,ckk[j],MACC)\n\n #Take the Fast Fourier Transforms\n wk1 = np.fft.ifft( wk1 )*len(wk1)\n wk2 = np.fft.ifft( wk2 )*len(wk1)\n\n wk1 = wk1[1:nout+1]\n wk2 = wk2[1:nout+1]\n rwk1 = wk1.real\n iwk1 = wk1.imag\n rwk2 = wk2.real\n iwk2 = wk2.imag\n \n df = 1.0/(xdif*ofac)\n \n #Compute the Lomb value for each frequency\n hypo2 = 2.0 * abs( wk2 )\n hc2wt = rwk2/hypo2\n hs2wt = iwk2/hypo2\n\n cwt = np.sqrt(0.5+hc2wt)\n swt = np.sign(hs2wt)*(np.sqrt(0.5-hc2wt))\n den = 0.5*n+hc2wt*rwk2+hs2wt*iwk2\n cterm = (cwt*rwk1+swt*iwk1)**2./den\n sterm = (cwt*iwk1-swt*rwk1)**2./(n-den)\n\n wk1 = df*(np.arange(nout, dtype='float')+1.)\n wk2 = (cterm+sterm)/(2.0*var)\n pmax = wk2.max()\n jmax = wk2.argmax()\n\n\n #Significance estimation\n #expy = exp(-wk2) \n #effm = 2.0*(nout)/ofac \n #sig = effm*expy\n #ind = (sig > 0.01).nonzero()\n #sig[ind] = 1.0-(1.0-expy[ind])**effm\n\n #Estimate significance of largest peak value\n expy = np.exp(-pmax) \n effm = 2.0*(nout)/ofac \n prob = effm*expy\n\n if prob > 0.01: \n prob = 1.0-(1.0-expy)**effm\n\n return wk1,wk2,nout,jmax,prob","def test_fft_complex_3d():\n\ta, b, c = np.meshgrid([0, 1, 0, 0], [0, 1j, 1j], [0, 1, 1, 1])\n\tdummy_array = xr.DataArray(a * b * c, dims=['x', 'y', 'z'])\n\tchunked_array = dummy_array.chunk(chunks={'x': 2, 'y': 2, 'z': 2})\n\tspectrum_array, spectrum_coords, spectrum_dims = \\\n\t\txfft._fft(chunked_array, nfft={'x': 8, 'y': 6, 'z': 8},\n\t\t dim=['x', 'y', 'z'], dx={'x':12, 'y': 0.01, 'z': 0.02})\n\tassert np.allclose(spectrum_array.compute(),\n\t np.fft.fftn(a * b * c, s=(8, 6, 8)))\n\tassert np.array_equal(spectrum_coords['f_x'], np.fft.fftfreq(8, d=12))\n\tassert np.array_equal(spectrum_coords['f_y'], np.fft.fftfreq(6, d=0.01))\n\tassert np.array_equal(spectrum_coords['f_z'], np.fft.fftfreq(8, d=0.02))\n\tassert ('f_x', 'f_y', 'f_z') == spectrum_dims","def frft(f, a):\n ret = numpy.zeros_like(f, dtype=numpy.complex)\n f = f.copy().astype(numpy.complex)\n N = len(f)\n shft = numpy.fmod(numpy.arange(N) + numpy.fix(N / 2), N).astype(int)\n sN = numpy.sqrt(N)\n a = numpy.remainder(a, 4.0)\n\n # Special cases\n if a == 0.0:\n return f\n if a == 2.0:\n return numpy.flipud(f)\n if a == 1.0:\n ret[shft] = numpy.fft.fft(f[shft]) / sN\n return ret\n if a == 3.0:\n ret[shft] = numpy.fft.ifft(f[shft]) * sN\n return ret\n\n # reduce to interval 0.5 < a < 1.5\n if a > 2.0:\n a = a - 2.0\n f = numpy.flipud(f)\n if a > 1.5:\n a = a - 1\n f[shft] = numpy.fft.fft(f[shft]) / sN\n if a < 0.5:\n a = a + 1\n f[shft] = numpy.fft.ifft(f[shft]) * sN\n\n # the general case for 0.5 < a < 1.5\n alpha = a * numpy.pi / 2\n tana2 = numpy.tan(alpha / 2)\n sina = numpy.sin(alpha)\n f = numpy.hstack((numpy.zeros(N - 1), sincinterp(f), numpy.zeros(N - 1))).T\n\n # chirp premultiplication\n chrp = numpy.exp(-1j * numpy.pi / N * tana2 / 4 *\n numpy.arange(-2 * N + 2, 2 * N - 1).T ** 2)\n f = chrp * f\n\n # chirp convolution\n c = numpy.pi / N / sina / 4\n tmp = numpy.exp(1j * c * numpy.arange(-(4 * N - 4), 4 * N - 3).T ** 2)\n ret = scipy.signal.fftconvolve(\n numpy.exp(1j * c * numpy.arange(-(4 * N - 4), 4 * N - 3).T ** 2),\n f\n )\n ret = ret[4 * N - 4:8 * N - 7] * numpy.sqrt(c / numpy.pi)\n\n # chirp post multiplication\n ret = chrp * ret\n\n # normalizing constant\n ret = numpy.exp(-1j * (1 - a) * numpy.pi / 4) * ret[N - 1:-N + 1:2]\n\n return ret","def fft_checking(filename):\n\n # print out experimental parameters and store the case name\n casename, Re, We = file_id(filename)\n\n # load the data into three numpy arrays\n frames, left_edges, right_edges = np.loadtxt(filename, delimiter=',',\n unpack=True)\n # create a new numpy array which converts the frames into time by using\n # the frame rate\n frame_time = frames/27000\n # calculating the jet diameter (numpy array)\n jet_diameter = 0.02*(right_edges-left_edges)\n # calculating the jet centroid (numpy array)\n jet_centroid = 0.02*0.5*(right_edges+left_edges)\n\n # setting up plots for left and right edges\n fig, ax = plt.subplots()\n # plotting left edge\n ax.plot(frame_time, left_edges)\n # plotting right edge\n ax.plot(frame_time, right_edges, '.')\n ax.set_xlabel('frame_time (seconds)')\n ax.set_ylabel('Pixels')\n ax.set_title('Edges plot')\n\n # plotting jet diameter\n fig1, ax1 = plt.subplots()\n ax1.plot(frame_time, jet_diameter)\n ax1.set_xlabel('frame_time (seconds)')\n ax1.set_ylabel('Jet diameter (mm)')\n ax1.set_title('Jet diameter plot')\n\n # plotting jet centroid\n fig2, ax2 = plt.subplots()\n ax2.plot(frame_time, jet_centroid)\n ax2.set_xlabel('frame_time (seconds)')\n ax2.set_ylabel('Jet centroid location (mm)')\n ax2.set_title('Jet centroid plot')\n\n # shifted FFTs\n # Shifted jet diameter plotting\n shifted_jet_diameter = jet_diameter - np.mean(jet_diameter)\n fig5, ax5 = plt.subplots()\n ax5.plot(frame_time, shifted_jet_diameter)\n ax5.set_title(\"Shifted jet diameter\")\n ax5.set_xlabel('frame_time (seconds)')\n ax5.set_ylabel('Shifted jet diameter (mm)')\n\n # shifted jet diameter fft\n shifted_jet_diameter_fft = rfft(shifted_jet_diameter)\n shifted_jet_diameter_freqs = rfftfreq(len(shifted_jet_diameter), 1/27000)\n\n fig6, ax6 = plt.subplots()\n ax6.stem(shifted_jet_diameter_freqs, np.abs(shifted_jet_diameter_fft))\n ax6.set_title('Shifted jet diameter FFT')\n ax6.set_xlabel('Frequencies')\n ax6.set_ylabel('Amplitude')\n\n # shifted jet centroid plotting\n shifted_jet_centroid = jet_centroid - np.mean(jet_centroid)\n fig7, ax7 = plt.subplots()\n ax7.plot(frame_time, shifted_jet_centroid)\n ax7.set_title(\"Shifted jet centroid\")\n ax7.set_xlabel('frame_time (seconds)')\n ax7.set_ylabel('Shifted jet centroid (mm)')\n\n # shifted jet centroid fft\n shifted_jet_centroid_fft = rfft(shifted_jet_centroid)\n shifted_jet_centroid_freqs = rfftfreq(len(shifted_jet_centroid), 1/27000)\n\n fig8, ax8 = plt.subplots()\n ax8.stem(shifted_jet_centroid_freqs, np.abs(shifted_jet_centroid_fft))\n ax8.set_title('Shifted jet centroid FFT')\n ax8.set_xlabel('Frequencies')\n ax8.set_ylabel('Amplitude')\n\n zero_events = np.count_nonzero(jet_diameter == 0)\n\n print('Number of zero events:', zero_events)\n print(\"Percentage of total:\", zero_events/len(jet_diameter)*100)\n print('Number of frames:', len(frames))","def __get_rfft():\n try:\n import pyfftw\n import os\n pyfftw.interfaces.cache.enable()\n pyfftw.interfaces.cache.set_keepalive_time(5)\n if pyfftw.config.NUM_THREADS == 1:\n pyfftw.config.NUM_THREADS = \\\n len(os.sched_getaffinity(0)) if hasattr(os, 'sched_getaffinity') else os.cpu_count()\n pyfftw.config.PLANNER_EFFORT = 'FFTW_MEASURE'\n\n def rfftn(*args, **kwargs):\n return pyfftw.interfaces.numpy_fft.rfftn(*args, overwrite_input=True, **kwargs)\n def irfftn(*args, **kwargs):\n return pyfftw.interfaces.numpy_fft.irfftn(*args, overwrite_input=True, **kwargs)\n empty_aligned = pyfftw.empty_aligned\n\n except ImportError:\n from numpy.fft import rfftn, irfftn\n empty_aligned = empty\n\n return rfftn, irfftn, empty_aligned","def calc_corr(f, f_unc, g, g_unc, fac, fac_unc):\n # calculate the covariance between f and g\n # cov(f,g) = (df/dfac) * (dg/dfac) * fac_unc**2\n # in this case f=x/fac, g=y/fac\n # so cov(f,g) = f * g * fac_unc**2 / fac**2\n cov = f * g * fac_unc ** 2 / fac ** 2\n\n # calculate and return the correlation coefficient between f and g\n # corr = cov(f,g) / (f_unc * g_unc)\n return cov / (f_unc * g_unc)","def test_rtf_evd(self):\n n_fft_bin = 10\n channel = 4\n specgram = np.random.random((n_fft_bin, channel)) + np.random.random((n_fft_bin, channel)) * 1j\n psd = np.einsum(\"fc,fd->fcd\", specgram.conj(), specgram)\n rtf = beamform_utils.rtf_evd_numpy(psd)\n rtf_audio = F.rtf_evd(torch.tensor(psd, dtype=self.complex_dtype, device=self.device))\n self.assertEqual(torch.tensor(rtf, dtype=self.complex_dtype, device=self.device), rtf_audio)","def autocorrelation_1d(data):\n\n N = len(data)\n n_fft = select_power_of_two(N)\n\n # Pad the signal with zeros to avoid the periodic images.\n\n R_data = np.zeros(2*n_fft)\n R_data[:N] = data\n\n F_data = np.fft.fft(R_data)\n\n result = np.fft.ifft(F_data*F_data.conj())[:N].real/(N-np.arange(N))\n\n return result[:N]","def xcorr(t, x, y, zeropad=True):\n tau = t\n # sx = len(x)\n # sy = len(y)\n if zeropad is True:\n Xn = np.fft.rfft(x, n=len(x) * 2)\n Yn = np.conj(sp.fft(y, n=len(x) * 2))\n else:\n Xn = np.fft.rfft(x)\n Yn = np.conj(np.fft.rfft(y))\n\n xcor = np.real(fftpack.fftshift(sp.ifft(Xn * Yn)))\n dt = t[1] - t[0]\n\n tau = np.linspace(-len(xcor) / 2 * dt - dt / 2,\n len(xcor) / 2 * dt - dt / 2, len(xcor))\n return tau, xcor","def BLUE_simple_flatfield_corr(flat, real):\n real=real.astype(np.float64)\n flat=flat.astype(np.float64)\n\n \n row_averages=[]\n for row in real:\n row_median=np.median(row)\n row_averages.append(row_median)\n plt.plot(np.linspace(0,len(row_averages), len(row_averages)),row_averages)\n plt.show()\n plt.close()\n \n row_averages=[]\n for row in flat:\n row_median=np.median(row)\n row_averages.append(row_median)\n plt.plot(np.linspace(0,len(row_averages), len(row_averages)),row_averages, color=\"red\")\n \n \n target_average=np.median(row_averages[700:])\n F_row_average=row_averages.copy()\n k=(row_averages[750]-row_averages[1500])/750\n \n for i in range(1501):\n F_row_average[1500-i]=row_averages[1500]+k*i\n for i in range(len(row_averages)-1500):\n F_row_average[1500+i]=row_averages[1500]-k*i\n plt.plot(np.linspace(0,len(row_averages), len(row_averages)),F_row_average, color=\"blue\")\n \n C=np.copy(real)\n for i, row in enumerate(flat, start=0):\n row_median=np.median(row)\n row_averages[i]=row_averages[i]/(row_median/target_average)\n gain=row_median/F_row_average[i]\n C[i]=C[i]/gain\n plt.plot(np.linspace(0,len(row_averages), len(row_averages)),row_averages, color=\"green\") \n plt.show()\n plt.close()\n \n return C","def test_pattern_correlation(self):\n x = self.D.copy()\n\n # correlation with random values\n y = self.D.copy()\n tmp = np.random.random(y.shape)\n y.data = np.ma.array(tmp, mask=tmp != tmp)\n P2 = PatternCorrelation(x, y)\n P2._correlate()\n self.assertEqual(x.nt,len(P2.r_value))\n self.assertEqual(x.nt,len(P2.t))\n\n for i in xrange(x.nt):\n slope, intercept, r_value, p_value, std_err = stats.mstats.linregress(x.data[i,:,:].flatten(),y.data[i,:,:].flatten())\n self.assertEqual(P2.r_value[i], r_value)\n self.assertEqual(P2.p_value[i], p_value)\n self.assertEqual(P2.slope[i], slope)\n self.assertEqual(P2.intercept[i], intercept)\n self.assertEqual(P2.std_err[i], std_err)","def build_oblique_foF2_observed_by_radar(rad=\"cvw\", dates=[dt.datetime(2017,8,21), dt.datetime(2017,8,21)], bmnum=11, scan_num=1,\n remove_first_range=800, remove_last_range=2500, power_drop=10., plot=True):\n csv_fname = \"data/{rad}_{start}_{end}.csv\".format(rad=rad, start=dates[0].strftime(\"%Y.%m.%d.%H.%M\"), \n end=dates[1].strftime(\"%Y.%m.%d.%H.%M\"))\n if not os.path.exists(csv_fname):\n fdata = FetchData( rad, [dates[0], dates[1]] )\n s_params = [\"noise.sky\", \"tfreq\", \"frang\", \"rsep\", \"scan\", \"bmnum\"]\n v_params = [\"slist\", \"v\", \"w_l\", \"p_l\", \"elv\"]\n _, scans = fdata.fetch_data(by=\"scan\", s_params=s_params, v_params=v_params)\n beams = []\n # Resacle tx_frequency and estimate slant range \n for scan in scans:\n for beam in scan.beams:\n if len(beam.slist) > 0:\n setattr(beam, \"slant_range\", beam.frang + np.array(beam.slist.tolist()) * beam.rsep)\n setattr(beam, \"tfreq\", np.round(beam.tfreq/1e3,1))\n beams.append(beam)\n # Extract oblique foF2 or MUF scan by scan\n print(\"\\n Data will be averaged over {} scans\".format(scan_num))\n print(\" Processing beam {}\".format(bmnum))\n print(\" Remove first range {}\".format(remove_first_range))\n print(\" Remove last range {}\".format(remove_last_range))\n print(\" Power drop {}\".format(power_drop))\n skip_distance, o_foF2, time_start, time_end = [], [], [], []\n for i in range(len(scans)-scan_num):\n rscan = scans[i:i+scan_num]\n p_l, srange, tfrq, angle = [], [], [], []\n for scan in rscan:\n for beam in scan.beams:\n if beam.bmnum == bmnum:\n if len(beam.slist) > 0:\n p_l.extend(beam.p_l.tolist())\n srange.extend(beam.slant_range.tolist())\n tfrq.append(beam.tfreq)\n if type(beam.elv) is list: angle.extend(beam.elv)\n else: angle.extend(beam.elv.tolist())\n du = pd.DataFrame()\n du[\"p_l\"], du[\"srange\"] = p_l, srange\n du = du[(du.srange>remove_first_range) & (du.srange<remove_last_range)]\n fname = \"images/{}.png\".format(rscan[0].stime.strftime(\"%Y-%m-%d-%H-%M\"))\n if len(du) > 0:\n sd = fit_lambda(du, power_drop, tfreq=np.mean(tfrq), elv=np.mean(angle).round(1), \n xlabel=\"srange\", ylabel=\"p_l\", fname=fname, plot=plot)\n if sd != np.nan:\n skip_distance.append(sd)\n o_foF2.append(np.mean(tfrq))\n time_start.append(rscan[0].stime)\n time_end.append(rscan[-1].stime)\n df = pd.DataFrame()\n df[\"skip_distance\"], df[\"o_foF2\"], df[\"time_start\"], df[\"time_end\"] = skip_distance, o_foF2, time_start, time_end\n df.to_csv(csv_fname, index=False, header=True)\n else: df = pd.read_csv(csv_fname, parse_dates=[\"time_start\", \"time_end\"])\n print(\" Header:\\n\",df.head())\n return df","def corfftc(z, Z_cum, N, M, HR, HS, HH):\n # 2-D FFT\n Z = np.zeros((N[2], M[1]), dtype=complex)\n if M[3]:\n idLeft = np.concatenate((np.array(range(M[0]+M[3])), np.array(range(M[3]))+M[2]-M[3]))\n idRight = np.concatenate((np.array(range(M[0]+M[3]))+M[3], np.array(range(M[3]))))\n z[:, idLeft] = z[:, idRight];\n else:\n zTmp = np.zeros((z.shape[0], M[2]), dtype=complex)\n zTmp[:z.shape[0], :z.shape[1]] = z\t\n z = zTmp\n for n in range(int(N[0]+N[3]*2)):\n R1 = np.fft.fft(z[n, :]);\n Z[n, :] = R1[:int(M[1])];\n for m in range(int(M[1])):\n Z[:, m] = np.fft.fft(Z[:, m]);\n # cumulation\n R1 = np.dot(HR[:, np.newaxis], HS[:, np.newaxis].T);\n HH = HH + R1 * np.conj(R1);\n Z_cum = Z_cum + R1 * Z;\n return Z_cum, HH","def test_sff_corrector():\n # The following csv file, provided by Vanderburg and Johnson\n # at https://www.cfa.harvard.edu/~avanderb/k2/ep60021426.html,\n # contains the results of applying SFF to EPIC 60021426.\n fn = get_pkg_data_filename('./data/ep60021426alldiagnostics.csv')\n data = np.genfromtxt(fn, delimiter=',', skip_header=1)\n mask = data[:, -2] == 0 # indicates whether the thrusters were on or off\n time = data[:, 0]\n raw_flux = data[:, 1]\n corrected_flux = data[:, 2]\n centroid_col = data[:, 3]\n centroid_row = data[:, 4]\n arclength = data[:, 5]\n correction = data[:, 6]\n\n lc = LightCurve(time=time, flux=raw_flux)\n sff = SFFCorrector(lc)\n corrected_lc = sff.correct(centroid_col=centroid_col,\n centroid_row=centroid_row,\n niters=1, windows=1)\n # do hidden plots execute smoothly?\n sff._plot_rotated_centroids()\n sff._plot_normflux_arclength()\n\n # the factor self.bspline(time-time[0]) accounts for\n # the long term trend which is divided out in order to get a \"flat\"\n # lightcurve.\n assert_almost_equal(corrected_lc.flux*sff.bspline(time),\n corrected_flux, decimal=3)\n assert_array_equal(time, corrected_lc.time)\n # the factor of 4 below accounts for the conversion\n # between pixel units to arcseconds\n assert_almost_equal(4*sff.s, arclength, decimal=2)\n assert_almost_equal(sff.interp(sff.s), correction, decimal=3)\n\n # test using KeplerLightCurve interface\n klc = KeplerLightCurve(time=time, flux=raw_flux, centroid_col=centroid_col,\n centroid_row=centroid_row)\n klc = klc.correct(niters=1, windows=1)\n sff = klc.corrector\n\n assert_almost_equal(klc.flux*sff.bspline(time),\n corrected_flux, decimal=3)\n assert_almost_equal(4*sff.s, arclength, decimal=2)\n assert_almost_equal(sff.interp(sff.s), correction, decimal=3)\n assert_array_equal(time, klc.time)","def test_crf():\n\n print '\\n\\ttest crf'\n os.system('crf_test -m ' + model_file + ' ' + test_file_crf + ' -o ' + encoded_test)\n print '\\t--done'","def get_cffts(self):\n return [\n rfft(self.nx, self.dx, fft=self.tfft, ny=self.ny,\n dy=self.dy).get_cfft(),\n rfft(self.nx, self.dx, fft=self.efft, ny=self.ny,\n dy=self.dy).get_cfft(),\n rfft(self.nx, self.dx, fft=self.bfft, ny=self.ny,\n dy=self.dy).get_cfft()\n ]","def downsampleConvolveROTF(img, rotf, newfullsize, maxdim=3):\n # def grad(dy, variables=['tfin','otf']):\n axes = None\n if maxdim is not None:\n axes = [d for d in range(-maxdim, 0)] # transform along all the axes within the maxdim range\n\n myrft = rft(img, axes=axes)\n oldfullsize = img.shape\n res = resampleRFT(myrft, rotf.shape, oldfullsize, newfullsize, maxdim=maxdim)\n newfullsz = res.shape[:-len(newfullsize)] + tuple(newfullsize)\n newfullsz = np.array(newfullsz)\n res = irft(res * rotf, newfullsz, axes=axes)\n mypixelsize = image.getPixelsize(img)\n if mypixelsize is not None:\n res.set_pixelsize(mypixelsize, factors=np.array(img.shape) / np.array(res.shape))\n else:\n res.pixelsize = None\n return res","def Coherence(wfr, Fx = 1/3, Fy = 1/3, pathX = None, pathY = None, pathC = None, pathCL = None, pathI = None):\n \n print(\"----Starting Coherence Function---\")\n \n Sx = int(Fx*wfr.params.Mesh.nx)\n Sy = int(Fy*wfr.params.Mesh.ny)\n print(\"Sampled area (pixels): {}\".format([Sx,Sy]))\n \n if Sx > 120 or Sy > 120:\n print(\"Error: Sampled area of wavefront is too large. Change Fx/Fy to a smaller value\")\n import sys\n sys.exit()\n \n start1 = time.time()\n cfr = getComplex(wfr)\n print(\"Shape of Complex Wavefield: {}\".format(np.shape(cfr)))\n end1 = time.time()\n print('Time taken to convert to complex wavefield (s): {}'.format(end1 - start1))\n \n _x0 = 0 # These are in _pixel_ coordinates!!\n _y0 = 0\n _x1 = int(np.max(np.shape(cfr[:,0,0]))) # These are in _pixel_ coordinates!!\n _y1 = int(np.max(np.shape(cfr[0,:,0])))\n \n print(\"Nx (pixels): {}\".format(_x1))\n print(\"Ny (pixels): {}\".format(_y1))\n \n numx = _x1 - _x0 # number of points for line profile\n numy = _y1 - _y0\n midX = int(numx/2)\n midY = int(numy/2)\n \n print(\"mid x: {}\".format(midX))\n print(\"mid y: {}\".format(midY))\n\n # # Fraction of wavefront to calculate coherence over\n # Fx = 1/3\n # Fy = 1/3\n \n ROI = ((int(midX-((Fx)*midX)),int(midY-((Fy)*midY))),\n (int(midX+((Fx)*midX)),int(midY+((Fy)*midY)))) \n \n lX = ROI[1][0]-ROI[0][0]\n lY = ROI[1][1]-ROI[0][1]\n \n print(\"Region of interest (pixels): {}\".format((lX,lY)))\n \n x0,y0 = ROI[0][0], ROI[0][1]\n x1,y1 = ROI[1][0], ROI[1][1]\n \n A = cfr[y0:y1,x0:x1]\n \n A_x1 = int(np.max(np.shape(A[:,0,0]))) # These are in _pixel_ coordinates!!\n A_y1 = int(np.max(np.shape(A[0,:,0])))\n \n print(\"Nx (pixels): {}\".format(_x1))\n print(\"Ny (pixels): {}\".format(_y1))\n \n Anumx = A_x1 # number of points for line profile\n Anumy = A_y1\n AmidX = int(Anumx/2)\n AmidY = int(Anumy/2)\n \n \n \"\"\" Cross Spectral Density (W) & Mutual Intensity Functions (Jx,Jy) \"\"\"\n start2 = time.time()\n B = np.array([A.conjugate() * a for a in A.flatten()])#[:,:,:,0] \n Bx = np.array([A[:,AmidY].conjugate() * a for a in A[:,AmidY]])\n By = np.array([A[AmidX,:].conjugate() * a for a in A[AmidX,:]])\n end2 = time.time()\n print('Time taken to calculate Mutual Intensity [J] (s): {}'.format(end2 - start2))\n \n print(\"Shape of B: {}\".format(np.shape(B)))\n print(\"Shape of Bx: {}\".format(np.shape(Bx)))\n print(\"Shape of By: {}\".format(np.shape(By)))\n \n C = abs(B.mean(0))\n # Cx = abs(Bx.mean(0))\n # Cy = abs(By.mean(0))\n \n print(\"Shape of C: {}\".format(np.shape(C)))\n # print(\"Shape of Cx: {}\".format(np.shape(Cx)))\n # print(\"Shape of Cy: {}\".format(np.shape(Cy)))\n \n \n # if wfr is Wavefront():\n Dx = Fx*wfr.params.Mesh.xMax - Fx*wfr.params.Mesh.xMin\n Dy = Fy*wfr.params.Mesh.yMax - Fy*wfr.params.Mesh.yMin\n # # else:\n # # Dx = Fx*wfr.mesh.xFin - Fx*wfr.mesh.xStart\n # # Dy = Fy*wfr.mesh.yfin - Fy*wfr.mesh.yStart\n \n \n \"\"\" Creating array of custom tick markers for plotting \"\"\"\n tickAx = [round_sig(-Dx*1e6/2),round_sig(-Dx*1e6/4),0,round_sig(Dx*1e6/4),round_sig(Dx*1e6/2)]\n tickAy = [round_sig(Dy*1e6/2),round_sig(Dy*1e6/4),0,round_sig(-Dy*1e6/4),round_sig(-Dy*1e6/2)]\n \n print(\"Array of horizontal markers: {}\".format(tickAx))\n print(\"Array of vertical markers: {}\".format(tickAy))\n \n plt.imshow(abs(Bx))#,vmin=np.min(C),vmax=np.max(C))\n plt.title(\"Mutual Intensity (x1-x0)\")\n plt.colorbar()\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\n plt.yticks(np.arange(0,lY+1,lY/4),tickAy)\n plt.xlabel(\"Horizontal Position [\\u03bcm]\")#\"(\\u03bcm)\")\n plt.ylabel(\"Vertical Position [\\u03bcm]\")#\"(\\u03bcm)\")\n if pathX != None:\n print(\"Saving (x1-x0) figure to path: {}\".format(pathX))\n plt.savefig(pathX)\n plt.show() \n \n plt.imshow(abs(By))#,vmin=np.min(C),vmax=np.max(C))\n plt.title(\"Mutual Intensity (y1-y0)\")\n plt.colorbar()\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\n plt.yticks(np.arange(0,lY+1,lY/4),tickAy)\n plt.xlabel(\"Horizontal Position [\\u03bcm]\")#\" (\\u03bcm)\")\n plt.ylabel(\"Vertical Position [\\u03bcm]\")#\"(\\u03bcm)\")\n if pathY != None:\n print(\"Saving (y1-y0) figure to path: {}\".format(pathY))\n plt.savefig(pathY)\n plt.show() \n \n \"\"\" Normalised Degree of Coherence \"\"\"\n U = 1-(abs((C)/(A.conjugate()*A)))\n \n \n \"\"\" Taking line profiles through U \"\"\"\n X = U[0:int(np.max(np.shape(U[:,0]))), int((y1-y0)/2)]\n Y = U[int((x1-x0)/2), 0:int(np.max(np.shape(U[0,:])))]\n \n # print(x0,x1)\n # print(y0,y1)\n \n \n print(\"Sampled area dimensions (m): {}\".format([Dx,Dy]))\n \n pX = Dx/lX\n pY = Dy/lY\n \n print(\"Pixel size (m): {}\".format([pX,pY]))\n print(\"Shape of U (pixels): {}\".format(np.shape(U)))\n \n \n \"\"\"Plotting\"\"\"\n plt.imshow(U ,vmin=0,vmax=1)\n plt.title(\"Degree of Coherence (1/\\u03bc)\")\n plt.colorbar()\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\n plt.yticks(np.arange(0,lY+1,lY/4),tickAy)\n plt.xlabel(\"Horizontal Position [\\u03bcm]\")#\"(\\u03bcm)\")\n plt.ylabel(\"Vertical Position [\\u03bcm]\")#\"(\\u03bcm)\")\n if pathC != None:\n print(\"Saving Degree of Coherence figure to path: {}\".format(pathC))\n plt.savefig(pathC)\n plt.show() \n \n plt.plot(X, label=\"Horizontal Profile\")\n plt.plot(Y, label=\"Vertical Profile\")\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\n plt.xlabel(\"Horizontal Position [\\u03bcm]\")#\"(\\u03bcm)\")\n plt.ylim(0,1.1)\n if pathCL != None:\n print(\"Saving line profile figure to path: {}\".format(pathCL))\n plt.savefig(pathCL)\n # locs, labels = plt.xticks()\n # labels = [round(float(item)*pX*1e7, 2 - int(math.floor(math.log10(abs(float(item)*pX*1e7)))) - 1) for item in locs]\n # plt.xticks(locs, labels)\n plt.legend()\n \n # round(float(item)*pX*1e7, 2 - int(math.floor(math.log10(abs(float(item)*pX*1e7)))) - 1)\n plt.show()\n \n # print('coherence array shape: {}'.format(np.shape(B)))\n # plt.plot(B)\n # plt.show()\n \n # D = np.reshape(B,())\n \n plt.imshow(abs(A.conjugate()*A))\n plt.title(\"intensity\")\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\n plt.yticks(np.arange(0,lY+1,lY/4),tickAy)\n plt.xlabel(\"Horizontal Position [\\u03bcm]\")#\"(\\u03bcm)\")\n plt.ylabel(\"Vertical Position [\\u03bcm]\")#\"(\\u03bcm)\")\n plt.colorbar()\n if pathI != None:\n print(\"Saving intensity figure to path: {}\".format(pathI))\n plt.savefig(pathI)\n plt.show()\n \n return B ,Dx, Dy","def do_fft(self, cs_data):\n\n for fbin in range(self.fft_bins):\n idx1 = int(fbin * floor(nfft * (1. - overlap)))\n idx2 = idx1 + nfft\n\n sx = cs_data[:, idx1:idx2]\n\n if detrend == 1:\n sx = detrend(sx, type='linear', axis=1)\n sx = detrend(sx, type='constant', axis=1) # subtract mean\n\n sx = sx * win # apply window function\n\n # get fft\n SX = np.fft.fft(sx, n=nfft)/nfft # divide by the length\n if np.mod(nfft, 2) == 0: # even nfft\n SX = np.hstack([SX[0:int(nfft/2)], np.conj(SX[int(nfft/2)]), SX[int(nfft/2):nfft]])\n if full == 1: # shift to -fN ~ 0 ~ fN\n SX = np.fft.fftshift(SX)\n else: # half 0 ~ fN\n SX = SX[0:int(nfft/2+1)]\n\n fftdata[b,:] = SX\n\n return ax, fftdata, win_factor","def test_conv2d_fft(self):\n\t\t\n\t\tdetails = self.watcher.describe(layers=[self.first_layer], conv2d_fft=True)\n\t\tprint(details)\n\t\t\n\t\tdetails = self.watcher.analyze(layers=[self.first_layer], conv2d_fft=True)\n\t\tactual = details.alpha.to_numpy()[0]\n\t\texpected = 2.144\n\t\tself.assertAlmostEqual(actual,expected, delta=0.01)","def test_frustum_planes_ring_cam() -> None:\n near_clip_dist = 6.89 # arbitrary value\n\n # Set \"focal_length_x_px_\"\n fx_px = 1402.4993697398709\n\n # Set \"focal_length_y_px_\"\n fy_px = 1405.1207294310225\n\n # Set \"focal_center_x_px_\"\n cx_px = 957.8471720086527\n\n # Set \"focal_center_y_px_\"\n cy_px = 600.442948946496\n\n camera_name = \"ring_front_right\"\n height_px = 1550\n width_px = 2048\n\n pinhole_camera = _create_pinhole_camera(\n fx_px=fx_px,\n fy_px=fy_px,\n cx_px=cx_px,\n cy_px=cy_px,\n height_px=height_px,\n width_px=width_px,\n cam_name=camera_name,\n )\n (\n left_plane,\n right_plane,\n near_plane,\n bottom_plane,\n top_plane,\n ) = pinhole_camera.frustum_planes(near_clip_dist)\n\n left_plane_expected: NDArrayFloat = np.array([fx_px, 0.0, width_px / 2.0, 0.0])\n right_plane_expected: NDArrayFloat = np.array([-fx_px, 0.0, width_px / 2.0, 0.0])\n near_plane_expected: NDArrayFloat = np.array([0.0, 0.0, 1.0, -near_clip_dist])\n bottom_plane_expected: NDArrayFloat = np.array([0.0, -fx_px, height_px / 2.0, 0.0])\n top_plane_expected: NDArrayFloat = np.array([0.0, fx_px, height_px / 2.0, 0.0])\n\n assert np.allclose(\n left_plane, left_plane_expected / np.linalg.norm(left_plane_expected)\n )\n assert np.allclose(\n right_plane, right_plane_expected / np.linalg.norm(right_plane_expected)\n )\n assert np.allclose(\n bottom_plane, bottom_plane_expected / np.linalg.norm(bottom_plane_expected)\n )\n assert np.allclose(\n top_plane, top_plane_expected / np.linalg.norm(top_plane_expected)\n )\n assert np.allclose(near_plane, near_plane_expected)","def fftconvolve(in1, in2, mode=\"full\", axis=None):\n\ts1 = np.array(in1.shape)\n\ts2 = np.array(in2.shape)\n\tcomplex_result = (np.issubdtype(in1.dtype, np.complex) or\n\t\t\t\t\t np.issubdtype(in2.dtype, np.complex))\n\n\tif axis is None:\n\t\tsize = s1 + s2 - 1\n\t\tfslice = tuple([ slice(0, int(sz)) for sz in size ])\n\telse:\n\t\tequal_shapes = s1 == s2\n\t\t# allow equal_shapes[axis] to be False\n\t\tequal_shapes[ axis ] = True\n\t\tassert equal_shapes.all(), 'Shape mismatch on non-convolving axes'\n\t\tsize = s1[ axis ] + s2[ axis ] - 1\n\t\tfslice = [ slice(l) for l in s1 ]\n\t\tfslice[ axis ] = slice(0, int(size))\n\t\tfslice = tuple(fslice)\n\n\t# Always use 2**n-sized FFT\n\tfsize = 2**int(np.ceil(np.log2(size)))\n\tif axis is None:\n\t\tIN1 = fftpack.fftn(in1, fsize)\n\t\tIN1 *= fftpack.fftn(in2, fsize)\n\t\tret = fftpack.ifftn(IN1)[ fslice ].copy()\n\telse:\n\t\tIN1 = fftpack.fft(in1, fsize, axis=axis)\n\t\tIN1 *= fftpack.fft(in2, fsize, axis=axis)\n\t\tret = fftpack.ifft(IN1, axis=axis)[ fslice ].copy()\n\tdel IN1\n\tif not complex_result:\n\t\tret = ret.real\n\tif mode == \"full\":\n\t\treturn ret\n\telif mode == \"same\":\n\t\tif np.product(s1, axis=0) > np.product(s2, axis=0):\n\t\t\tosize = s1\n\t\telse:\n\t\t\tosize = s2\n\t\treturn signaltools._centered(ret, osize)\n\telif mode == \"valid\":\n\t\treturn signaltools._centered(ret, abs(s2 - s1) + 1)","def test_fft_spectrum_fieldtrip_01():\n ft_psd_dpss_3 = [0.00513886191307729, 0.00541235129368216, 0.00637327754180630, 0.00975873992634912, 0.0114961627430138, 0.0121812348620110, 0.0114278017545212, 0.0113668316543143, 0.0112161528645388, 0.0117016241464867]\n f0, Sxx0 = _fft(x, s_freq, detrend=None, taper='dpss', output='spectraldensity', sides='one', scaling='fieldtrip', halfbandwidth=3)\n assert_array_almost_equal(Sxx0[100:110], ft_psd_dpss_3, decimal=4)","def test_reciprocal_trig_functions(self):\r\n angles = ['-pi/4', 'pi/6', 'pi/5', '5*pi/4', '9*pi/4', '1 + j']\r\n sec_values = [1.414, 1.155, 1.236, -1.414, 1.414, 0.498 + 0.591j]\r\n csc_values = [-1.414, 2, 1.701, -1.414, 1.414, 0.622 - 0.304j]\r\n cot_values = [-1, 1.732, 1.376, 1, 1, 0.218 - 0.868j]\r\n\r\n self.assert_function_values('sec', angles, sec_values)\r\n self.assert_function_values('csc', angles, csc_values)\r\n self.assert_function_values('cot', angles, cot_values)\r\n\r\n arcsec_inputs = ['1.1547', '1.2361', '2', '-2', '-1.4142', '0.4983+0.5911*j']\r\n arcsec_angles = [0.524, 0.628, 1.047, 2.094, 2.356, 1 + 1j]\r\n self.assert_function_values('arcsec', arcsec_inputs, arcsec_angles)\r\n\r\n arccsc_inputs = ['-1.1547', '-1.4142', '2', '1.7013', '1.1547', '0.6215-0.3039*j']\r\n arccsc_angles = [-1.047, -0.785, 0.524, 0.628, 1.047, 1 + 1j]\r\n self.assert_function_values('arccsc', arccsc_inputs, arccsc_angles)\r\n\r\n # Has the same range as arccsc\r\n arccot_inputs = ['-0.5774', '-1', '1.7321', '1.3764', '0.5774', '(0.2176-0.868*j)']\r\n arccot_angles = arccsc_angles\r\n self.assert_function_values('arccot', arccot_inputs, arccot_angles)","def fftconvolve(in1, in2, mode=\"full\", axis=None):\r\n s1 = np.array(in1.shape)\r\n s2 = np.array(in2.shape)\r\n complex_result = (np.issubdtype(in1.dtype, np.complex) or\r\n np.issubdtype(in2.dtype, np.complex))\r\n\r\n if axis is None:\r\n size = s1 + s2 - 1\r\n fslice = tuple([slice(0, int(sz)) for sz in size])\r\n else:\r\n equal_shapes = s1 == s2\r\n # allow equal_shapes[axis] to be False\r\n equal_shapes[axis] = True\r\n assert equal_shapes.all(), 'Shape mismatch on non-convolving axes'\r\n size = s1[axis] + s2[axis] - 1\r\n fslice = [slice(l) for l in s1]\r\n fslice[axis] = slice(0, int(size))\r\n fslice = tuple(fslice)\r\n\r\n # Always use 2**n-sized FFT\r\n fsize = 2 ** int(np.ceil(np.log2(size)))\r\n if axis is None:\r\n IN1 = fftpack.fftn(in1, fsize)\r\n IN1 *= fftpack.fftn(in2, fsize)\r\n ret = fftpack.ifftn(IN1)[fslice].copy()\r\n else:\r\n IN1 = fftpack.fft(in1, fsize, axis=axis)\r\n IN1 *= fftpack.fft(in2, fsize, axis=axis)\r\n ret = fftpack.ifft(IN1, axis=axis)[fslice].copy()\r\n del IN1\r\n if not complex_result:\r\n ret = ret.real\r\n if mode == \"full\":\r\n return ret\r\n elif mode == \"same\":\r\n if np.product(s1, axis=0) > np.product(s2, axis=0):\r\n osize = s1\r\n else:\r\n osize = s2\r\n return signaltools._centered(ret, osize)\r\n elif mode == \"valid\":\r\n return signaltools._centered(ret, abs(s2 - s1) + 1)","def frfest(x, f, dt, windowname=\"hanning\", ave=bool(True), Hv=bool(False)):\n if len(f.shape) == 1:\n f = f.reshape(1, -1, 1)\n\n if len(x.shape) == 1:\n x = x.reshape(1, -1, 1)\n\n if len(f.shape) == 2:\n if (f.shape).index(max(f.shape)) == 0:\n f = f.reshape(max(f.shape), min(f.shape), 1)\n else:\n f = f.reshape(1, max(f.shape), min(f.shape))\n\n if len(x.shape) == 2:\n if (x.shape).index(max(x.shape)) == 0:\n x = x.reshape(max(x.shape), min(x.shape), 1)\n else:\n x = x.reshape(1, max(x.shape), min(x.shape))\n\n # Note: Two different ways to ignore returned values shown\n Pff = asd(f, dt, windowname=windowname)[1]\n freq, Pxf = crsd(x, f, dt, windowname=windowname)\n _, Pxx = asd(x, dt)\n\n # Note Pfx=conj(Pxf) is applied in the H1 FRF estimation\n Txf1 = np.conj(Pxf / Pff)\n Txf2 = Pxx / Pxf\n # Nulled to avoid output problems/simplify calls if unrequested\n Txfv = np.zeros_like(Txf1)\n\n coh = (Pxf * np.conj(Pxf)).real / Pxx / Pff\n\n if Hv:\n for i in np.arange(Pxx.shape[1]):\n frfm = np.array(\n [[Pff[0, i], np.conj(Pxf[0, i])], [Pxf[0, i], Pxx[0, i]]])\n\n alpha = 1 # np.sqrt(Pff[0,i]/Pxx[0,i])\n\n frfm = np.array([[Pff[0, i], alpha * np.conj(Pxf[0, i])],\n [alpha * Pxf[0, i], alpha**2 * Pxx[0, i]]])\n\n lam, vecs = la.eigh(frfm)\n\n index = lam.argsort()\n\n lam = lam[index]\n\n vecs = vecs[:, index]\n\n Txfv[0, i] = -(vecs[0, 0] / vecs[1, 0]) / alpha\n\n return freq, Txf1, Txf2, coh, Txfv","def coherence_partial(time_series, r, csd_method=None):\r\n\r\n if csd_method is None:\r\n csd_method = {'this_method': 'welch'} # The default\r\n\r\n f, fxy = get_spectra(time_series, csd_method)\r\n\r\n # Initialize c according to the size of f:\r\n c = np.zeros((time_series.shape[0],\r\n time_series.shape[0],\r\n f.shape[0]), dtype=complex)\r\n\r\n for i in range(time_series.shape[0]):\r\n for j in range(i, time_series.shape[0]):\r\n f, fxx, frr, frx = get_spectra_bi(time_series[i], r, csd_method)\r\n f, fyy, frr, fry = get_spectra_bi(time_series[j], r, csd_method)\r\n c[i, j] = coherence_partial_spec(fxy[i][j], fxy[i][i],\r\n fxy[j][j], frx, fry, frr)\r\n\r\n idx = tril_indices(time_series.shape[0], -1)\r\n c[idx[0], idx[1], ...] = c[idx[1], idx[0], ...].conj() # Make it symmetric\r\n\r\n return f, c","def fRCrim(Swe,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout):\n#\n# 1. Compute and normalise volumetric components:\n#\t-----------------------------------------------\n\tVw=PHIe*Swe\n\tVh=PHIe*(1-Swe)\n\tVwe=(Vw-Cwv)/(1-Cwv)\n\tVwe=ImposeLimits(Vwe,0,1)\n\tVke=(Vk-Ckv)/(1-Ckv)\n\tVke=ImposeLimits(Vke,0,1)\n\tSum=abs(Vc1)+abs(Vc2)+abs(Vc3)+abs(Vke)+abs(Vwe)+abs(Vh)\n\tVc1=abs(Vc1)/Sum\n\tVc2=abs(Vc2)/Sum\n\tVc3=abs(Vc3)/Sum\n\tVk=abs(Vk)/Sum\n\tVw=abs(Vw)/Sum\n\tVh=abs(Vh)/Sum\n#\n#\t2. Determine conductivity of components:\n#\t----------------------------------------\n\tSigc1=1/Rc1\n\tSigc2=1/Rc2\n\tSigc3=1/Rc3\n\tSigk=1/Rk\n\tSigw=1/Rw\n\tSigh=1/Rh\n#\n#\t3. Compute Conductivity:\n#\t========================\n\tTrm1=Vc1*(Sigc1**(1/Alpha))\n\tTrm2=Vc2*(Sigc2**(1/Alpha))\n\tTrm3=Vc3*(Sigc3**(1/Alpha))\n\tTrm4=(Vk**2.2)*(Sigk**(1/Alpha)) # Factor of 2.2 included to get data to fit to Yang et al\n\tTrm5=Vw*(Sigw**(1/Alpha))\n\tTrm6=Vh*(Sigh**(1/Alpha))\n\tCrf=(Trm1+Trm2+Trm3+Trm4+Trm5+Trm6)**Alpha\n#\n#\n# 4. Output result:\n#\t-----------------\n\tif(Tout==0):\n\t\tFr=Crf\n\telse:\n\t\tFr=1/Crf\n\treturn Fr","def test_simple(self):\n with self.subTest(\"from np array\"):\n data = np.random.rand(10, 4)\n mask = np.ones((10, 4))\n channels = [\"a\", \"b\", \"c\", \"d\"]\n fcs.FCSData((data, mask), channels=channels)","def test_CorrelationDecoder_smoke(testdata_laird, tmp_path_factory):\n testdata_laird = testdata_laird.copy()\n features = testdata_laird.get_labels(ids=testdata_laird.ids[0])[:5]\n\n # Make an image to decode\n meta = mkda.KDA(null_method=\"approximate\")\n res = meta.fit(testdata_laird)\n img = res.get_map(\"stat\")\n\n # Test: train decoder with Dataset object\n decoder = continuous.CorrelationDecoder(features=features)\n decoder.fit(testdata_laird)\n decoded_df = decoder.transform(img)\n\n assert isinstance(decoded_df, pd.DataFrame)\n\n # Get features and images to compare with other methods\n features = list(decoder.results_.maps.keys())\n images = np.array(list(decoder.results_.maps.values()))\n\n # Save images to disk to test load_imgs method\n tmpdir = tmp_path_factory.mktemp(\"test_CorrelationDecoder\")\n decoder.results_.save_maps(tmpdir)\n\n # Test: load pregenerated maps using a dictionary of feature names and paths\n img_dict = {feature: os.path.join(tmpdir, f\"{feature}.nii.gz\") for feature in features}\n decoder2 = continuous.CorrelationDecoder()\n decoder2.load_imgs(img_dict, mask=testdata_laird.masker)\n decoded2_df = decoder2.transform(img)\n\n features2 = list(decoder2.results_.maps.keys())\n images2 = np.array(list(decoder2.results_.maps.values()))\n\n assert isinstance(decoded2_df, pd.DataFrame)\n assert np.array_equal(features, features2)\n assert np.array_equal(images, images2)\n assert decoded_df.equals(decoded2_df)\n\n # Test: load pregenerated maps from a directory\n decoder3 = continuous.CorrelationDecoder()\n decoder3.load_imgs(tmpdir.as_posix(), mask=testdata_laird.masker)\n decoded3_df = decoder3.transform(img)\n\n features3 = list(decoder3.results_.maps.keys())\n images3 = np.array(list(decoder3.results_.maps.values()))\n\n assert isinstance(decoded3_df, pd.DataFrame)\n assert np.array_equal(features, features3)\n assert np.array_equal(images, images3)\n assert decoded_df.equals(decoded3_df)\n\n # Test: passing a dataset to load_imgs\n decoder4 = continuous.CorrelationDecoder()\n with pytest.raises(ValueError):\n decoder4.load_imgs(testdata_laird, mask=testdata_laird.masker)\n\n # Test: try loading pregenerated maps without a masker\n decoder5 = continuous.CorrelationDecoder()\n with pytest.raises(ValueError):\n decoder5.load_imgs(img_dict)\n\n # Test: try transforming an image without fitting the decoder\n decoder6 = continuous.CorrelationDecoder()\n with pytest.raises(AttributeError):\n decoder6.transform(img)","def process(self):\n\n # noise field generation\n proto = self.__generate_protoarray(self._n_x, self._n_y, self._variance_expected, self._r_corr_in_points)\n proto_shifted = fftshift(proto, axes=(0, 1))\n proto_fft_obj = ifft2(proto_shifted)\n proto_fft_normalized = self.__normalize_after_fft(proto_fft_obj())\n self._noise_field = proto_fft_normalized\n\n # initialization of arrays for real and imaginary parts\n self._noise_field_real, self._noise_field_imag = \\\n self._initialize_noise_arrays(self._noise_field, self._n_x, self._n_y)\n\n # autocorrelation functions calculation\n self._calculate_autocorrelations()","def test_MFT_flux_conservation(centering='FFTSTYLE', outdir=None, outname='test_MFT_flux', precision=0.01):\n\n # Set up constants for either a more precise test or a less precise but much \n # faster test:\n print(\"Testing MFT flux conservation for centering = \"+centering)\n if precision ==0.001:\n npupil = 800\n npix = 4096\n u = 400 # of lam/D. Must be <= the Nyquist frequency of the pupil sampling or there\n # will be aliased copies of the PSF.\n elif precision==0.01: \n npupil = 400\n npix = 2048\n u = 200 # of lam/D. Must be <= the Nyquist frequency of the pupil sampling or there\n # will be aliased copies of the PSF.\n else:\n raise NotImplementedError('Invalid value for precision.')\n\n\n\n # Create pupil\n ctr = (float(npupil)/2.0, float(npupil)/2.0 )\n pupil = makedisk(s=(npupil, npupil), c=ctr, r=float(npupil)/2.0001, t=np.float64, grey=0)\n pupil /= np.sqrt(pupil.sum())\n if outdir is not None:\n fits.PrimaryHDU(pupil.astype(np.float32)).writeto(outdir+os.sep+outname+\"pupil.fits\", clobber=True)\n\n # MFT setup style and execute\n mft = matrixDFT.MatrixFourierTransform(centering=centering, verbose=True)\n a = mft.perform(pupil, u, npix)\n\n pre = (abs(pupil)**2).sum() # normalized area of input pupil, should be 1 by construction\n post = (abs(a)**2).sum() # \n ratio = post / pre\n print \"Pre-FFT total: \"+str( pre)\n print \"Post-FFT total: \"+str( post )\n print \"Ratio: \"+str( ratio)\n\n\n\n if outdir is not None:\n complexinfo(a, str=\"mft1 asf\")\n asf = a.real.copy()\n fits.PrimaryHDU(asf.astype(np.float32)).writeto(outdir+os.sep+outname+\"asf.fits\", clobber=True)\n cpsf = a * a.conjugate()\n psf = cpsf.real.copy()\n #SF.SimpleFitsWrite(fn=outdir+os.sep+outname+\"psf.fits\", data=psf.astype(np.float32), clobber='y')\n fits.PrimaryHDU(psf.astype(np.float32)).writeto(outdir+os.sep+outname+\"psf.fits\", clobber=True)\n\n assert np.abs(1.0 - ratio) < precision","def inverseSTRF(specgram, rates=[1, 2, 4, 8, 16, 32], scales=[0.5, 1, 2, 4, 8], fl=8, tc=8, fac=-2, shift=0, full_T=0, full_X=0, BP=0, norm=.9, foutt=0, foutx=0):\n # Retrieve parameters\n K1 = len(rates)\n K2 = len(scales)\n N, M = lastN, lastM\n N1 = int(2**np.ceil(np.log2(N)))\n N2 = 2*N1\n M1 = int(2**np.ceil(np.log2(M)))\n M2 = 2*M1\n STF\t= 1000 / fl\n SRF\t= 24;\n M4 = np.floor(float(M)/2*full_X);\t# dM\n N4 = np.floor(float(N)/2*full_T);\t# dN\n HH = 0;\n Z_cum = 0;\n for rdx in range(K1):\n # rate filtering\n fc_rt = rates[rdx]\n HR = temporal_filter(fc_rt, N1, STF, [1+rdx+BP, K1+BP*2])\n for sgn in (1, -1):\n # rate filtering modification\n if sgn > 0:\n HR = np.conj(np.hstack((HR, np.zeros(N1))))\n else:\n HR = np.hstack( (HR[0], np.conj(HR[N2:0:-1])) )\n HR[N1] = np.abs(HR[N1+1]) \n for sdx in range(K2):\n # scale filtering\n fc_sc = scales[sdx]\n HS = frequency_filter(fc_sc, M1, SRF, [1+sdx+BP, K2+BP*2])\n z = np.squeeze(specgram[sdx, rdx+(sgn==1)*K1, :, :]).copy()\n # 2-D FFT and cumulation\n Z_cum, HH = corfftc(z, Z_cum, [N, N1, N2, N4], [M, M1, M2, M4], HR, HS, HH);\n #qlsdkjcn\n # normalization\n HH[:, 0] = HH[:, 0] * 2\n yh = cornorm(Z_cum, HH, [N, N1, N2, N4], [M, M1, M2, M4], norm, foutt, foutx);\n return yh","def test_solar_cc():\n\n features = ['clearsky_ratio', 'rsds', 'clearsky_ghi']\n input_files = [os.path.join(TEST_DATA_DIR, 'rsds_test.nc')]\n nsrdb_source_fp = os.path.join(TEST_DATA_DIR, 'test_nsrdb_co_2018.h5')\n\n with xr.open_mfdataset(input_files) as fh:\n min_lat = np.min(fh.lat.values)\n min_lon = np.min(fh.lon.values) - 360\n target = (min_lat, min_lon)\n shape = (len(fh.lat.values), len(fh.lon.values))\n\n with pytest.raises(AssertionError):\n handler = DataHandlerNCforCC(input_files, features=features,\n target=target, shape=shape,\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n\n handler = DataHandlerNCforCC(input_files, features=features,\n nsrdb_source_fp=nsrdb_source_fp,\n target=target, shape=shape,\n temporal_slice=slice(0, 1),\n val_split=0.0,\n worker_kwargs=dict(max_workers=1))\n\n cs_ratio = handler.data[..., 0]\n ghi = handler.data[..., 1]\n cs_ghi = handler.data[..., 2]\n cs_ratio_truth = ghi / cs_ghi\n\n assert cs_ratio.max() < 1\n assert cs_ratio.min() > 0\n assert (ghi < cs_ghi).all()\n assert np.allclose(cs_ratio, cs_ratio_truth)\n\n with Resource(nsrdb_source_fp) as res:\n meta = res.meta\n tree = KDTree(meta[['latitude', 'longitude']])\n cs_ghi_true = res['clearsky_ghi']\n\n # check a few sites against NSRDB source file\n for i in range(4):\n for j in range(4):\n test_coord = handler.lat_lon[i, j]\n _, inn = tree.query(test_coord)\n\n assert np.allclose(cs_ghi_true[0:48, inn].mean(), cs_ghi[i, j])","def test_matched_filter5():\n x_size = 80\n y_size = 90\n\n objects = numpy.zeros((1, 5))\n\n # Make filter with unit sum.\n objects[0,:] = [x_size/2, y_size/2, 1.0, 1.0, 1.0]\n psf = dg.drawGaussians((x_size, y_size), objects)\n psf = psf/numpy.sum(psf)\n flt = matchedFilterC.MatchedFilter(psf)\n\n # Make test image.\n image = numpy.zeros((x_size, y_size))\n image[int(x_size/2), int(y_size/2)] = float(100)\n\n mf_conv = flt.convolve(image)\n\n t1 = numpy.fft.fft2(recenterPSF.recenterPSF(psf))\n t2 = numpy.fft.fft2(image)\n np_conv = numpy.real(numpy.fft.ifft2(t1*t2))\n\n assert(numpy.allclose(mf_conv, np_conv))\n\n flt.cleanup()","def test_fft_spectrum_fieldtrip_02():\n ft_psd_hann = [0.00106465976843528, 0.00562957700710057, 0.00214937527201723, 0.000405599433993590, 0.00506141871942431, 0.00343922341551741, 0.00223373256323887, 0.00767611770955874, 0.0426550524445195, 0.0376986963169514]\n f0, Sxx0 = _fft(x, s_freq, detrend=None, taper='hann', output='spectraldensity', sides='one', scaling='fieldtrip')\n # less precise because different shape of hann window\n assert_array_almost_equal(Sxx0[100:110], ft_psd_hann, decimal=3)","def estimate_F(corrs):\n N, _ = corrs.shape\n corrs_temp = np.zeros([N,4])\n corrs_temp[:,1] = corrs[:,0]\n corrs_temp[:,0] = corrs[:,1]\n corrs_temp[:,2] = corrs[:,3]\n corrs_temp[:,3] = corrs[:,2]\n corrs = corrs_temp\n means = []\n stds = []\n for i in range(4):\n mean = np.mean(corrs[:,i])\n means.append(mean)\n std = np.std(corrs[:,i])\n stds.append(std)\n corrs[:,i] -= mean\n corrs[:,i] /= std\n T1 = np.array([[1/stds[0], 0, -means[0]/stds[0]],[0,1/stds[1], -means[1]/stds[1]], [0,0,1]])\n T2 = np.array([[1/stds[2], 0, -means[2]/stds[2]],[0,1/stds[3], -means[3]/stds[3]], [0,0,1]])\n Y = []\n for j in range(N):\n Y.append(np.outer(np.hstack([corrs[j,2:],1]),np.hstack([corrs[j,:2],1])).flatten())\n Y = np.array(Y)\n\n u, s, v = np.linalg.svd(Y, full_matrices = 0)\n if s[-1] != 0:\n F = v[-1]\n else:\n F = v[-2]\n F = F.reshape([3,3])\n u, s, v = np.linalg.svd(F, full_matrices = 0)\n if len(s)==3:\n s[-1] = 0\n F = u @ np.diag(s) @ v\n F = T2.T @ F @ T1\n F = F/np.linalg.norm(F, ord = 'fro')\n return F","def get_crd_fc(self, axis, shaped=False):\n return self._src_crds.get_fc(axis, shaped=shaped)","def scoreCirc_PassiveFilter_2(circuit, gen, indi, makeRedundancyInMatrix):\n #Calculate density and uniquiness (as in makeNetlist)\n if makeRedundancyInMatrix == True:\n FullBigCircuitMatrix = deepcopy(fullRedundancyBigCircuitMatrix(circuit.BigCircuitMatrix))\n else:\n FullBigCircuitMatrix = deepcopy(circuit.BigCircuitMatrix)\n\n rowsR,columnsR,columnsC,rowsC = sortedNonZeroIndices(FullBigCircuitMatrix)\n\n matrixDensity = float(len(rowsR))/float((BigMatrixSize*BigMatrixSize/2))\t#(ones/(all/2))\n matrixQuaziID = sum(rowsR)+sum(columnsR)-BigMatrixSize*(BigMatrixSize-1)\n OcSc, IcNc, SelfConnElm = checkConnsConnected(FullBigCircuitMatrix) #Outer connections Short cut, Inner connections Not connected\n #print \"Kratkih stikov zunanjih povezav:\", OcSc\n \n results = None\n if OcSc > 1:\n score = 1e4*np.exp(OcSc)\n else:\n makeNetlist(circuit, gen, indi, FullBigCircuitMatrix)\n results = runme2.evaluatePassiveFilter_2(gen, indi)\n \n disfCount = 0\n\n gain = np.array(results['gain']['nominal'], dtype=float)\n if np.isnan(gain):\n disfCount = disfCount + 1\n g = 0\n else:\n g = abs(gain - 0) if gain < 0 else 0\n\n ripple = np.array(results['ripple']['nominal'], dtype=float)\n if np.isnan(ripple):\n disfCount = disfCount + 1\n r = 0 \n else:\n r = abs(ripple - 0.5) if ripple > 0.5 else 0\n \n damping = np.array(results['damping']['nominal'], dtype=float)\n if np.isnan(damping):\n disfCount = disfCount + 1\n d = 0\n else:\n d = abs(40 - damping) if damping < 40 else 0\n\n slope = np.array(results['dumpingSlope']['nominal'], dtype=float)\n if np.isnan(slope):\n disfCount = disfCount + 1\n slo = 0\n else:\n slo = 0 if slope>60 else 60-slope\n \n bandwidth = np.array(results['bw']['nominal'], dtype=float)\n if np.isnan(bandwidth):\n disfCount = disfCount + 1\n bw = 0\n else:\n bw = abs(bandwidth-1000)/100\n \n #THD = np.array(results['THD']['nominal'], dtype=float)\n #if np.isnan(THD):\n # disfCount = disfCount + 1\n # thd = 0\n #else:\n # thd = THD-1 if THD > 1 else 0\n #print 10*r, g, d, slo, bw\n score = 10*r + g + d + slo + bw\n\n if disfCount > 0:\n score += np.exp(disfCount) * 1e3\n\n #score = score + (IcNc*IcNc+1)# + abs(BW-bw)*1e2 + abs(CUTOFF-cutoff)*1e2 #add small punishment if not all nodes connected and bw and cutoff are off\n\n #print \"\\t\\t\\t\\t\\tG_\" + str(gen) + \"_I_\" + str(indi) + \" SCORE:\", score\n #cleanup current subcircuit\n filename = \"g_\" + str(gen) + \"_i_\" + str(indi) + \"_subckt.cir\"\n os.remove(filename)\n return score, matrixDensity, matrixQuaziID, results","def test_standard_mfcc():\n run_framesync(MFCC)","def mfcc(signal, sampling_rate, factor=0.095, frame_size=0.025, frame_overlap=0.015, NFFT=512, num_filt = 40):\n pre_emphasized = pre_emphasize(signal)\n frames = make_frames(pre_emphasized, rate)\n\n #FFT and Power Spectrum\n #NFFT = 512\n mag_frames = np.absolute(np.fft.rfft(frames, NFFT)) # Magnitude of the FFT\n power_frames = ((1.0 / NFFT) * (np.power(mag_frames,2))) # Power Spectrum\n\n filter_banks = make_filter_banks(power_frames, rate, NFFT)\n\n #MFCC\n num_ceps = 20\n mfcc_40 = dct(filter_banks, type=2, axis=1, norm='ortho') \n mfcc = mfcc_40 #[:, 1 : (num_ceps + 1)] # Keep 2-13\n\n #Mean Normalization\n mfcc = mfcc - (np.mean(mfcc, axis=0) + 1e-6)\n\n mfcc_features = np.hstack((np.mean(mfcc.T, axis=1), np.std(mfcc.T, axis=1), skew(mfcc.T, axis = 1), \n np.max(mfcc.T, axis = 1), np.median(mfcc.T, axis = 1), np.min(mfcc.T, axis = 1)))\n \n return mfcc_features","def test_corr_transform_performance(meta_cres, corr, signal_masks, simulatedata_cbma):\n _, (ground_truth_foci, _) = simulatedata_cbma\n mask = meta_cres.masker.mask_img\n ground_truth_foci_ijks = [tuple(mm2vox(focus, mask.affine)) for focus in ground_truth_foci]\n sig_idx, nonsig_idx = [\n meta_cres.masker.transform(img).astype(bool).squeeze() for img in signal_masks\n ]\n\n p_array = meta_cres.maps.get(\"p\")\n if p_array is None or corr.method == \"montecarlo\":\n p_array = 10 ** -meta_cres.maps.get(\"logp_level-voxel_corr-FWE_method-montecarlo\")\n\n n_iters = corr.parameters.get(\"n_iters\")\n\n # ALE with MKDA kernel with montecarlo correction\n # combination gives poor performance\n if (\n isinstance(meta_cres.estimator, ale.ALE)\n and isinstance(meta_cres.estimator.kernel_transformer, kernel.MKDAKernel)\n and meta_cres.estimator.get_params().get(\"null_method\") == \"approximate\"\n and corr.method != \"montecarlo\"\n ):\n good_sensitivity = True\n good_specificity = False\n elif (\n isinstance(meta_cres.estimator, ale.ALE)\n and isinstance(meta_cres.estimator.kernel_transformer, kernel.MKDAKernel)\n and \"montecarlo\" in meta_cres.estimator.get_params().get(\"null_method\")\n ):\n good_sensitivity = False\n good_specificity = True\n elif (\n isinstance(meta_cres.estimator, ale.ALE)\n and isinstance(meta_cres.estimator.kernel_transformer, kernel.MKDAKernel)\n and meta_cres.estimator.get_params().get(\"null_method\") == \"approximate\"\n and corr.method == \"montecarlo\"\n ):\n good_sensitivity = False\n good_specificity = True\n elif (\n isinstance(meta_cres.estimator, ale.ALE)\n and type(meta_cres.estimator.kernel_transformer) == kernel.KDAKernel\n and (\n \"montecarlo\" in meta_cres.estimator.get_params().get(\"null_method\")\n or (\n meta_cres.estimator.get_params().get(\"null_method\") == \"approximate\"\n and corr.method == \"montecarlo\"\n )\n )\n ):\n good_sensitivity = False\n good_specificity = True\n elif (\n isinstance(meta_cres.estimator, ale.ALE)\n and type(meta_cres.estimator.kernel_transformer) == kernel.KDAKernel\n and meta_cres.estimator.get_params().get(\"null_method\") == \"approximate\"\n ):\n good_sensitivity = True\n good_specificity = False\n elif (\n isinstance(meta_cres.estimator, mkda.MKDADensity)\n and isinstance(meta_cres.estimator.kernel_transformer, kernel.ALEKernel)\n and meta_cres.estimator.get_params().get(\"null_method\") != \"reduced_montecarlo\"\n and corr.method != \"montecarlo\"\n ):\n good_sensitivity = False\n good_specificity = True\n else:\n good_sensitivity = True\n good_specificity = True\n\n _check_p_values(\n p_array,\n meta_cres.masker,\n sig_idx,\n nonsig_idx,\n ALPHA,\n ground_truth_foci_ijks,\n n_iters=n_iters,\n good_sensitivity=good_sensitivity,\n good_specificity=good_specificity,\n )","def is_rfft(obj):\n if not (hasattr(obj, 'nx') and hasattr(obj, 'dx') and hasattr(obj, 'ny')\n and hasattr(obj, 'dy') and hasattr(obj, 'fft')):\n return False\n\n return obj.fft.shape == (obj.nx, obj.ny / 2 + 1)","def test_fft_complex_1d():\n\ta = np.exp(2j * np.pi * np.arange(8) / 8)\n\tdummy_array = xr.DataArray(a, dims=['x'])\n\tchunked_array = dummy_array.chunk(chunks={'x': 2})\n\tspectrum_array, spectrum_coords, spectrum_dims = \\\n\t\txfft._fft(chunked_array, nfft={'x': 16}, dim=['x'], dx={'x': 0.5})\n\tassert np.array_equal(spectrum_array.compute(), np.fft.fft(a, n=16))\n\tassert np.array_equal(spectrum_coords['f_x'], np.fft.fftfreq(16, d=0.5))\n\tassert 'f_x' in spectrum_dims","def test_width_z_to_f_f(mf, ncf, t3f, qf):\n pre = EL / (SW * CW)\n gl = pre * (t3f - qf * SW**2)\n gr = -pre * qf * SW**2\n\n def msqrd_z_to_f_f(_):\n return (\n ncf\n * 2\n / 3\n * (6 * gl * gr * mf**2 + (gl**2 + gr**2) * (-(mf**2) + MZ**2))\n )\n\n mr2 = (mf / MZ) ** 2\n af = t3f - qf * SW**2\n bf = -qf * SW**2\n\n analytic = (\n ncf\n * EL**2\n * MZ\n / (24 * np.pi * CW**2 * SW**2)\n * np.sqrt(1 - 4 * mr2)\n * ((af**2 + bf**2) * (1 - mr2) + 6 * af * bf * mr2)\n )\n\n phase_space = Rambo(MZ, [mf, mf], msqrd=msqrd_z_to_f_f)\n width = phase_space.decay_width(10_000, seed=SEED)[0]\n\n assert width == pytest.approx(analytic)","def NIR_flatfield_corr(tif): \n _,_,_,flat_file_N,_=return_flatfield_set_path(2)\n \n print(tif)\n \n N=gdal_array.LoadFile(tif)\n \n file_path=os.path.dirname(os.path.abspath(tif))+\"/corr/\"+os.path.basename(tif)[:-4]+\"_corr.tif\"\n \n N=BLUE_simple_flatfield_corr(gdal_array.LoadFile(flat_file_N), N)\n \n options = ['PROFILE=GeoTIFF']\n driver=osgeo.gdal.GetDriverByName(\"GTiff\")\n basename=os.path.basename(tif)\n basename=basename[:3]+\"N\"+basename[4:]\n \n file_path=os.path.dirname(os.path.abspath(tif))+\"/corr/\"+basename[:-4]+\"_corr.tif\"\n dataset=driver.Create(file_path, N.shape[1],N.shape[0], 1, osgeo.gdal.GDT_UInt16, options) \n dataset.GetRasterBand(1).WriteArray(N)\n dataset.FlushCache()\n dataset = None","def simple_flatfield_corr(flat, real, Mfaktor, Pfaktor):\n real=real.astype(np.float64)\n flat=flat.astype(np.float64)\n # init_max=np.max(real)/4095\n print(np.max(real))\n flat=NormalizeData(flat)\n flat=flat*Mfaktor \n m=np.average(flat)\n gain=m/(flat+Pfaktor) \n C=np.multiply(gain, real) \n print(np.max(C))\n return C","def automorphism_group_FF_alg2(rational_function):\n # define ground field and ambient function field\n if rational_function.parent().is_field():\n K = rational_function.parent()\n R = K.ring()\n else:\n R = rational_function.parent()\n K = R.fraction_field()\n\n F = R.base_ring()\n if not F.is_finite() or not F.is_field():\n raise TypeError(\"coefficient ring is not a finite field\")\n p = F.characteristic()\n z = R.gen(0)\n phi = K(rational_function)\n f = phi.numerator()\n g = phi.denominator()\n D = max(f.degree(), g.degree())\n\n # Build an invariant set for phi\n fix = f(z) - z*g(z)\n factor_list = fix.factor()\n minimal_fix_poly = R(prod(x[0] for x in factor_list))\n n = sum(x[0].degree() for x in factor_list) + bool(fix.degree() < D+1)\n\n if n >= 3:\n T_poly = minimal_fix_poly\n infinity_check = bool(fix.degree() < D+1)\n elif n == 2:\n # Infinity is a fixed point\n if bool(fix.degree() < D+1):\n y = fix.roots(multiplicities=False)[0]\n preimage = g*(f(z) - y*g(z))\n infinity_check = 1\n # Infinity is not a fixed point\n else:\n C = minimal_fix_poly.coefficients(sparse=False)\n preimage = C[2]*f(z)**2 + C[1]*f(z)*g(z) + C[0]*g(z)**2\n infinity_check = bool(preimage.degree() < 2*D)\n\n T_poly = R(prod(x[0] for x in preimage.factor()))\n\n else: #case n=1\n # Infinity is the fixed point\n if bool(fix.degree() < D+1):\n minimal_preimage = R(prod(x[0] for x in g.factor()))\n if minimal_preimage.degree() + 1 >= 3:\n T_poly = minimal_preimage\n infinity_check = 1\n else:\n T_poly = R(prod(x[0] for x in phi(phi(z)).denominator().factor() ) )\n infinity_check = 1\n\n # Infinity is not a fixed point\n else:\n y = fix.roots(multiplicities=False)[0]\n preimage = R(f(z) - y*g(z))\n minimal_preimage = R(prod(x[0] for x in preimage.factor()))\n if minimal_preimage.degree() + bool(preimage.degree()<D) >= 3:\n T_poly = minimal_preimage\n infinity_check = bool(preimage.degree()<D)\n else:\n preimage2 = R(phi(phi(z)).numerator() - y*phi(phi(z)).denominator())\n T_poly = R(prod(x[0] for x in preimage2.factor() ) )\n infinity_check = infinity_check = bool(preimage2.degree() < D**2)\n\n # Define a field of definition for the absolute automorphism group\n r = lcm([x[0].degree() for x in T_poly.factor()])*F.degree()\n E = GF(p**r,'b')\n b = E.gen(0)\n sigma = F.Hom(E)[0]\n S = PolynomialRing(E,'w')\n w = S.gen(0)\n E_poly = rational_function_coerce(T_poly, sigma, S)\n\n T = [ [alpha, E(1)] for alpha in E_poly.roots(ring=E, multiplicities=False)]\n if infinity_check == 1:\n T.append([E(1),E(0)])\n\n # Coerce phi into the larger ring and call Algorithm 1\n Phi = rational_function_coerce(phi, sigma, S)\n return [S, three_stable_points(Phi, T)]","def test_DFT_rect(centering='FFTRECT', outdir=None, outname='DFT1R_', npix=None, sampling=10., nlamd=None):\n\n print \"Testing DFT, style = \"+centering\n\n\n npupil = 156\n pctr = int(npupil/2)\n s = (npupil,npupil)\n\n\n # make things rectangular:\n if nlamd is None and npix is None:\n nlamd = (10,20)\n npix = [val*sampling for val in nlamd] #(100, 200) \n elif npix is None:\n npix = [val*sampling for val in nlamd] #(100, 200) \n elif nlamd is None:\n nlamd = [val/sampling for val in npix]\n u = nlamd\n print u\n #(u, float(u)/npix[0]*npix[1])\n #npix = (npix, 2*npix)\n\n\n # FFT style\n mft1 = matrixDFT.MatrixFourierTransform(centering=centering)\n\n #ctr = (float(npupil)/2.0 + mft1.offset(), float(npupil)/2.0 + mft1.offset())\n ctr = (float(npupil)/2.0 , float(npupil)/2.0)\n #print ctr\n pupil = makedisk(s=s, c=ctr, r=float(npupil)/2.0001, t=np.float64, grey=0)\n\n pupil[0:60, 0:60] = 0\n pupil[0:10] = 0\n\n pupil /= np.sqrt(pupil.sum())\n\n plt.clf()\n plt.subplots_adjust(left=0.02, right=0.98)\n plt.subplot(141)\n\n pmx = pupil.max()\n plt.imshow(pupil, vmin=0, vmax=pmx*1.5)\n\n\n if outdir is not None:\n fits.PrimaryHDU(pupil.astype(np.float32)).writeto(outdir+os.sep+outname+\"pupil.fits\", clobber=True)\n\n a = mft1.perform(pupil, u, npix)\n\n pre = (abs(pupil)**2).sum() \n post = (abs(a)**2).sum() \n ratio = post / pre\n calcr = 1./(1.0*u[0]*u[1] *npix[0]*npix[1]) # multiply post by this to make them equal\n print \"Pre-FFT total: \"+str( pre)\n print \"Post-FFT total: \"+str( post )\n print \"Ratio: \"+str( ratio)\n #print \"Calc ratio : \"+str( calcr)\n #print \"uncorrected: \"+str( ratio/calcr)\n\n\n complexinfo(a, str=\",ft1 asf\")\n asf = a.real.copy()\n if outdir is not None:\n fits.PrimaryHDU(asf.astype(np.float32)).writeto(outdir+os.sep+outname+\"asf.fits\", clobber=True)\n cpsf = a * a.conjugate()\n psf = cpsf.real.copy()\n if outdir is not None:\n fits.PrimaryHDU(psf.astype(np.float32)).writeto(outdir+os.sep+outname+\"psf.fits\", clobber=True)\n\n ax=plt.subplot(142)\n plt.imshow(asf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\n ax.set_title='ASF'\n\n ax=plt.subplot(143)\n plt.imshow(psf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\n ax.set_title='PSF'\n\n plt.subplot(144)\n\n pupil2 = mft1.inverse(a, u, npupil)\n pupil2r = (pupil2 * pupil2.conjugate()).real\n plt.imshow( pupil2r, vmin=0,vmax=pmx*1.5*0.01) # FIXME flux normalization is not right?? I think this has to do with squaring the pupil here, that's all.\n plt.gca().set_title='back to pupil'\n plt.draw()\n print \"Post-inverse FFT total: \"+str( abs(pupil2r).sum() )\n print \"Post-inverse pupil max: \"+str(pupil2r.max())\n\n plt.suptitle('Matrix DFT with rectangular arrays using centering={0}'.format(centering))\n\n plt.savefig('test_DFT_rectangular_results_{0}.pdf'.format(centering))","def cross_correlation(f, g):\n\n out = None\n k = np.flip(np.flip(g, 0), 1)\n out = conv_fast(f, k)\n\n return out","def test_fft_spectrum_02():\n f, t, Sxx = _spectral_helper(x, x, fs=s_freq,\n window='hann',\n nperseg=x.shape[0],\n noverlap=0,\n nfft=None,\n return_onesided=True,\n mode='psd',\n scaling='spectrum')\n\n f0, Sxx0 = _fft(x, s_freq, detrend=None, taper='hann', scaling='energy', sides='one')\n\n assert_array_equal(f0, f)\n assert_array_almost_equal(Sxx0, Sxx[:, 0] * CORRECTION_FACTOR)","def pairCorrelationR(frametracks, dr=0.5, cutoff=50, subset=None, fast=False,\n nnmaxcount=None):\n ftr = frametracks\n ndens = numberDensity(ftr)\n hist_bin_edges = np.arange(0, cutoff + dr/2.0, dr, dtype=float)\n histaccum = np.zeros((len(hist_bin_edges) - 1), dtype=int)\n if nnmaxcount is None:\n # Set 'maxcount' to a safe value\n maxcount = np.pi * cutoff**2 * ndens * 10\n else:\n maxcount = nnmaxcount\n NNE = NNEngine(ftr, cutoff, maxcount, fast=fast, subset=subset)\n for xy, dists in NNE.iter_dist():\n try:\n hist = _fast_hist(dists, hist_bin_edges)\n except ValueError: # zero neighbors\n continue\n histaccum += hist\n histareas = np.diff(np.pi * hist_bin_edges**2)\n return histaccum / float(NNE.loopcount()) / (histareas * ndens), hist_bin_edges"],"string":"[\n \"def corrf(u, v, nf):\\n V = np.conj(np.fft.fft(v, n=nf))\\n U = np.fft.fft(u, n=nf)\\n X = U*V\\n x = np.real(np.fft.ifft(X, n=nf))\\n return x\",\n \"def frc(im1, im2, annulus_width=1, edgetaper=5, edgeloc=8 / 20.0, loc=(0, 0), smooth=None, working_mask=None, x=None,\\n y=None, rmax=None, taper=None):\\n\\n # 2012-02-25 20:40 IJMC: Empty bins now have numel=0, not nan.\\n # 2012-02-04 17:41 IJMC: Added \\\"SUM\\\" flag\\n # 2010-11-19 16:36 IJC: Updated documentation for Sphinx\\n # 2010-03-10 19:22 IJC: Ported to python from Matlab\\n # 2005/12/19 Added 'working_region' option (IJC)\\n # 2005/12/15 Switched order of outputs (IJC)\\n # 2005/12/12 IJC: Removed decifact, changed name, wrote comments.\\n # 2005/11/04 by Ian Crossfield at the Jet Propulsion Laboratory\\n\\n import numpy as ny\\n\\n class radialDat:\\n \\\"\\\"\\\"Empty object container.\\n \\\"\\\"\\\"\\n\\n def __init__(self):\\n self.num = None\\n self.denom = None\\n self.T1bit = None\\n self.Thalfbit = None\\n\\n # ---------------------\\n # Set up input parameters\\n # ---------------------\\n\\n if working_mask == None:\\n working_mask = ny.ones(im1.shape, bool)\\n\\n npix, npiy = im1.shape\\n if taper is not None:\\n taper0 = taper\\n else:\\n taper0 = tapercircle(im1.shape, edgetaper, edgeloc, loc)\\n f, a = plt.subplots()\\n a.imshow(imsave(im1 * taper0))\\n plt.title('tapered')\\n plt.show()\\n # taper0 = 1\\n F1 = fftshift(fft2(ifftshift(im1 * taper0)))\\n F2 = fftshift(fft2(ifftshift(im2 * taper0)))\\n F1F2_star = F1 * F2.conj()\\n\\n if x == None or y == None:\\n x1 = ny.arange(-npix / 2., npix / 2.)\\n y1 = ny.arange(-npiy / 2., npiy / 2.)\\n x, y = ny.meshgrid(y1, x1)\\n\\n r = abs(x + 1j * y)\\n\\n if rmax == None:\\n rmax = r[working_mask].max()\\n\\n # ---------------------\\n # Prepare the data container\\n # ---------------------\\n dr = ny.abs([x[0, 0] - x[0, 1]]) * annulus_width\\n radial = ny.arange(rmax / dr) * dr + dr / 2.\\n nrad = len(radial)\\n radialdata = radialDat()\\n radialdata.num = ny.zeros(nrad)\\n radialdata.denom = ny.zeros(nrad)\\n radialdata.T1bit = ny.zeros(nrad)\\n radialdata.Thalfbit = ny.zeros(nrad)\\n radialdata.r = radial / (npix / 2)\\n\\n # ---------------------\\n # Loop through the bins\\n # ---------------------\\n for irad in range(nrad): # = 1:numel(radial)\\n minrad = irad * dr\\n maxrad = minrad + dr\\n thisindex = (r >= minrad) * (r < maxrad) * working_mask\\n # import pylab as py\\n # pdb.set_trace()\\n if not thisindex.ravel().any():\\n radialdata.num[irad] = ny.nan\\n radialdata.denom[irad] = ny.nan\\n radialdata.T1bit[irad] = ny.nan\\n radialdata.Thalfbit[irad] = ny.nan\\n else:\\n sqrt_n = np.sqrt(thisindex.astype(np.int).sum())\\n radialdata.num[irad] = np.real(F1F2_star[thisindex].sum())\\n radialdata.denom[irad] = ny.sqrt((ny.abs(F1[thisindex]) ** 2).sum() * (ny.abs(F2[thisindex]) ** 2).sum())\\n radialdata.T1bit[irad] = (0.5 + 2.4142 / sqrt_n) / (1.5 + 1.4142 / sqrt_n)\\n radialdata.Thalfbit[irad] = (0.2071 + 1.9102 / sqrt_n) / (1.2071 + 0.9102 / sqrt_n)\\n\\n # ---------------------\\n # Return with data\\n # ---------------------\\n radialdata.frc = ny.nan_to_num(radialdata.num / radialdata.denom)\\n radialdata.frc[radialdata.frc < 0] = 0\\n if smooth is not None:\\n radialdata.frc = gaussian_filter1d(radialdata.frc, smooth)\\n take = radialdata.r <= 1.1\\n radialdata.r = radialdata.r[take]\\n radialdata.frc = radialdata.frc[take]\\n radialdata.T1bit = radialdata.T1bit[take]\\n radialdata.Thalfbit = radialdata.Thalfbit[take]\\n return radialdata\",\n \"def flatfield_corr(*args): \\n print(len(args), args)\\n if len(args)==1:\\n \\n raster=gdal_array.LoadFile(args[0])\\n R=raster[0]\\n G=raster[1]\\n B=raster[2]\\n file_path=os.path.dirname(os.path.abspath(args[0]))+\\\"/corr/\\\"+os.path.basename(args[0])[:-4]+\\\"_corr.tif\\\"\\n elif len(args)==3:\\n R=gdal_array.LoadFile(args[0])\\n G=gdal_array.LoadFile(args[1])\\n B=gdal_array.LoadFile(args[2])\\n basename=os.path.basename(args[0])\\n basename=basename[:3]+basename[4:]\\n file_path=os.path.dirname(os.path.abspath(args[0]))+\\\"/corr/\\\"+os.path.basename(args[0])[:-4]+\\\"_rgb_corr.tif\\\"\\n else:\\n print(\\\"functions takes 1 (rgb file path) or 3 arguments (one filepath per channel)\\\")\\n \\n \\n flat_file_R, flat_file_G, flat_file_B,_,_=return_flatfield_set_path(2)\\n \\n # Mfaktor=5\\n R=BLUE_simple_flatfield_corr(gdal_array.LoadFile(flat_file_R), R)\\n G=BLUE_simple_flatfield_corr(gdal_array.LoadFile(flat_file_G), G)\\n B=BLUE_simple_flatfield_corr(gdal_array.LoadFile(flat_file_B), B)\\n \\n G=np.roll(G, 8, axis=1)\\n \\n # print(np.max(raster), np.min(raster))\\n \\n \\n plot_raster=np.empty([2050, 2448, 3], dtype=np.int16)\\n plot_raster[:,:,0]=R \\n plot_raster[:,:,1]=G\\n plot_raster[:,:,2]=B\\n \\n plot_raster=(plot_raster/np.max(plot_raster))*255\\n plot_raster=plot_raster.astype(np.uint8)\\n plot_raster[:,:,0]=cv2.equalizeHist( plot_raster[:,:,0])\\n plot_raster[:,:,1]=cv2.equalizeHist( plot_raster[:,:,1])\\n plot_raster[:,:,2]=cv2.equalizeHist( plot_raster[:,:,2])\\n \\n \\n # plt.axis('off')\\n\\n \\n \\n # plt.imshow(plot_raster, vmin=0, vmax=65535)\\n # plt.show()\\n # plt.close()\\n \\n # max_=np.max(raster)\\n\\n \\n # raster=raster.astype(np.uint16)\\n \\n driver=osgeo.gdal.GetDriverByName(\\\"GTiff\\\")\\n options = ['PHOTOMETRIC=RGB', 'PROFILE=GeoTIFF']\\n \\n dataset=driver.Create(os.path.dirname(os.path.abspath(args[0]))+\\\"/corr/rgb/\\\"+os.path.basename(args[0])[:-4]+\\\"_rgb_corr.tif\\\"\\n , R.shape[1]-8,R.shape[0], 3, osgeo.gdal.GDT_UInt16, options) \\n dataset.GetRasterBand(1).WriteArray(R[:,8:])\\n dataset.GetRasterBand(2).WriteArray(G[:,8:])\\n dataset.GetRasterBand(3).WriteArray(B[:,8:])\\n dataset.FlushCache()\\n dataset = None\\n \\n options = ['PROFILE=GeoTIFF']\\n\\n basename=os.path.basename(args[0])\\n basename=basename[:3]+\\\"R\\\"+basename[4:]\\n file_path=os.path.dirname(os.path.abspath(args[0]))+\\\"/corr/\\\"+basename[:-4]+\\\"_corr.tif\\\"\\n dataset=driver.Create(file_path, R.shape[1]-8,R.shape[0], 1, osgeo.gdal.GDT_UInt16, options) \\n dataset.GetRasterBand(1).WriteArray(R[:,8:])\\n dataset.FlushCache()\\n dataset = None\\n \\n basename=os.path.basename(args[0])\\n basename=basename[:3]+\\\"G\\\"+basename[4:]\\n file_path=os.path.dirname(os.path.abspath(args[0]))+\\\"/corr/\\\"+basename[:-4]+\\\"_corr.tif\\\"\\n dataset=driver.Create(file_path, R.shape[1]-8,R.shape[0], 1, osgeo.gdal.GDT_UInt16, options) \\n dataset.GetRasterBand(1).WriteArray(G[:,8:])\\n dataset.FlushCache()\\n dataset = None\\n \\n basename=os.path.basename(args[0])\\n basename=basename[:3]+\\\"B\\\"+basename[4:]\\n file_path=os.path.dirname(os.path.abspath(args[0]))+\\\"/corr/\\\"+basename[:-4]+\\\"_corr.tif\\\"\\n dataset=driver.Create(file_path, R.shape[1]-8,R.shape[0], 1, osgeo.gdal.GDT_UInt16, options) \\n dataset.GetRasterBand(1).WriteArray(B[:,8:])\\n dataset.FlushCache()\\n dataset = None\\n \\n \\n \\n # plot_raster = cv2.cvtColor(plot_raster, cv2.COLOR_RGB2BGR)\\n # cv2.imwrite(file_path[:-4]+\\\"_preview.jpg\\\", plot_raster)\\n # plot_raster=NormalizeData(plot_raster)\\n # plot_raster=plot_raster/4095\\n # plot_raster=plot_raster*512\\n # plot_raster=plot_raster.astype(np.uint8)\\n \\n \\n # plt.gca().set_axis_off()\\n # plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, \\n # hspace = 0, wspace = 0)\\n # plt.margins(0,0)\\n # plt.gca().xaxis.set_major_locator(plt.NullLocator())\\n # plt.gca().yaxis.set_major_locator(plt.NullLocator())\\n \\n # plt.imshow(plot_raster[:,8:,:])\\n # # plt.savefig(file_path[:-4]+\\\"_previewplot.jpg\\\", dpi=600, bbox_inches='tight')\\n # plt.show()\\n # plt.close\\n \\n \\n # # print(img_array.shape)\\n \\n # # img=Image.fromarray(plot_raster, \\\"RGB\\\")\\n # # img.save(file_path[:-4]+\\\"_preview.jpg\\\")\\n \\n \\n \\n # # print(np.max(raster), np.min(raster))\",\n \"def cross_correlate(rmsynth_pixel, rmsf):\\n return np.fft.ifft(np.fft.fft(rmsynth_pixel)*np.fft.fft(rmsf[::-1]))\",\n \"def correlate(fft1,fft2, maxlag,dt, Nfft, method=\\\"cross-correlation\\\"):\\n\\n if fft1.ndim == 1:\\n nwin=1\\n elif fft1.ndim == 2:\\n nwin= int(fft1.shape[0])\\n\\n t0=time.time()\\n corr=np.zeros(shape=(nwin,Nfft),dtype=np.complex64)\\n fft1_globe = cuda.to_device(fft1[:,:Nfft//2].reshape(fft1.size,))\\n fft2_globe = cuda.to_device(fft2[:,:Nfft//2].reshape(fft2.size,))\\n corr_globe = cuda.device_array(shape=(nwin*(Nfft//2),),dtype=np.complex64)\\n \\n threadsperblock = 2000\\n blockspergrid = math.ceil(fft1_globe.size/threadsperblock)\\n \\n if method == 'deconv':\\n decon_gpu[threadsperblock,blockspergrid](fft1_globe,fft2_globe,corr_globe)\\n elif method =='coherence':\\n coherence_gpu[threadsperblock,blockspergrid](fft1_globe,fft2_globe,corr_globe)\\n\\n tcorr = corr_globe.copy_to_host()\\n corr = tcorr.reshape(nwin,Nfft//2)\\n\\n ncorr = np.zeros(shape=Nfft,dtype=np.complex64)\\n ncorr[:Nfft//2] = np.mean(corr,axis=0)\\n ncorr[-(Nfft//2)+1:]=np.flip(np.conj(ncorr[1:(Nfft//2)]),axis=0)\\n ncorr[0]=complex(0,0)\\n ncorr = np.real(np.fft.ifftshift(scipy.fftpack.ifft(ncorr, Nfft, axis=0)))\\n\\n t1=time.time()\\n print('it takes '+str(t1-t0)+' s')\\n\\n tcorr = np.arange(-Nfft//2 + 1, Nfft//2)*dt\\n ind = np.where(np.abs(tcorr) <= maxlag)[0]\\n ncorr = ncorr[ind]\\n tcorr = tcorr[ind]\\n\\n return ncorr,tcorr\",\n \"def test_ft_with_pols():\\n fake_data = np.zeros((3, 2, 13, 31))\\n fake_data[:, 0, 7, 11] += 1.0\\n fake_corr = utils.normalized_fourier_transform(\\n fake_data, 1 * units.dimensionless_unscaled, taper=windows.boxcar, axis=3\\n )\\n assert (3, 2, 13, 31) == fake_corr.shape\",\n \"def test_correlation_spectrum():\\r\\n # Smoke-test for now - unclear what to test here...\\r\\n f, c = tsa.correlation_spectrum(x, y, norm=True)\",\n \"def test_fft_real_2d():\\n\\ta = np.mgrid[:5, :5, :5][0]\\n\\tdummy_array = xr.DataArray(a, dims=['x', 'y', 'z'])\\n\\tchunked_array = dummy_array.chunk(chunks={'x': 2, 'y': 2, 'z': 2})\\n\\tspectrum_array, spectrum_coords, spectrum_dims = \\\\\\n\\t\\txfft._fft(chunked_array, nfft={'y': 14, 'z': 18}, dim=['y', 'z'],\\n\\t\\t dx={'y': 0.01, 'z': 0.02}, sym=False)\\n\\tassert np.allclose(spectrum_array.compute(),\\n\\t np.fft.rfftn(a, s=(18, 14), axes=(2, 1)))\\n\\tassert np.array_equal(spectrum_coords['f_y'], np.fft.rfftfreq(14, d=0.01))\\n\\tassert np.array_equal(spectrum_coords['f_z'], np.fft.fftfreq(18, d=0.02))\\n\\tassert ('x', 'f_y', 'f_z') == spectrum_dims\",\n \"def calculate_overf_correlation(amp, index, f0, dt, n_lags):\\n \\n # Cast inputs as floats as I do a bunch of division.\\n dt = float(dt)\\n f0 = float(f0)\\n index = float(index)\\n # Number of points used in calculation needs to be at least 10 times bigger\\n # than final number of point returned. This is so we are not affected by\\n # the periodicity of the correlation function.\\n buff_factor = 64\\n n = buff_factor * n_lags\\n n_return = n_lags\\n # Generate the power spectrum.\\n # Need to add a low frequency cut off, since there is an IR divergence.\\n # Choose to cut off at 1/2df (so we get a bit of slope mode).\\n power = overf_power_spectrum(amp, index, f0, dt, n,\\n cut_off=1./n_lags/dt/2.0)\\n # FFT it to the correlation function.\\n corr = fft.ifft(power)\\n # Complex part should be zero.\\n corr = corr.real\\n # In previous versions of this function, we shifted the output function.\\n # however this screws up positive definiteness of the correlation matrix\\n # and is unnecessary if you have the IR cut off.\\n #corr -= corr[2 * n_return]\\n # Trim to return size.\\n corr = corr[:n_return]\\n # To normalize, need to multiply by twice the bandwidth.\\n corr *= 1.0/dt\\n return corr\",\n \"def test_fft_real_3d():\\n\\ta = np.mgrid[:7, :5, :5][0]\\n\\tdummy_array = xr.DataArray(a, dims=['x', 'y', 'z'])\\n\\tchunked_array = dummy_array.chunk(chunks={'x': 7, 'y': 5, 'z': 5})\\n\\tspectrum_array, spectrum_coords, spectrum_dims = \\\\\\n\\t\\txfft._fft(chunked_array, nfft={'x': 11, 'y': 14, 'z': 18},\\n\\t\\t dim=['x', 'y', 'z'], dx={'x':12, 'y': 0.01, 'z': 0.02},\\n\\t\\t sym=False)\\n\\tassert np.allclose(spectrum_array.compute(),\\n\\t np.fft.rfftn(a.T, s=(18, 14, 11)).T)\\n\\tassert np.array_equal(spectrum_coords['f_x'], np.fft.rfftfreq(11, d=12))\\n\\tassert np.array_equal(spectrum_coords['f_y'], np.fft.fftfreq(14, d=0.01))\\n\\tassert np.array_equal(spectrum_coords['f_z'], np.fft.fftfreq(18, d=0.02))\\n\\tassert ('f_x', 'f_y', 'f_z') == spectrum_dims\",\n \"def test_normalized_fourier_transform():\\n fake_data = np.zeros((1, 13, 21))\\n fake_data[0, 7, 11] += 1\\n fake_corr = utils.normalized_fourier_transform(\\n fake_data, 1 * units.dimensionless_unscaled, taper=windows.boxcar, axis=2\\n )\\n test_corr = np.fft.fft(fake_data, axis=-1)\\n test_corr = np.fft.fftshift(test_corr, axes=-1)\\n fake_corr = fake_corr.value\\n assert np.allclose(test_corr, fake_corr)\",\n \"def xcorr(arr1, arr2, mode = 'full', axes = None):\\n if mode not in {'full', 'same'}:\\n raise ValueError('Unexpected cross-correlation mode {}'.format(mode))\\n \\n if axes is None:\\n axes = tuple(range(arr1.ndim))\\n\\n arr1, arr2 = np.asarray(arr1), np.asarray(arr2)\\n\\n # Determine final size along transformation axes\\n # To speed up FFT, shape of Fourier transform might be slightly larger\\n # then slice back before returning\\n s1 = tuple(arr1.shape[ax] for ax in axes)\\n s2 = tuple(arr2.shape[ax] for ax in axes)\\n final_shape = tuple( ax1 + ax2 - 1 for ax1, ax2 in zip(s1, s2))\\n fast_shape = tuple(map(next_fast_len, final_shape))\\n final_slice = tuple([slice(0, int(sz)) for sz in final_shape])\\n\\n F1 = fftn(arr1, shape = fast_shape, axes = axes)\\n F2 = fftn(np.conj(mirror(arr2, axes = axes)), shape = fast_shape, axes = axes)\\n xc = ifftn(F1 * F2)[final_slice]\\n\\n if mode == 'same':\\n return _centered(xc, arr1.shape, axes = axes)\\n else:\\n return xc\",\n \"def testrescorr():\\n tau = np.zeros((2,50))\\n tau[0,25] = 2\\n tau[1,23] = 3\\n tau2 = spec_utils.res_corr(tau, 2, 8)\\n #Check flux conserved\\n assert np.abs(np.sum(tau2[0,:])/ np.sum(tau[0,:]) -1) < 1e-6\\n assert np.abs(np.sum(tau2[1,:])/ np.sum(tau[1,:]) -1) < 1e-6\\n #Check expanded by expected amount\\n for i in (0,1):\\n assert np.size(np.where(tau2[i,:]> 0)) == 15\",\n \"def circular_cross_correlation(x, y):\\n return tf.real(tf.ifft(tf.multiply(tf.conj(tf.fft(tf.cast(x, tf.complex64))) , tf.fft(tf.cast(y, tf.complex64)))))\",\n \"def toff(self) -> None:\\n\\n size = self.circ_size\\n self._get_random_input_state(self.seed)\\n\\n remainder = size % 3\\n for layer in range(size):\\n leftovers = tuple(random.sample(range(size), remainder))\\n candidates = [x for x in range(size) if x not in leftovers]\\n\\n while candidates:\\n current_toff = tuple(random.sample(candidates, 3))\\n self.ccx(current_toff[0], current_toff[1], current_toff[2])\\n candidates = [x for x in candidates if x not in current_toff]\\n\\n self.decompose().decompose()\\n if self.meas: self.measure(self.qr, self.cr)\",\n \"def cross_correlation(x_ref: np.ndarray, x_target: np.ndarray, fs: Optional[int] = None,\\n hilbert_flag: bool = False, normalize_flag: bool = False,\\n freq_range: Optional[Union[np.ndarray, list]] = None,\\n calc_offset: bool = False, plot_flag: bool = False\\n ) -> Tuple[np.ndarray, np.ndarray, Union[float, None]]:\\n\\n # preliminaries\\n assert (x_ref.ndim == 1) & (x_target.ndim == 1)\\n len1 = x_ref.size\\n len2 = x_target.size\\n len_cc = len1 + len2 - 1\\n\\n # compute\\n x1_fft = fft.rfft(x_ref, len_cc)\\n x2_fft = fft.rfft(x_target, len_cc)\\n cc_fft = x1_fft * np.conj(x2_fft)\\n\\n # normalize by magnitude of reference signal\\n if normalize_flag:\\n magnitude_factor = np.abs(x1_fft) ** 2\\n cc_fft = (cc_fft / magnitude_factor)\\n\\n # frequency filtering\\n if freq_range is not None:\\n f_vec = fft.rfftfreq(len_cc, 1/fs)\\n assert np.size(freq_range) == 2\\n idx = (f_vec < freq_range[0]) | (f_vec > freq_range[1])\\n cc_fft[idx] = 0\\n\\n # transform back to time domain\\n cc = fft.irfft(cc_fft, len_cc)\\n cc = np.roll(cc, len2 - 1)\\n lags = np.arange(len_cc) - (len2 - 1)\\n if fs is not None:\\n lags = lags / fs\\n\\n # hilbert transform\\n if hilbert_flag:\\n cc = np.abs(hilbert(cc))\\n\\n # calculate offset\\n if calc_offset:\\n offset = lags[np.argmax(np.abs(cc))]\\n else:\\n offset = None\\n\\n # plot\\n if plot_flag:\\n fig = px.line(y=cc, x=lags)\\n lags_units = \\\"samples\\\" if fs is None else \\\"seconds\\\"\\n fig.update_xaxes(title=f\\\"Shift [{lags_units}]\\\")\\n fig.update_yaxes(title=\\\"Processed Cross Correlation\\\")\\n fig.show()\\n\\n return cc, lags, offset\",\n \"def corrf(self, refimg_fea, targetimg_fea, maxdisp, fac=1):\\n b, c, height, width = refimg_fea.shape\\n if refimg_fea.is_cuda:\\n cost = Variable(\\n torch.cuda.FloatTensor(b, c, 2 * maxdisp + 1, 2 * int(maxdisp // fac) + 1, height, width)).fill_(\\n 0.) # b,c,u,v,h,w\\n else:\\n cost = Variable(torch.FloatTensor(b, c, 2 * maxdisp + 1, 2 * int(maxdisp // fac) + 1, height, width)).fill_(\\n 0.) # b,c,u,v,h,w\\n # print(cost.shape)\\n for i in range(2 * maxdisp + 1):\\n ind = i - maxdisp\\n for j in range(2 * int(maxdisp // fac) + 1):\\n indd = j - int(maxdisp // fac)\\n feata = refimg_fea[:, :, max(0, -indd):height - indd, max(0, -ind):width - ind]\\n featb = targetimg_fea[:, :, max(0, +indd):height + indd, max(0, ind):width + ind]\\n diff = (feata * featb)\\n cost[:, :, i, j, max(0, -indd):height - indd, max(0, -ind):width - ind] = diff\\n cost = F.leaky_relu(cost, 0.1, inplace=True)\\n # print(cost.shape)\\n return cost\",\n \"def test_fft_spectrum_fieldtrip_03():\\n ft_complex_dpss = [-0.0335619899491902 - 0.0100985443725351j, 0.0252013706875434 + 0.0436725973183397j, -0.0145928652426528 - 0.0546311601211480j, -0.00364680778007352 + 0.0542853721812055j, 0.0293189825468446 - 0.0554598147669454j, -0.0523346938092935 + 0.0458447745674979j, 0.0739055167896313 - 0.00673071060189224j, -0.0892965233534656 - 0.0698942934418098j, 0.0664933718921557 + 0.148311783870617j, -0.00190172379532472 - 0.160711901636832j]\\n f0, Sxx0 = _fft(x, s_freq, detrend=None, taper='dpss', output='complex', sides='two', scaling='fieldtrip', halfbandwidth=3)\\n # Note that the DC freq is different\\n assert_array_almost_equal(Sxx0[100:110, 0], ft_complex_dpss)\",\n \"def plot_correlation_fit(img1_ft, img2_ft, frqs, dx, fmax=None, frqs_guess=None, roi_size=31,\\n peak_pixels=2, figsize=(20, 10), ttl_str=\\\"\\\"):\\n\\n # get physical parameters\\n dy = dx\\n\\n # get frequency data\\n fxs = tools.get_fft_frqs(img1_ft.shape[1], dx)\\n fys = tools.get_fft_frqs(img1_ft.shape[0], dy)\\n if fmax is None:\\n fmax = np.sqrt(np.max(fxs)**2 + np.max(fys)**2)\\n\\n # power spectrum / cross correlation\\n # cc = np.abs(img1_ft * img2_ft.conj())\\n # cc = np.abs(scipy.signal.fftconvolve(img1_ft, img2_ft.conj(), mode='same'))\\n cc = np.abs(scipy.signal.correlate(img2_ft, img1_ft, mode='same'))\\n\\n fx_sim, fy_sim = frqs\\n # useful info to print\\n period = 1 / np.sqrt(fx_sim ** 2 + fy_sim ** 2)\\n angle = np.angle(fx_sim + 1j * fy_sim)\\n\\n peak_cc = tools.get_peak_value(cc, fxs, fys, [fx_sim, fy_sim], peak_pixels)\\n\\n peak1_dc = tools.get_peak_value(img1_ft, fxs, fys, [0, 0], peak_pixels)\\n peak2 = tools.get_peak_value(img2_ft, fxs, fys, [fx_sim, fy_sim], peak_pixels)\\n\\n extent = tools.get_extent(fys, fxs)\\n\\n # create figure\\n figh = plt.figure(figsize=figsize)\\n gspec = matplotlib.gridspec.GridSpec(ncols=14, nrows=2, hspace=0.3, figure=figh)\\n\\n str = \\\"\\\"\\n if ttl_str != \\\"\\\":\\n str += \\\"%s\\\\n\\\" % ttl_str\\n # suptitle\\n str += ' fit: period %0.1fnm = 1/%0.3fum at %.2fdeg=%0.3frad; f=(%0.3f,%0.3f) 1/um, peak cc=%0.3g at %0.2fdeg' % \\\\\\n (period * 1e3, 1/period, angle * 180 / np.pi, angle, fx_sim, fy_sim, np.abs(peak_cc), np.angle(peak_cc) * 180/np.pi)\\n if frqs_guess is not None:\\n fx_g, fy_g = frqs_guess\\n period_g = 1 / np.sqrt(fx_g ** 2 + fy_g ** 2)\\n angle_g = np.angle(fx_g + 1j * fy_g)\\n peak_cc_g = tools.get_peak_value(cc, fxs, fys, frqs_guess, peak_pixels)\\n\\n str += '\\\\nguess: period %0.1fnm = 1/%0.3fum at %.2fdeg=%0.3frad; f=(%0.3f,%0.3f) 1/um, peak cc=%0.3g at %0.2fdeg' % \\\\\\n (period_g * 1e3, 1/period_g, angle_g * 180 / np.pi, angle_g, fx_g, fy_g, np.abs(peak_cc_g), np.angle(peak_cc_g) * 180/np.pi)\\n plt.suptitle(str)\\n\\n # #######################################\\n # plot region of interest\\n # #######################################\\n roi_cx = np.argmin(np.abs(fx_sim - fxs))\\n roi_cy = np.argmin(np.abs(fy_sim - fys))\\n roi = tools.get_centered_roi([roi_cy, roi_cx], [roi_size, roi_size])\\n\\n extent_roi = tools.get_extent(fys[roi[0]:roi[1]], fxs[roi[2]:roi[3]])\\n\\n ax = plt.subplot(gspec[0, 0:6])\\n ax.set_title(\\\"cross correlation, ROI\\\")\\n im1 = ax.imshow(cc[roi[0]:roi[1], roi[2]:roi[3]], interpolation=None, norm=PowerNorm(gamma=0.1), extent=extent_roi)\\n ph1 = ax.scatter(frqs[0], frqs[1], color='r', marker='x')\\n if frqs_guess is not None:\\n if np.linalg.norm(frqs - frqs_guess) < np.linalg.norm(frqs + frqs_guess):\\n ph2 = ax.scatter(frqs_guess[0], frqs_guess[1], color='g', marker='x')\\n else:\\n ph2 = ax.scatter(-frqs_guess[0], -frqs_guess[1], color='g', marker='x')\\n\\n if frqs_guess is not None:\\n ax.legend([ph1, ph2], ['frq fit', 'frq guess'], loc=\\\"upper right\\\")\\n else:\\n ax.legend([ph1], ['frq fit'], loc=\\\"upper right\\\")\\n\\n circ_max_frq = matplotlib.patches.Circle((0, 0), radius=fmax, color='k', fill=0, ls='--')\\n ax.add_artist(circ_max_frq)\\n\\n ax.set_xlabel('fx (1/um)')\\n ax.set_ylabel('fy (1/um)')\\n\\n\\n cbar_ax = figh.add_subplot(gspec[0, 6])\\n figh.colorbar(im1, cax=cbar_ax)\\n\\n ### full image ###\\n ax2 = plt.subplot(gspec[0, 7:13])\\n im2 = ax2.imshow(cc, interpolation=None, norm=PowerNorm(gamma=0.1), extent=extent)\\n ax2.set_xlim([-fmax, fmax])\\n ax2.set_ylim([fmax, -fmax])\\n\\n # plot maximum frequency\\n circ_max_frq = matplotlib.patches.Circle((0, 0), radius=fmax, color='k', fill=0)\\n ax2.add_artist(circ_max_frq)\\n\\n roi_rec = matplotlib.patches.Rectangle((fxs[roi[2]], fys[roi[0]]), fxs[roi[3]] - fxs[roi[2]], fys[roi[1]] - fys[roi[0]],\\n edgecolor='k', fill=0)\\n ax2.add_artist(roi_rec)\\n\\n ax2.set_title(\\\"Cross correlation, C(fo) = \\\\sum_f img_ft1(f) x img_ft2^*(f+fo)\\\")\\n ax2.set_xlabel('fx (1/um)')\\n ax2.set_ylabel('fy (1/um)')\\n\\n cbar_ax = figh.add_subplot(gspec[0, 13])\\n figh.colorbar(im2, cax=cbar_ax)\\n\\n # ft 1\\n ax3 = plt.subplot(gspec[1, 0:6])\\n ax3.set_title(\\\"fft 1 PS near DC, peak = %0.3g at %0.2fdeg\\\" % (np.abs(peak1_dc), np.angle(peak1_dc) * 180/np.pi))\\n\\n cx_c = np.argmin(np.abs(fxs))\\n cy_c = np.argmin(np.abs(fys))\\n roi_center = tools.get_centered_roi([cy_c, cx_c], [roi_size, roi_size])\\n\\n im3 = ax3.imshow(np.abs(img1_ft[roi_center[0]:roi_center[1], roi_center[2]:roi_center[3]])**2,\\n interpolation=None, norm=PowerNorm(gamma=0.1), extent=extent)\\n ax3.scatter(0, 0, color='r', marker='x')\\n\\n cbar_ax = figh.add_subplot(gspec[1, 6])\\n figh.colorbar(im3, cax=cbar_ax)\\n\\n # ft 2\\n ax4 = plt.subplot(gspec[1, 7:13])\\n ttl_str = \\\"fft 2 PS near fo, peak = %0.3g at %0.2fdeg\\\" % (np.abs(peak2), np.angle(peak2) * 180 / np.pi)\\n if frqs_guess is not None:\\n peak2_g = tools.get_peak_value(img2_ft, fxs, fys, frqs_guess, peak_pixels)\\n ttl_str += \\\"\\\\nguess peak = = %0.3g at %0.2fdeg\\\" % (np.abs(peak2_g), np.angle(peak2_g) * 180 / np.pi)\\n ax4.set_title(ttl_str)\\n\\n im4 = ax4.imshow(np.abs(img2_ft[roi[0]:roi[1], roi[2]:roi[3]])**2,\\n interpolation=None, norm=PowerNorm(gamma=0.1), extent=extent_roi)\\n ph1 = ax4.scatter(frqs[0], frqs[1], color='r', marker='x')\\n if frqs_guess is not None:\\n if np.linalg.norm(frqs - frqs_guess) < np.linalg.norm(frqs + frqs_guess):\\n ph2 = ax4.scatter(frqs_guess[0], frqs_guess[1], color='g', marker='x')\\n else:\\n ph2 = ax4.scatter(-frqs_guess[0], -frqs_guess[1], color='g', marker='x')\\n\\n cbar_ax = figh.add_subplot(gspec[1, 13])\\n figh.colorbar(im4, cax=cbar_ax)\\n\\n return figh\",\n \"def test_correlation_test_perfect_correlation(self):\\r\\n # These results were verified with R.\\r\\n obs = correlation_test([1, 2, 3, 4], [1, 2, 3, 4])\\r\\n self.assertFloatEqual(obs[:2],\\r\\n (0.99999999999999978, 2.2204460492503131e-16))\\r\\n self.assertEqual(len(obs[2]), 999)\\r\\n for r in obs[2]:\\r\\n self.assertTrue(r >= -1.0 and r <= 1.0)\\r\\n self.assertCorrectPValue(0.06, 0.09, correlation_test,\\r\\n ([1, 2, 3, 4], [1, 2, 3, 4]), p_val_idx=3)\\r\\n self.assertFloatEqual(obs[4], (0.99999999999998879, 1.0))\",\n \"def test_fft_real_1d():\\n\\ta = [0, 1, 0, 0]\\n\\tdummy_array = xr.DataArray(a, dims=['x'])\\n\\tchunked_array = dummy_array.chunk(chunks={'x': 2})\\n\\tspectrum_array, spectrum_coords, spectrum_dims = \\\\\\n\\t\\txfft._fft(chunked_array, nfft={'x': 4}, dim=['x'], dx={'x': 0.01},\\n\\t\\t sym=False)\\n\\tassert np.array_equal(spectrum_array.compute(), np.fft.rfft(a))\\n\\tassert np.array_equal(spectrum_coords['f_x'], np.fft.rfftfreq(4, d=0.01))\\n\\tassert 'f_x' in spectrum_dims\",\n \"def periodic_corr(x, y):\\r\\n return np.fft.ifft(np.fft.fft(x) * np.fft.fft(y).conj()).real\",\n \"def get_simple_ccf(flux1, flux2, shift_lst):\\n\\n n = flux1.size\\n ccf_lst = []\\n for shift in shift_lst:\\n segment1 = flux1[max(0,shift):min(n,n+shift)]\\n segment2 = flux2[max(0,-shift):min(n,n-shift)]\\n c1 = math.sqrt((segment1**2).sum())\\n c2 = math.sqrt((segment2**2).sum())\\n corr = np.correlate(segment1, segment2)/c1/c2\\n ccf_lst.append(corr)\\n return np.array(ccf_lst)\",\n \"def corr2d_fourier(slip, test, lonslip = [], latslip = [], lontest = [], lattest = [], normalizar = True):\\n\\n\\n if normalizar: \\n xcorr2d = signal.correlate(slip/np.size(slip), test/np.size(test), mode='full', method='fft')\\n else:\\n xcorr2d = signal.correlate(slip, test, mode='full', method='fft')\\n \\n \\n valor_corr = np.sum(xcorr2d)\\n\\n\\n return valor_corr\",\n \"def correlation_1d(data1, data2):\\n\\n N = len(data1)\\n assert N == len(data2)\\n n_fft = select_power_of_two(N)\\n\\n # Pad the signal with zeros to avoid the periodic images.\\n R_data1 = np.zeros(2*n_fft)\\n R_data1[:N] = data1\\n R_data2 = np.zeros(2*n_fft)\\n R_data2[:N] = data2\\n F_data1 = np.fft.fft(R_data1)\\n F_data2 = np.fft.fft(R_data2)\\n result = np.fft.ifft(F_data1.conj()*F_data2)\\n positive_time = result[:N].real/(N-np.arange(N))\\n negative_time = result[-N+1:][::-1].real/(N-1-np.arange(N-1))\\n\\n return np.concatenate((negative_time[::-1], positive_time))\",\n \"def test_correlation(self):\\r\\n x = [1, 2, 3, 5]\\r\\n y = [0, 0, 0, 0]\\r\\n z = [1, 1, 1, 1]\\r\\n a = [2, 4, 6, 8]\\r\\n b = [1.5, 1.4, 1.2, 1.1]\\r\\n c = [15, 10, 5, 20]\\r\\n\\r\\n bad = [1, 2, 3] # originally gave r = 1.0000000002\\r\\n\\r\\n self.assertFloatEqual(correlation(x, x), (1, 0))\\r\\n self.assertFloatEqual(correlation(x, y), (0, 1))\\r\\n self.assertFloatEqual(correlation(y, z), (0, 1))\\r\\n self.assertFloatEqualAbs(correlation(x, a), (0.9827076, 0.01729), 1e-5)\\r\\n self.assertFloatEqualAbs(\\r\\n correlation(x, b), (-0.9621405, 0.03786), 1e-5)\\r\\n self.assertFloatEqualAbs(correlation(x, c), (0.3779645, 0.622), 1e-3)\\r\\n self.assertEqual(correlation(bad, bad), (1, 0))\",\n \"def test_fft_complex_2d():\\n\\ta, b, c = np.meshgrid([0, 1, 0, 0], [0, 1j, 1j], [0, 1, 1, 1])\\n\\tdummy_array = xr.DataArray(a * b * c, dims=['x', 'y', 'z'])\\n\\tchunked_array = dummy_array.chunk(chunks={'x': 2, 'y': 2, 'z': 2})\\n\\tspectrum_array, spectrum_coords, spectrum_dims = \\\\\\n\\t\\txfft._fft(chunked_array, nfft={'y': 6, 'z': 8}, dim=['y', 'z'],\\n\\t\\t dx={'y': 0.01, 'z': 0.02})\\n\\tassert np.allclose(spectrum_array.compute(),\\n\\t np.fft.fftn(a * b * c, s=(8, 6), axes=(2, 1)))\\n\\tassert np.array_equal(spectrum_coords['f_y'], np.fft.fftfreq(6, d=0.01))\\n\\tassert np.array_equal(spectrum_coords['f_z'], np.fft.fftfreq(8, d=0.02))\\n\\tassert ('x', 'f_y', 'f_z') == spectrum_dims\",\n \"def _xcorrf(self, profile1, profile2, dx):\\n corrf = np.correlate(profile2, profile1, mode = 'same') \\\\\\n /np.sum(profile1**2)\\n\\n if np.isnan(corrf).any():\\n displ = np.nan\\n corr = 0\\n else:\\n displ = (np.where(corrf == np.max(corrf))[0][0] - len(corrf)//2)*dx\\n corr = np.max(corrf)\\n\\n return displ, corr\",\n \"def calculate_roc(calibration_model, PSF_model, test_images, test_coef, N_iter=3, noise=False, SNR_noise=None):\\n\\n N_PSF = test_coef.shape[0] # How many PSF cases do we have\\n N_eps = 200 # How many thresholds to sample\\n percentage = np.linspace(0, 100, N_eps) # Array of percentage thresholds\\n roc = np.zeros((N_iter, N_eps)) # ROC array\\n\\n # get the norm of the test coef at the beginning\\n norm_test0 = norm(test_coef, axis=1)\\n\\n if noise:\\n # Add readout noise to the test images\\n test_images = calibration_model.noise_effects.add_readout_noise(test_images, RMS_READ=1 / SNR_noise)\\n\\n # placeholder arrays for the images and coefficients\\n psf0, coef0 = test_images, test_coef\\n for k in range(N_iter):\\n print(\\\"\\\\nIteration #%d\\\" % (k + 1))\\n # predict the coefficients\\n guess = calibration_model.cnn_model.predict(psf0)\\n residual = coef0 - guess\\n norm_residual = norm(residual, axis=1)\\n # compare the norm of the residual to that of the original coefficients\\n ratios = norm_residual / norm_test0 * 100\\n\\n # calculate the ROC\\n for j in range(N_eps):\\n # compute the fraction of cases whose ratio norm residual / norm test coef is smaller than threshold\\n roc[k, j] = np.sum(ratios < percentage[j]) / N_PSF\\n\\n # update the PSF images for the next iteration\\n new_PSF = np.zeros_like(test_images)\\n for i in range(N_PSF):\\n if i % 500 == 0:\\n print(i)\\n psf_nom, s_nom = PSF_model.compute_PSF(residual[i])\\n psf_foc, s_foc = PSF_model.compute_PSF(residual[i], diversity=True)\\n new_PSF[i, :, :, 0] = psf_nom\\n new_PSF[i, :, :, 1] = psf_foc\\n\\n if noise:\\n # Add readout noise to the test images\\n new_PSF = calibration_model.noise_effects.add_readout_noise(new_PSF, RMS_READ=1 / SNR_noise)\\n\\n # Overwrite the placeholder arrays for the next iteration\\n psf0 = new_PSF\\n coef0 = residual\\n\\n return roc, percentage, residual\",\n \"def comb_fc(filepatt):\\r\\n\\r\\n\\r\\n files = glob.glob(os.path.join(savefolder, filepatt))\\r\\n print(filepatt)\\r\\n \\r\\n if files == []:\\r\\n imgs = []\\r\\n print('No files found for ' + filepatt)\\r\\n return\\r\\n\\r\\n\\r\\n imgs = np.empty((600, 600, 3))\\r\\n for fi, file in enumerate(files):\\r\\n img = cv2.imread(file)\\r\\n \\r\\n if fi == 0:\\r\\n imgs = img\\r\\n else:\\r\\n imgs = np.concatenate((imgs, img), axis = 2)\\r\\n\\r\\n idx = filepatt.find('freq')\\r\\n comb_fcGraph = os.path.join(savefolder, 'comb_' + filepatt[idx: -len('.mat')])\\r\\n cv2.imwrite(comb_fcGraph, imgs)\\r\\n print(comb_fcGraph)\\r\\n\\r\\n # find lowweight\\r\\n pvals_vec = []\\r\\n ciCOH_vec = []\\r\\n pvals = pvals_fc_overtime(ciCOH = ciCOH, ntrials = ntrials, ntemp = ntemp, f = f, t = t)\\r\\n\\r\\n reject, pval_corr = fdr_correction(pvals, alpha=0.05, method='indep')\\r\\n \\r\\n\\r\\n \\r\\n lowweight = min(ciCOH_vec[rejs])\\r\\n\\r\\n return lowweight\",\n \"def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \\n av = akv * 1e3 # Convert kilovots to volts\\n cs = cs * 1e7 # Convert spherical aberation from mm to A\\n \\n # wavelength of electrons\\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\\n \\n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\\n wgh2 = dscale*wgh\\n\\n ix = freqs[:,0]\\n iy = freqs[:,1]\\n freq_radius = n.sqrt(ix**2 + iy**2)\\n\\n angle = elambda*freq_radius\\n angspt = n.arctan2(iy,ix)\\n if rots is not None:\\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\\n angle = angle.reshape((-1,1)) \\n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\\n c2 = -c1*cs*angle**2/2.0\\n angdif = angspt - angastf\\n ccos = n.cos(2.0*angdif)\\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\\n chi = c1*df + c2\\n\\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\\n \\n if bfactor is not None:\\n ctf *= envelope_function(freq_radius, bfactor)\\n\\n return n.require(ctf,dtype = freqs.dtype)\",\n \"def test_fdr_correction(self):\\r\\n pvals = array([.1, .7, .5, .3, .9])\\r\\n exp = array([.5, .7 * 5 / 4., .5 * 5 / 3., .3 * 5 / 2., .9])\\r\\n obs = fdr_correction(pvals)\\r\\n self.assertFloatEqual(obs, exp)\",\n \"def estimate_F_ransac(corr, num_iter, inlier_thresh):\\n _, inlier_mask = ransac(corr, estimate_F, sym_epipolar_dist, 8, num_iter, inlier_thresh)\\n # inlier_mask = np.ones(9)\\n # inlier_mask[0] = 0\\n F = estimate_F(corr[inlier_mask.astype(np.bool)])\\n return F\",\n \"def fasper(x, y, ofac, hifac, n_threads, MACC=4):\\n # Check dimensions of input arrays\\n n = int(len(x))\\n if n != len(y):\\n print('Incompatible arrays.')\\n return\\n \\n # print x, y, hifac, ofac\\n \\n nout = int(0.5*ofac*hifac*n)\\n nfreqt = int(ofac*hifac*n*MACC) #Size the FFT as next power\\n nfreq = 64 # of 2 above nfreqt.\\n\\n while nfreq < nfreqt:\\n nfreq = 2*nfreq\\n\\n ndim = int(2*nfreq)\\n \\n # Compute the mean, variance\\n ave = y.mean()\\n # sample variance because the divisor is N-1\\n var = ((y - y.mean())**2).sum()/(len(y) - 1) \\n # and range of the data.\\n xmin = x.min()\\n xmax = x.max()\\n xdif = xmax - xmin\\n\\n # extrapolate the data into the workspaces\\n if is_pyfftw:\\n wk1 = pyfftw.n_byte_align_empty(int(ndim), 16, 'complex') * 0.\\n wk2 = pyfftw.n_byte_align_empty(int(ndim), 16, 'complex') * 0.\\n else:\\n wk1 = zeros(ndim, dtype='complex')\\n wk2 = zeros(ndim, dtype='complex')\\n\\n fac = ndim/(xdif*ofac)\\n fndim = ndim\\n ck = ((x - xmin)*fac) % fndim\\n ckk = (2.0*ck) % fndim\\n \\n for j in range(0, n):\\n __spread__(y[j] - ave, wk1, ndim, ck[j], MACC)\\n __spread__(1.0, wk2, ndim, ckk[j], MACC)\\n\\n # Take the Fast Fourier Transforms.\\n if is_pyfftw:\\n fft_wk1 = pyfftw.builders.ifft(wk1, planner_effort='FFTW_ESTIMATE',\\n threads=n_threads)\\n wk1 = fft_wk1() * len(wk1)\\n fft_wk2 = pyfftw.builders.ifft(wk2, planner_effort='FFTW_ESTIMATE',\\n threads=n_threads)\\n wk2 = fft_wk2() * len(wk2)\\n else:\\n wk1 = ifft(wk1)*len(wk1)\\n wk2 = ifft(wk2)*len(wk1)\\n\\n wk1 = wk1[1:nout + 1]\\n wk2 = wk2[1:nout + 1]\\n rwk1 = wk1.real\\n iwk1 = wk1.imag\\n rwk2 = wk2.real\\n iwk2 = wk2.imag\\n \\n df = 1.0/(xdif*ofac)\\n \\n # Compute the Lomb value for each frequency\\n hypo2 = 2.0*abs(wk2)\\n hc2wt = rwk2/hypo2\\n hs2wt = iwk2/hypo2\\n\\n cwt = sqrt(0.5 + hc2wt)\\n swt = sign(hs2wt)*(sqrt(0.5 - hc2wt))\\n den = 0.5*n + hc2wt*rwk2 + hs2wt*iwk2\\n cterm = (cwt*rwk1 + swt*iwk1)**2./den\\n sterm = (cwt*iwk1 - swt*rwk1)**2./(n - den)\\n\\n wk1 = df*(arange(nout, dtype='float') + 1.)\\n wk2 = (cterm + sterm)/(2.0*var)\\n pmax = wk2.max()\\n jmax = wk2.argmax()\\n\\n # Estimate significance of largest peak value\\n expy = exp(-pmax) \\n effm = 2.0*(nout)/ofac\\n prob = effm*expy\\n\\n if prob > 0.01: \\n prob = 1.0 - (1.0 - expy)**effm\\n\\n return wk1, wk2, nout, jmax, prob\",\n \"def correlation_spectrum(x1, x2, Fs=2 * np.pi, norm=False):\\r\\n\\r\\n x1 = x1 - np.mean(x1)\\r\\n x2 = x2 - np.mean(x2)\\r\\n x1_f = fftpack.fft(x1)\\r\\n x2_f = fftpack.fft(x2)\\r\\n D = np.sqrt(np.sum(x1 ** 2) * np.sum(x2 ** 2))\\r\\n n = x1.shape[0]\\r\\n\\r\\n ccn = ((np.real(x1_f) * np.real(x2_f) +\\r\\n np.imag(x1_f) * np.imag(x2_f)) /\\r\\n (D * n))\\r\\n\\r\\n if norm:\\r\\n ccn = ccn / np.sum(ccn) * 2 # Only half of the sum is sent back\\r\\n # because of the freq domain symmetry.\\r\\n # XXX Does normalization make this\\r\\n # strictly positive?\\r\\n\\r\\n f = utils.get_freqs(Fs, n)\\r\\n return f, ccn[0:(n / 2 + 1)]\",\n \"def correlate(array1,array2):\\r\\n arrayout = np.conj(fft2(array1)) * fft2(array2)\\r\\n return ifft2(arrayout)\",\n \"def test(size_timeseries, num_timeseries):\\n data = random_data(num_timeseries, size_timeseries)\\n correlations_dfe = [0.0] * calc_num_correlations(num_timeseries)\\n correlations_cpu = [0.0] * calc_num_correlations(num_timeseries)\\n indices_step = [0.0] * calc_num_correlations(num_timeseries) * 2\\n\\n start_time = time.time()\\n correlate_dfe(data, size_timeseries, num_timeseries, correlations_dfe)\\n dfe_total = time.time() - start_time\\n print 'DFE correlation total time:\\\\t%.5lfs' % dfe_total\\n\\n start_time = time.time()\\n correlate_cpu(data, num_timeseries, size_timeseries,\\n correlations_cpu, indices_step)\\n cpu_total = time.time() - start_time\\n print 'CPU correlation total time:\\\\t%.5lfs' % cpu_total\\n\\n check(correlations_dfe, correlations_cpu, num_timeseries, indices_step)\",\n \"def test_delay_vals_with_pols():\\n fake_data = np.zeros((3, 2, 13, 31))\\n fake_data[:, 0, 7, 11] += 1.0\\n fake_corr = utils.normalized_fourier_transform(\\n fake_data, 1 * units.dimensionless_unscaled, taper=windows.boxcar, axis=3\\n )\\n test_corr = np.fft.fft(fake_data, axis=-1)\\n test_corr = np.fft.fftshift(test_corr, axes=-1)\\n fake_corr = fake_corr.value\\n assert np.allclose(test_corr, fake_corr)\",\n \"def test_fftconvolve_numerics(self, leading_dims, lengths, mode):\\n L_x, L_y = lengths\\n\\n x = torch.rand(*(leading_dims + (L_x,)), dtype=self.dtype, device=self.device)\\n y = torch.rand(*(leading_dims + (L_y,)), dtype=self.dtype, device=self.device)\\n\\n actual = F.fftconvolve(x, y, mode=mode)\\n\\n expected = signal.fftconvolve(x.detach().cpu().numpy(), y.detach().cpu().numpy(), axes=-1, mode=mode)\\n expected = torch.tensor(expected)\\n\\n self.assertEqual(expected, actual)\",\n \"def test_MFT_MFTwithnumexpr_equivalence(display=False, displaycrop=None):\\n\\n centering='FFTSTYLE' # needed if you want near-exact agreement of MFT and FFT!\\n\\n default_use_numexpr = accel_math._USE_NUMEXPR\\n\\n for useflag in [True,False]:\\n accel_math._USE_NUMEXPR = useflag\\n\\n imgin = optics.ParityTestAperture().sample(wavelength=1e-6, npix=256)\\n\\n npix = imgin.shape\\n nlamD = np.asarray(imgin.shape)\\n mft = matrixDFT.MatrixFourierTransform(centering=centering)\\n mftout = mft.perform(imgin, nlamD, npix)\\n\\n fftout = np.fft.fftshift(np.fft.fft2(np.fft.fftshift(imgin))) / np.sqrt(imgin.shape[0] * imgin.shape[1])\\n\\n\\n norm_factor = abs(mftout).sum()\\n\\n absdiff = abs(mftout-fftout) / norm_factor\\n\\n assert(np.all(absdiff < 1e-10))\\n\\n\\n accel_math._USE_NUMEXPR = default_use_numexpr\",\n \"def rolling_circular_correlation(\\n data_x: np.ndarray, data_y: np.ndarray, fps: int, time_window: float = 1.0\\n ) -> np.ndarray:\\n\\n data_x, data_y = np.deg2rad(data_x), np.deg2rad(data_y)\\n results = np.full((data_x.shape[0]), np.nan)\\n window_size = int(time_window * fps)\\n for window_start in prange(0, data_x.shape[0] - window_size + 1):\\n data_x_window = data_x[window_start : window_start + window_size]\\n data_y_window = data_y[window_start : window_start + window_size]\\n x_sin = np.sin(\\n data_x_window\\n - np.angle(np.nansum(np.multiply(1, np.exp(1j * data_x_window))))\\n )\\n y_sin = np.sin(\\n data_y_window\\n - np.angle(np.nansum(np.multiply(1, np.exp(1j * data_y_window))))\\n )\\n r = np.sum(x_sin * y_sin) / np.sqrt(np.sum(x_sin**2) * np.sum(y_sin**2))\\n results[window_start + window_size] = (\\n np.sqrt(\\n (data_x_window.shape[0] * (x_sin**2).mean() * (y_sin**2).mean())\\n / np.mean(x_sin**2 * y_sin**2)\\n )\\n * r\\n )\\n\\n return results\",\n \"def test_crofton_method(self):\\n\\n chi_sq = lambda pred, obs: np.sum((obs - pred)**2 / pred)\\n\\n para_crof = np.arange(0, 9)\\n\\n crof = PIHM()\\n\\n # Data from Crofton 1971\\n st1_obs = np.array([161, 111, 67, 65, 50, 30, 33, 13, 8])\\n st2_obs = np.array([189, 129, 86, 51, 27, 14, 8, 1, 2])\\n st3_obs = np.array([458, 81, 40, 22, 19, 4, 6, 3, 0])\\n st4_obs = np.array([164, 147, 92, 43, 25, 11, 3, 0, 1])\\n st5_obs = np.array([140, 77, 30, 14, 10, 3, 2, 0, 0])\\n st6_obs = np.array([153, 29, 6, 2, 1, 0, 0, 0, 0])\\n\\n # Raw data\\n st1_raw = np.repeat(para_crof, st1_obs)\\n st2_raw = np.repeat(para_crof, st2_obs)\\n st3_raw = np.repeat(para_crof, st3_obs)\\n st4_raw = np.repeat(para_crof, st4_obs)\\n st5_raw = np.repeat(para_crof, st5_obs)\\n st6_raw = np.repeat(para_crof, st6_obs)\\n\\n # Crofton predicted with truncations!\\n st1_pred = {\\n 3: np.array([162.2, 103.9, 77.4, 60.4, 48.2, 38.9, 31.7, 26.0, 21.4]),\\n 4: np.array([162.4, 103.4, 77.6, 61.2, 49.4, 40.5, 33.5, 27.9, 23.3]),\\n 5: np.array([161.2, 107.0, 78.0, 58.7, 44.7, 34.4, 26.6, 20.7, 16.1]),\\n 6: np.array([162.1, 104.6, 77.3, 59.5, 46.7, 37.1, 29.7, 23.9, 19.3]),\\n 7: np.array([160.2, 108.8, 79.2, 58.9, 44.3, 33.6, 25.5, 19.5, 14.9]),\\n 8: np.array([158.4, 111.7, 80.8, 59.0, 43.2, 31.7, 23.3, 17.2, 12.7])}\\n\\n st2_pred = {\\n 3: np.array([188.6, 130.7, 83.6 , 52.0, 31.9, 19.4, 11.7, 7.0, 4.2]),\\n 4: np.array([187.9, 133.0, 83.0, 49.4, 28.7, 16.5, 9.3, 5.3, 2.9,]),\\n 5: np.array([187.3, 134.5, 83.0, 48.4, 27.4, 15.3, 8.4, 4.6, 2.5]),\\n 6: np.array([187.2, 134.8, 83.1, 48.3, 27.3, 15.1, 8.3, 4.5, 2.4]),\\n 7: np.array([185.3, 138.1, 84.2, 47.5, 25.7, 13.6, 7.0, 3.6, 1.8]),\\n 8: np.array([185.5, 137.9, 84.1, 47.5, 25.8, 13.7, 7.1, 3.7, 1.9])}\\n\\n st3_pred = {\\n 3: np.array([457.9, 81.8, 39.0, 22.5, 14.1, 9.2, 6.3, 4.3, 3.0]),\\n 4: np.array([458.1, 79.5, 40.3, 25.0, 16.9, 12.0, 8.8, 6.5, 5.0]),\\n 5: np.array([457.5, 83.7, 39.0, 21.9, 13.3, 8.5, 5.5, 3.7, 2.5]),\\n 6: np.array([457.0, 83.4, 39.1, 22.0, 13.5, 8.6, 5.7, 3.8, 2.2]),\\n 7: np.array([457.4, 84.1, 39.1, 21.8, 13.2, 8.3, 5.4, 3.6, 2.4])}\\n\\n # Station 1 comparison\\n\\n trunc = np.arange(3, 9)\\n\\n crof_st1_ks = [0.754, 0.736, 0.834, 0.776, 0.874, 0.951]\\n crof_st1_N = [677, 708, 606, 646, 594, 573]\\n our_st1_N = []\\n our_st1_ks = []\\n crof_st1_compare_ss = []\\n\\n crof.data = st1_raw\\n\\n for i in trunc:\\n\\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\\n N, mu, k = crof.crofton_method(bin_edges)\\n our_st1_ks.append(k)\\n our_st1_N.append(N)\\n\\n assert_array_almost_equal(crof_st1_ks, our_st1_ks, decimal=1)\\n\\n # This will fail, but it is close\\n # Uncomment and run nosetests to see results\\n\\n # assert_array_equal(crof_st1_N, our_st1_N)\\n\\n # Station 2 comparison\\n\\n crof_st2_ks = [1.182, 1.313, 1.392, 1.407, 1.574, 1.563]\\n crof_st2_N = [535, 520, 514, 513, 508, 509]\\n our_st2_N = []\\n our_st2_ks = []\\n crof_st2_compare_ss = []\\n\\n crof.data = st2_raw\\n\\n for i in trunc:\\n\\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\\n N, mu, k = crof.crofton_method(bin_edges)\\n our_st2_ks.append(k)\\n our_st2_N.append(N)\\n\\n assert_array_almost_equal(crof_st2_ks, our_st2_ks, decimal=1)\\n\\n assert_array_equal(np.round(crof_st2_N, -1), np.round(our_st2_N, -1))\\n\\n # Station 3 comparison\\n\\n trunc = np.arange(3, 8)\\n\\n crof_st3_ks = [.229, .206, .244, .242, .247]\\n crof_st3_N = [646, 670, 642, 643, 641]\\n our_st3_N = []\\n our_st3_ks = []\\n crof_st3_compare_ss = []\\n\\n crof.data = st3_raw\\n\\n for i in trunc:\\n\\n bin_edges = list(np.arange(0, i + 1)) + [i + 0.9]\\n N, mu, k = crof.crofton_method(bin_edges)\\n our_st3_ks.append(k)\\n our_st3_N.append(N)\\n\\n assert_array_almost_equal(crof_st3_ks, our_st3_ks, decimal=1)\\n\\n # Close to equal but not quite. Which is ok. We don't expect them\\n # to be exactly equal\\n # Uncomment and run nosetests to see\\n\\n # assert_array_equal(crof_st3_N, our_st3_N)\",\n \"def test_MKDAChi2_fdr(testdata_cbma):\\n meta = MKDAChi2()\\n results = meta.fit(testdata_cbma, testdata_cbma)\\n corr = FDRCorrector(method=\\\"indep\\\", alpha=0.001)\\n corr_results = corr.transform(results)\\n assert isinstance(results, nimare.results.MetaResult)\\n assert isinstance(results.description_, str)\\n assert isinstance(corr_results, nimare.results.MetaResult)\\n assert isinstance(corr_results.description_, str)\\n\\n methods = FDRCorrector.inspect(results)\\n assert methods == [\\\"indep\\\", \\\"negcorr\\\"]\",\n \"def test_inv_fft() -> None:\\n ntests = 30\\n for i in range(ntests):\\n input_size = np.random.randint(4, 16, size=(2))\\n filter_size = np.random.randint(1, 4, size=(2))\\n input_mat = np.random.rand(*input_size)\\n filter_mat = np.random.rand(*filter_size)\\n # input_mat = np.array([[1, 2], [3, 4]])\\n # filter_mat = np.array([[1, 2], [3, 4]])\\n # fwd = fwd_conv2d(input_mat, filter_mat)\\n fwd_fft = fwd_conv2d_fft(input_mat, filter_mat)\\n inv_fwd_fft = inv_conv2d_fft(fwd_fft, filter_mat, None)\\n fwd_inv_fwd_fft = fwd_conv2d_fft(inv_fwd_fft, filter_mat)\\n # print(input_mat)\\n # print(filter_mat)\\n # print(fwd)\\n # print(fwd_fft)\\n # print(inv_fwd_fft)\\n # print(fwd_inv_fwd_fft)\\n error = np.linalg.norm(fwd_inv_fwd_fft - fwd_fft)\\n assert error < 0.05, 'test_inv_fft test #%d failed:\\\\n' \\\\\\n 'error %f too large!\\\\n' \\\\\\n 'filter_mat:\\\\n%s\\\\ninput_mat:\\\\n%s\\\\n' \\\\\\n 'fwd_fft:\\\\n%s\\\\n' \\\\\\n 'inv_fwd_fft:\\\\n%s\\\\n' % (i,\\n error,\\n filter_mat,\\n input_mat,\\n fwd_fft,\\n inv_fwd_fft)\",\n \"def nancrosscorr(\\n fr1: np.ndarray,\\n fr2: np.ndarray = None,\\n thres_n=2,\\n fillvalue=np.nan,\\n processes=1,\\n) -> np.ndarray:\\n if fr2 is None:\\n fr2 = fr1\\n\\n is_fr1_ndim2 = fr1.ndim == 2\\n if is_fr1_ndim2:\\n fr1 = fr1[..., None]\\n\\n is_fr2_ndim2 = fr2.ndim == 2\\n if is_fr2_ndim2:\\n fr2 = fr2[..., None]\\n\\n assert fr1.ndim == 3\\n assert fr2.ndim == 3\\n assert thres_n >= 2, 'to compute correlation thres_n needs to be >= 2'\\n\\n fsh1 = np.array(fr1.shape[:2])\\n fsh2 = np.array(fr2.shape[:2])\\n # csh = fsh1 + fsh2\\n\\n # NOTE: pad smaller of the two to match max_shape + 2,\\n # + 2 to ensure both are padded on both sides to remove smoothing artifact\\n max_sh0 = np.amax(np.stack([fsh1, fsh2], axis=0), axis=0)\\n max_sh = max_sh0 + 2\\n # max_sh = (max_sh // 2) * 2 + 1 # enforce odd numbers so it has a center\\n pad1 = max_sh - fsh1\\n # pad1 = np.stack([\\n # int(np.floor(pad1 / 2))])\\n pad2 = max_sh - fsh2\\n fr1 = np.pad(fr1, [\\n (int(np.floor(pad1[0] / 2)),\\n int(np.ceil(pad1[0] / 2))),\\n (int(np.floor(pad1[1] / 2)),\\n int(np.ceil(pad1[1] / 2))),\\n (0, 0)\\n ], constant_values=np.nan)\\n fr2 = np.pad(fr2, [\\n (int(np.floor(pad2[0] / 2)),\\n int(np.ceil(pad2[0] / 2))),\\n (int(np.floor(pad2[1] / 2)),\\n int(np.ceil(pad2[1] / 2))),\\n (0, 0)\\n ], constant_values=np.nan)\\n\\n csh = max_sh0 * 2\\n cc = np.zeros(tuple(csh) + fr1.shape[2:]) + fillvalue\\n # fsh = np.amin(np.stack([fsh1, fsh2], axis=0), axis=0)\\n # fsh = np.ceil(max_sh / 2).astype(int)\\n fsh = max_sh0\\n\\n pool = Pool(processes=processes)\\n # if processes > 0:\\n # pool = Pool(processes=processes)\\n # f_map = pool.map\\n # else:\\n # def f_map(*args, **kwargs):\\n # return list(map(*args, **kwargs))\\n\\n # def ccorrs(dx: int):\\n # cc0 = _ccorrs_given_dx(dx, csh, fillvalue, fr1, fr2, fsh, thres_n)\\n\\n dxs = np.arange(-fsh[0], fsh[0])\\n cc[fsh[0] + dxs] = np.array(pool.map(\\n _ccorrs_given_dx,\\n ((dx, csh, fillvalue, fr1, fr2, fsh, thres_n) for dx in dxs)\\n ))\\n # cc[fsh[0] + dxs] = np.array(pool.map(ccorrs, dxs))\\n\\n # if processes > 0:\\n # pool.close()\\n\\n if is_fr1_ndim2 and is_fr2_ndim2:\\n assert cc.shape[-1] == 1\\n cc = cc[..., 0]\\n\\n return cc\",\n \"def coherency(s1, s2, lags, plot=False, window_fraction=None, noise_floor_db=None):\\n\\n # test for symmetry\\n i = len(lags) // 2\\n assert lags[i] == 0, \\\"Midpoint of lags must be zero for coherency!\\\"\\n assert np.sum(-lags[:i] != lags[-i:][::-1]) == 0, \\\"lags must be symmetric for coherency!\\\"\\n\\n window = np.ones([len(lags)], dtype='float')\\n if window_fraction is not None:\\n assert window_fraction > 0 and window_fraction <= 1, \\\"window_fraction must be between 0 and 1\\\"\\n # create a gaussian windowing function for the CF and ACFs\\n window = np.exp(-lags**2 / (window_fraction*lags.max())**2)\\n\\n # do an FFT shift to the lags and the window, otherwise the FFT of the ACFs is not equal to the power\\n # spectrum for some numerical reason\\n window = fftshift(window)\\n shift_lags = fftshift(lags)\\n if len(lags) % 2 == 1:\\n # shift zero from end of shift_lags to beginning\\n shift_lags = np.roll(shift_lags, 1)\\n window = np.roll(window, 1)\\n\\n cf = correlation_function(s1, s2, shift_lags)\\n acf1 = correlation_function(s1, s1, shift_lags)\\n acf2 = correlation_function(s2, s2, shift_lags)\\n\\n if np.sum(np.isnan(cf)) > 0:\\n # print 'len(lags)=%d, len(s1)=%d, len(s2)=%d' % (len(lags), len(s1), len(s2))\\n print('signals=',zip(s1, s2))\\n print('shift_lags,cf=',zip(shift_lags, cf))\\n raise Exception(\\\"Nans in cf\\\")\\n\\n assert np.sum(np.isnan(acf1)) == 0, \\\"Nans in acf1\\\"\\n assert np.sum(np.isnan(acf2)) == 0, \\\"Nans in acf2\\\"\\n\\n if window_fraction is not None:\\n cf *= window\\n acf1 *= window\\n acf2 *= window\\n\\n cf_fft = fft(cf)\\n acf1_fft = fft(acf1)\\n acf2_fft = fft(acf2)\\n\\n acf1_ps = np.abs(acf1_fft)\\n acf2_ps = np.abs(acf2_fft)\\n\\n # determine which points are noise (with magnitudes too low to be useful) in the acfs\\n zeros = np.zeros([len(cf_fft)], dtype='bool')\\n if noise_floor_db is not None:\\n db1 = 20*np.log10(acf1_ps / acf1_ps.max()) + noise_floor_db\\n z1 = db1 <= 0\\n\\n db2 = 20*np.log10(acf2_ps / acf2_ps.max()) + noise_floor_db\\n z2 = db2 <= 0\\n zeros = z1 | z2\\n\\n assert np.abs(acf1_fft.imag).max() < 1e-8, \\\"acf1_fft.imag.max()=%f\\\" % np.abs(acf1_fft.imag).max()\\n assert np.abs(acf2_fft.imag).max() < 1e-8, \\\"acf2_fft.imag.max()=%f\\\" % np.abs(acf2_fft.imag).max()\\n\\n cpre = cf_fft / np.sqrt(acf1_ps*acf2_ps)\\n cpre[zeros] = 0\\n c = ifft(cpre)\\n assert np.abs(c.imag).max() < 1e-8, \\\"np.abs(c.imag).max()=%f\\\" % np.abs(c.imag).max()\\n\\n coh = fftshift(c.real)\\n freq = fftshift(fftfreq(len(lags)))\\n fi = freq >= 0\\n\\n if np.sum(np.abs(coh) > 1) > 0:\\n print('Warning: coherency is > 1!')\\n\\n if plot:\\n plt.figure()\\n plt.subplot(2, 3, 1)\\n plt.plot(s1, 'r-')\\n plt.plot(s2, 'b-')\\n plt.legend(['s1', 's2'])\\n plt.xlabel('Time')\\n plt.axis('tight')\\n plt.title('Signals')\\n\\n plt.subplot(2, 3, 2)\\n plt.axvline(0, c='k')\\n plt.axhline(0, c='k')\\n l1 = plt.plot(lags, fftshift(acf1), 'r-')\\n l2 = plt.plot(lags, fftshift(acf2), 'b-')\\n l3 = plt.plot(lags, fftshift(cf), 'g-')\\n plt.title('Correlation Functions')\\n plt.xlabel('Lags')\\n plt.legend(['', '', 'ACF1', 'ACF2', 'CF12'])\\n plt.axis('tight')\\n plt.ylim(-0.5, 1.0)\\n\\n plt.subplot(2, 3, 3)\\n plt.axhline(0, c='k', alpha=0.75)\\n plt.axvline(0, c='k', alpha=0.75)\\n plt.plot(lags, coh, 'm-')\\n plt.ylabel('Coherency')\\n plt.xlabel('Lag')\\n plt.axis('tight')\\n plt.title('Coherency')\\n\\n plt.subplot(2, 3, 4)\\n plt.plot(freq[fi], fftshift(acf1_ps)[fi], 'r')\\n plt.plot(freq[fi], fftshift(acf2_ps)[fi], 'b')\\n cf_ps = fftshift(np.abs(cf_fft))\\n cf_pre_ps = fftshift(np.abs(cpre))\\n plt.plot(freq[fi], cf_ps[fi], 'g--')\\n plt.plot(freq[fi], cf_pre_ps[fi], 'm-')\\n plt.legend(['ACF1', 'ACF2', 'CF12', 'CPRE'])\\n plt.ylabel('Power (raw)')\\n plt.xlabel('Frequency')\\n plt.axis('tight')\\n plt.title('Raw Power Spectra')\\n\\n if noise_floor_db:\\n plt.subplot(2, 3, 5)\\n plt.axhline(0, c='k')\\n plt.plot(freq[fi], fftshift(db1)[fi], 'r')\\n plt.plot(freq[fi], fftshift(db2)[fi], 'b')\\n plt.legend(['ACF1', 'ACF2'])\\n plt.ylabel('Power (dB)')\\n plt.xlabel('Frequency')\\n plt.axis('tight')\\n plt.title('Log Power Spectra')\\n\\n plt.show()\\n\\n return coh\",\n \"def rfft(pix, tcl):\\n nx, dx, ny, dy = pix.nx, pix.dx, pix.ny, pix.dy\\n \\n ret = maps.rfft(nx, dx, ny=ny, dy=dy)\\n ret.fft[:,:] = (np.random.standard_normal((ny,nx/2+1)) + 1.j * np.random.standard_normal((ny,nx/2+1))) / np.sqrt(2.)\\n ret.fft[0,0] = np.sqrt(2.) * np.real(ret.fft[0,0])\\n ret.fft[ny/2+1:, 0] = np.conj( ret.fft[1:ny/2,0][::-1] )\\n\\n ret.fft[:,:] *= np.interp( ret.get_ell().flatten(), np.arange(0,len(tcl)), np.sqrt(tcl), right=0 ).reshape( ret.fft.shape )\\n return ret\",\n \"def msd_Correlation(allX):\\n M = allX.shape[0]\\n # numpy with MKL (i.e. intelpython distribution), the fft wont be\\n # accelerated unless axis along 0 or -1\\n # perform FT along n_frame axis\\n # (n_frams, n_particles, n_dim) -> (n_frames_Ft, n_particles, n_dim)\\n allFX = np.fft.rfft(allX, axis=0, n=M*2)\\n # sum over n_dim axis\\n corr = np.sum(abs(allFX)**2, axis=(1, -1)) # (n_frames_ft,)\\n # IFT over n_frame_ft axis (axis=0), whole operation euqals to\\n # fx = fft(_.T[0]), fy =... for _ in\\n # allX.swapaxes(0,1) -> (n_particles, n_frames, n_dim)\\n # then sum fx, fy, fz...fndim\\n # rfft for real inputs, higher eff\\n return np.fft.irfft(corr, n=2 * M)[:M].real/np.arange(M, 0, -1)\\n # (n_frames,), the n_particles dimension is added out\",\n \"def fasper_py(x,y,ofac,hifac, MACC=4):\\n #Check dimensions of input arrays\\n n = long(len(x))\\n if n != len(y):\\n print 'Incompatible arrays.'\\n return\\n\\n nout = 0.5*ofac*hifac*n\\n nfreqt = long(ofac*hifac*n*MACC) #Size the FFT as next power\\n nfreq = 64L # of 2 above nfreqt.\\n\\n while nfreq < nfreqt: \\n nfreq = 2*nfreq\\n\\n ndim = long(2*nfreq)\\n \\n #Compute the mean, variance\\n ave = y.mean()\\n ##sample variance because the divisor is N-1\\n var = ((y-y.mean())**2).sum()/(len(y)-1) \\n # and range of the data.\\n xmin = x.min()\\n xmax = x.max()\\n xdif = xmax-xmin\\n\\n #extirpolate the data into the workspaces\\n wk1 = np.zeros(ndim, dtype='complex')\\n wk2 = np.zeros(ndim, dtype='complex')\\n\\n fac = ndim/(xdif*ofac)\\n fndim = ndim\\n ck = ((x-xmin)*fac) % fndim\\n ckk = (2.0*ck) % fndim\\n\\n for j in range(0L, n):\\n __spread__(y[j]-ave,wk1,ndim,ck[j],MACC)\\n __spread__(1.0,wk2,ndim,ckk[j],MACC)\\n\\n #Take the Fast Fourier Transforms\\n wk1 = np.fft.ifft( wk1 )*len(wk1)\\n wk2 = np.fft.ifft( wk2 )*len(wk1)\\n\\n wk1 = wk1[1:nout+1]\\n wk2 = wk2[1:nout+1]\\n rwk1 = wk1.real\\n iwk1 = wk1.imag\\n rwk2 = wk2.real\\n iwk2 = wk2.imag\\n \\n df = 1.0/(xdif*ofac)\\n \\n #Compute the Lomb value for each frequency\\n hypo2 = 2.0 * abs( wk2 )\\n hc2wt = rwk2/hypo2\\n hs2wt = iwk2/hypo2\\n\\n cwt = np.sqrt(0.5+hc2wt)\\n swt = np.sign(hs2wt)*(np.sqrt(0.5-hc2wt))\\n den = 0.5*n+hc2wt*rwk2+hs2wt*iwk2\\n cterm = (cwt*rwk1+swt*iwk1)**2./den\\n sterm = (cwt*iwk1-swt*rwk1)**2./(n-den)\\n\\n wk1 = df*(np.arange(nout, dtype='float')+1.)\\n wk2 = (cterm+sterm)/(2.0*var)\\n pmax = wk2.max()\\n jmax = wk2.argmax()\\n\\n\\n #Significance estimation\\n #expy = exp(-wk2) \\n #effm = 2.0*(nout)/ofac \\n #sig = effm*expy\\n #ind = (sig > 0.01).nonzero()\\n #sig[ind] = 1.0-(1.0-expy[ind])**effm\\n\\n #Estimate significance of largest peak value\\n expy = np.exp(-pmax) \\n effm = 2.0*(nout)/ofac \\n prob = effm*expy\\n\\n if prob > 0.01: \\n prob = 1.0-(1.0-expy)**effm\\n\\n return wk1,wk2,nout,jmax,prob\",\n \"def test_fft_complex_3d():\\n\\ta, b, c = np.meshgrid([0, 1, 0, 0], [0, 1j, 1j], [0, 1, 1, 1])\\n\\tdummy_array = xr.DataArray(a * b * c, dims=['x', 'y', 'z'])\\n\\tchunked_array = dummy_array.chunk(chunks={'x': 2, 'y': 2, 'z': 2})\\n\\tspectrum_array, spectrum_coords, spectrum_dims = \\\\\\n\\t\\txfft._fft(chunked_array, nfft={'x': 8, 'y': 6, 'z': 8},\\n\\t\\t dim=['x', 'y', 'z'], dx={'x':12, 'y': 0.01, 'z': 0.02})\\n\\tassert np.allclose(spectrum_array.compute(),\\n\\t np.fft.fftn(a * b * c, s=(8, 6, 8)))\\n\\tassert np.array_equal(spectrum_coords['f_x'], np.fft.fftfreq(8, d=12))\\n\\tassert np.array_equal(spectrum_coords['f_y'], np.fft.fftfreq(6, d=0.01))\\n\\tassert np.array_equal(spectrum_coords['f_z'], np.fft.fftfreq(8, d=0.02))\\n\\tassert ('f_x', 'f_y', 'f_z') == spectrum_dims\",\n \"def frft(f, a):\\n ret = numpy.zeros_like(f, dtype=numpy.complex)\\n f = f.copy().astype(numpy.complex)\\n N = len(f)\\n shft = numpy.fmod(numpy.arange(N) + numpy.fix(N / 2), N).astype(int)\\n sN = numpy.sqrt(N)\\n a = numpy.remainder(a, 4.0)\\n\\n # Special cases\\n if a == 0.0:\\n return f\\n if a == 2.0:\\n return numpy.flipud(f)\\n if a == 1.0:\\n ret[shft] = numpy.fft.fft(f[shft]) / sN\\n return ret\\n if a == 3.0:\\n ret[shft] = numpy.fft.ifft(f[shft]) * sN\\n return ret\\n\\n # reduce to interval 0.5 < a < 1.5\\n if a > 2.0:\\n a = a - 2.0\\n f = numpy.flipud(f)\\n if a > 1.5:\\n a = a - 1\\n f[shft] = numpy.fft.fft(f[shft]) / sN\\n if a < 0.5:\\n a = a + 1\\n f[shft] = numpy.fft.ifft(f[shft]) * sN\\n\\n # the general case for 0.5 < a < 1.5\\n alpha = a * numpy.pi / 2\\n tana2 = numpy.tan(alpha / 2)\\n sina = numpy.sin(alpha)\\n f = numpy.hstack((numpy.zeros(N - 1), sincinterp(f), numpy.zeros(N - 1))).T\\n\\n # chirp premultiplication\\n chrp = numpy.exp(-1j * numpy.pi / N * tana2 / 4 *\\n numpy.arange(-2 * N + 2, 2 * N - 1).T ** 2)\\n f = chrp * f\\n\\n # chirp convolution\\n c = numpy.pi / N / sina / 4\\n tmp = numpy.exp(1j * c * numpy.arange(-(4 * N - 4), 4 * N - 3).T ** 2)\\n ret = scipy.signal.fftconvolve(\\n numpy.exp(1j * c * numpy.arange(-(4 * N - 4), 4 * N - 3).T ** 2),\\n f\\n )\\n ret = ret[4 * N - 4:8 * N - 7] * numpy.sqrt(c / numpy.pi)\\n\\n # chirp post multiplication\\n ret = chrp * ret\\n\\n # normalizing constant\\n ret = numpy.exp(-1j * (1 - a) * numpy.pi / 4) * ret[N - 1:-N + 1:2]\\n\\n return ret\",\n \"def fft_checking(filename):\\n\\n # print out experimental parameters and store the case name\\n casename, Re, We = file_id(filename)\\n\\n # load the data into three numpy arrays\\n frames, left_edges, right_edges = np.loadtxt(filename, delimiter=',',\\n unpack=True)\\n # create a new numpy array which converts the frames into time by using\\n # the frame rate\\n frame_time = frames/27000\\n # calculating the jet diameter (numpy array)\\n jet_diameter = 0.02*(right_edges-left_edges)\\n # calculating the jet centroid (numpy array)\\n jet_centroid = 0.02*0.5*(right_edges+left_edges)\\n\\n # setting up plots for left and right edges\\n fig, ax = plt.subplots()\\n # plotting left edge\\n ax.plot(frame_time, left_edges)\\n # plotting right edge\\n ax.plot(frame_time, right_edges, '.')\\n ax.set_xlabel('frame_time (seconds)')\\n ax.set_ylabel('Pixels')\\n ax.set_title('Edges plot')\\n\\n # plotting jet diameter\\n fig1, ax1 = plt.subplots()\\n ax1.plot(frame_time, jet_diameter)\\n ax1.set_xlabel('frame_time (seconds)')\\n ax1.set_ylabel('Jet diameter (mm)')\\n ax1.set_title('Jet diameter plot')\\n\\n # plotting jet centroid\\n fig2, ax2 = plt.subplots()\\n ax2.plot(frame_time, jet_centroid)\\n ax2.set_xlabel('frame_time (seconds)')\\n ax2.set_ylabel('Jet centroid location (mm)')\\n ax2.set_title('Jet centroid plot')\\n\\n # shifted FFTs\\n # Shifted jet diameter plotting\\n shifted_jet_diameter = jet_diameter - np.mean(jet_diameter)\\n fig5, ax5 = plt.subplots()\\n ax5.plot(frame_time, shifted_jet_diameter)\\n ax5.set_title(\\\"Shifted jet diameter\\\")\\n ax5.set_xlabel('frame_time (seconds)')\\n ax5.set_ylabel('Shifted jet diameter (mm)')\\n\\n # shifted jet diameter fft\\n shifted_jet_diameter_fft = rfft(shifted_jet_diameter)\\n shifted_jet_diameter_freqs = rfftfreq(len(shifted_jet_diameter), 1/27000)\\n\\n fig6, ax6 = plt.subplots()\\n ax6.stem(shifted_jet_diameter_freqs, np.abs(shifted_jet_diameter_fft))\\n ax6.set_title('Shifted jet diameter FFT')\\n ax6.set_xlabel('Frequencies')\\n ax6.set_ylabel('Amplitude')\\n\\n # shifted jet centroid plotting\\n shifted_jet_centroid = jet_centroid - np.mean(jet_centroid)\\n fig7, ax7 = plt.subplots()\\n ax7.plot(frame_time, shifted_jet_centroid)\\n ax7.set_title(\\\"Shifted jet centroid\\\")\\n ax7.set_xlabel('frame_time (seconds)')\\n ax7.set_ylabel('Shifted jet centroid (mm)')\\n\\n # shifted jet centroid fft\\n shifted_jet_centroid_fft = rfft(shifted_jet_centroid)\\n shifted_jet_centroid_freqs = rfftfreq(len(shifted_jet_centroid), 1/27000)\\n\\n fig8, ax8 = plt.subplots()\\n ax8.stem(shifted_jet_centroid_freqs, np.abs(shifted_jet_centroid_fft))\\n ax8.set_title('Shifted jet centroid FFT')\\n ax8.set_xlabel('Frequencies')\\n ax8.set_ylabel('Amplitude')\\n\\n zero_events = np.count_nonzero(jet_diameter == 0)\\n\\n print('Number of zero events:', zero_events)\\n print(\\\"Percentage of total:\\\", zero_events/len(jet_diameter)*100)\\n print('Number of frames:', len(frames))\",\n \"def __get_rfft():\\n try:\\n import pyfftw\\n import os\\n pyfftw.interfaces.cache.enable()\\n pyfftw.interfaces.cache.set_keepalive_time(5)\\n if pyfftw.config.NUM_THREADS == 1:\\n pyfftw.config.NUM_THREADS = \\\\\\n len(os.sched_getaffinity(0)) if hasattr(os, 'sched_getaffinity') else os.cpu_count()\\n pyfftw.config.PLANNER_EFFORT = 'FFTW_MEASURE'\\n\\n def rfftn(*args, **kwargs):\\n return pyfftw.interfaces.numpy_fft.rfftn(*args, overwrite_input=True, **kwargs)\\n def irfftn(*args, **kwargs):\\n return pyfftw.interfaces.numpy_fft.irfftn(*args, overwrite_input=True, **kwargs)\\n empty_aligned = pyfftw.empty_aligned\\n\\n except ImportError:\\n from numpy.fft import rfftn, irfftn\\n empty_aligned = empty\\n\\n return rfftn, irfftn, empty_aligned\",\n \"def calc_corr(f, f_unc, g, g_unc, fac, fac_unc):\\n # calculate the covariance between f and g\\n # cov(f,g) = (df/dfac) * (dg/dfac) * fac_unc**2\\n # in this case f=x/fac, g=y/fac\\n # so cov(f,g) = f * g * fac_unc**2 / fac**2\\n cov = f * g * fac_unc ** 2 / fac ** 2\\n\\n # calculate and return the correlation coefficient between f and g\\n # corr = cov(f,g) / (f_unc * g_unc)\\n return cov / (f_unc * g_unc)\",\n \"def test_rtf_evd(self):\\n n_fft_bin = 10\\n channel = 4\\n specgram = np.random.random((n_fft_bin, channel)) + np.random.random((n_fft_bin, channel)) * 1j\\n psd = np.einsum(\\\"fc,fd->fcd\\\", specgram.conj(), specgram)\\n rtf = beamform_utils.rtf_evd_numpy(psd)\\n rtf_audio = F.rtf_evd(torch.tensor(psd, dtype=self.complex_dtype, device=self.device))\\n self.assertEqual(torch.tensor(rtf, dtype=self.complex_dtype, device=self.device), rtf_audio)\",\n \"def autocorrelation_1d(data):\\n\\n N = len(data)\\n n_fft = select_power_of_two(N)\\n\\n # Pad the signal with zeros to avoid the periodic images.\\n\\n R_data = np.zeros(2*n_fft)\\n R_data[:N] = data\\n\\n F_data = np.fft.fft(R_data)\\n\\n result = np.fft.ifft(F_data*F_data.conj())[:N].real/(N-np.arange(N))\\n\\n return result[:N]\",\n \"def xcorr(t, x, y, zeropad=True):\\n tau = t\\n # sx = len(x)\\n # sy = len(y)\\n if zeropad is True:\\n Xn = np.fft.rfft(x, n=len(x) * 2)\\n Yn = np.conj(sp.fft(y, n=len(x) * 2))\\n else:\\n Xn = np.fft.rfft(x)\\n Yn = np.conj(np.fft.rfft(y))\\n\\n xcor = np.real(fftpack.fftshift(sp.ifft(Xn * Yn)))\\n dt = t[1] - t[0]\\n\\n tau = np.linspace(-len(xcor) / 2 * dt - dt / 2,\\n len(xcor) / 2 * dt - dt / 2, len(xcor))\\n return tau, xcor\",\n \"def BLUE_simple_flatfield_corr(flat, real):\\n real=real.astype(np.float64)\\n flat=flat.astype(np.float64)\\n\\n \\n row_averages=[]\\n for row in real:\\n row_median=np.median(row)\\n row_averages.append(row_median)\\n plt.plot(np.linspace(0,len(row_averages), len(row_averages)),row_averages)\\n plt.show()\\n plt.close()\\n \\n row_averages=[]\\n for row in flat:\\n row_median=np.median(row)\\n row_averages.append(row_median)\\n plt.plot(np.linspace(0,len(row_averages), len(row_averages)),row_averages, color=\\\"red\\\")\\n \\n \\n target_average=np.median(row_averages[700:])\\n F_row_average=row_averages.copy()\\n k=(row_averages[750]-row_averages[1500])/750\\n \\n for i in range(1501):\\n F_row_average[1500-i]=row_averages[1500]+k*i\\n for i in range(len(row_averages)-1500):\\n F_row_average[1500+i]=row_averages[1500]-k*i\\n plt.plot(np.linspace(0,len(row_averages), len(row_averages)),F_row_average, color=\\\"blue\\\")\\n \\n C=np.copy(real)\\n for i, row in enumerate(flat, start=0):\\n row_median=np.median(row)\\n row_averages[i]=row_averages[i]/(row_median/target_average)\\n gain=row_median/F_row_average[i]\\n C[i]=C[i]/gain\\n plt.plot(np.linspace(0,len(row_averages), len(row_averages)),row_averages, color=\\\"green\\\") \\n plt.show()\\n plt.close()\\n \\n return C\",\n \"def test_pattern_correlation(self):\\n x = self.D.copy()\\n\\n # correlation with random values\\n y = self.D.copy()\\n tmp = np.random.random(y.shape)\\n y.data = np.ma.array(tmp, mask=tmp != tmp)\\n P2 = PatternCorrelation(x, y)\\n P2._correlate()\\n self.assertEqual(x.nt,len(P2.r_value))\\n self.assertEqual(x.nt,len(P2.t))\\n\\n for i in xrange(x.nt):\\n slope, intercept, r_value, p_value, std_err = stats.mstats.linregress(x.data[i,:,:].flatten(),y.data[i,:,:].flatten())\\n self.assertEqual(P2.r_value[i], r_value)\\n self.assertEqual(P2.p_value[i], p_value)\\n self.assertEqual(P2.slope[i], slope)\\n self.assertEqual(P2.intercept[i], intercept)\\n self.assertEqual(P2.std_err[i], std_err)\",\n \"def build_oblique_foF2_observed_by_radar(rad=\\\"cvw\\\", dates=[dt.datetime(2017,8,21), dt.datetime(2017,8,21)], bmnum=11, scan_num=1,\\n remove_first_range=800, remove_last_range=2500, power_drop=10., plot=True):\\n csv_fname = \\\"data/{rad}_{start}_{end}.csv\\\".format(rad=rad, start=dates[0].strftime(\\\"%Y.%m.%d.%H.%M\\\"), \\n end=dates[1].strftime(\\\"%Y.%m.%d.%H.%M\\\"))\\n if not os.path.exists(csv_fname):\\n fdata = FetchData( rad, [dates[0], dates[1]] )\\n s_params = [\\\"noise.sky\\\", \\\"tfreq\\\", \\\"frang\\\", \\\"rsep\\\", \\\"scan\\\", \\\"bmnum\\\"]\\n v_params = [\\\"slist\\\", \\\"v\\\", \\\"w_l\\\", \\\"p_l\\\", \\\"elv\\\"]\\n _, scans = fdata.fetch_data(by=\\\"scan\\\", s_params=s_params, v_params=v_params)\\n beams = []\\n # Resacle tx_frequency and estimate slant range \\n for scan in scans:\\n for beam in scan.beams:\\n if len(beam.slist) > 0:\\n setattr(beam, \\\"slant_range\\\", beam.frang + np.array(beam.slist.tolist()) * beam.rsep)\\n setattr(beam, \\\"tfreq\\\", np.round(beam.tfreq/1e3,1))\\n beams.append(beam)\\n # Extract oblique foF2 or MUF scan by scan\\n print(\\\"\\\\n Data will be averaged over {} scans\\\".format(scan_num))\\n print(\\\" Processing beam {}\\\".format(bmnum))\\n print(\\\" Remove first range {}\\\".format(remove_first_range))\\n print(\\\" Remove last range {}\\\".format(remove_last_range))\\n print(\\\" Power drop {}\\\".format(power_drop))\\n skip_distance, o_foF2, time_start, time_end = [], [], [], []\\n for i in range(len(scans)-scan_num):\\n rscan = scans[i:i+scan_num]\\n p_l, srange, tfrq, angle = [], [], [], []\\n for scan in rscan:\\n for beam in scan.beams:\\n if beam.bmnum == bmnum:\\n if len(beam.slist) > 0:\\n p_l.extend(beam.p_l.tolist())\\n srange.extend(beam.slant_range.tolist())\\n tfrq.append(beam.tfreq)\\n if type(beam.elv) is list: angle.extend(beam.elv)\\n else: angle.extend(beam.elv.tolist())\\n du = pd.DataFrame()\\n du[\\\"p_l\\\"], du[\\\"srange\\\"] = p_l, srange\\n du = du[(du.srange>remove_first_range) & (du.srange<remove_last_range)]\\n fname = \\\"images/{}.png\\\".format(rscan[0].stime.strftime(\\\"%Y-%m-%d-%H-%M\\\"))\\n if len(du) > 0:\\n sd = fit_lambda(du, power_drop, tfreq=np.mean(tfrq), elv=np.mean(angle).round(1), \\n xlabel=\\\"srange\\\", ylabel=\\\"p_l\\\", fname=fname, plot=plot)\\n if sd != np.nan:\\n skip_distance.append(sd)\\n o_foF2.append(np.mean(tfrq))\\n time_start.append(rscan[0].stime)\\n time_end.append(rscan[-1].stime)\\n df = pd.DataFrame()\\n df[\\\"skip_distance\\\"], df[\\\"o_foF2\\\"], df[\\\"time_start\\\"], df[\\\"time_end\\\"] = skip_distance, o_foF2, time_start, time_end\\n df.to_csv(csv_fname, index=False, header=True)\\n else: df = pd.read_csv(csv_fname, parse_dates=[\\\"time_start\\\", \\\"time_end\\\"])\\n print(\\\" Header:\\\\n\\\",df.head())\\n return df\",\n \"def corfftc(z, Z_cum, N, M, HR, HS, HH):\\n # 2-D FFT\\n Z = np.zeros((N[2], M[1]), dtype=complex)\\n if M[3]:\\n idLeft = np.concatenate((np.array(range(M[0]+M[3])), np.array(range(M[3]))+M[2]-M[3]))\\n idRight = np.concatenate((np.array(range(M[0]+M[3]))+M[3], np.array(range(M[3]))))\\n z[:, idLeft] = z[:, idRight];\\n else:\\n zTmp = np.zeros((z.shape[0], M[2]), dtype=complex)\\n zTmp[:z.shape[0], :z.shape[1]] = z\\t\\n z = zTmp\\n for n in range(int(N[0]+N[3]*2)):\\n R1 = np.fft.fft(z[n, :]);\\n Z[n, :] = R1[:int(M[1])];\\n for m in range(int(M[1])):\\n Z[:, m] = np.fft.fft(Z[:, m]);\\n # cumulation\\n R1 = np.dot(HR[:, np.newaxis], HS[:, np.newaxis].T);\\n HH = HH + R1 * np.conj(R1);\\n Z_cum = Z_cum + R1 * Z;\\n return Z_cum, HH\",\n \"def test_sff_corrector():\\n # The following csv file, provided by Vanderburg and Johnson\\n # at https://www.cfa.harvard.edu/~avanderb/k2/ep60021426.html,\\n # contains the results of applying SFF to EPIC 60021426.\\n fn = get_pkg_data_filename('./data/ep60021426alldiagnostics.csv')\\n data = np.genfromtxt(fn, delimiter=',', skip_header=1)\\n mask = data[:, -2] == 0 # indicates whether the thrusters were on or off\\n time = data[:, 0]\\n raw_flux = data[:, 1]\\n corrected_flux = data[:, 2]\\n centroid_col = data[:, 3]\\n centroid_row = data[:, 4]\\n arclength = data[:, 5]\\n correction = data[:, 6]\\n\\n lc = LightCurve(time=time, flux=raw_flux)\\n sff = SFFCorrector(lc)\\n corrected_lc = sff.correct(centroid_col=centroid_col,\\n centroid_row=centroid_row,\\n niters=1, windows=1)\\n # do hidden plots execute smoothly?\\n sff._plot_rotated_centroids()\\n sff._plot_normflux_arclength()\\n\\n # the factor self.bspline(time-time[0]) accounts for\\n # the long term trend which is divided out in order to get a \\\"flat\\\"\\n # lightcurve.\\n assert_almost_equal(corrected_lc.flux*sff.bspline(time),\\n corrected_flux, decimal=3)\\n assert_array_equal(time, corrected_lc.time)\\n # the factor of 4 below accounts for the conversion\\n # between pixel units to arcseconds\\n assert_almost_equal(4*sff.s, arclength, decimal=2)\\n assert_almost_equal(sff.interp(sff.s), correction, decimal=3)\\n\\n # test using KeplerLightCurve interface\\n klc = KeplerLightCurve(time=time, flux=raw_flux, centroid_col=centroid_col,\\n centroid_row=centroid_row)\\n klc = klc.correct(niters=1, windows=1)\\n sff = klc.corrector\\n\\n assert_almost_equal(klc.flux*sff.bspline(time),\\n corrected_flux, decimal=3)\\n assert_almost_equal(4*sff.s, arclength, decimal=2)\\n assert_almost_equal(sff.interp(sff.s), correction, decimal=3)\\n assert_array_equal(time, klc.time)\",\n \"def test_crf():\\n\\n print '\\\\n\\\\ttest crf'\\n os.system('crf_test -m ' + model_file + ' ' + test_file_crf + ' -o ' + encoded_test)\\n print '\\\\t--done'\",\n \"def get_cffts(self):\\n return [\\n rfft(self.nx, self.dx, fft=self.tfft, ny=self.ny,\\n dy=self.dy).get_cfft(),\\n rfft(self.nx, self.dx, fft=self.efft, ny=self.ny,\\n dy=self.dy).get_cfft(),\\n rfft(self.nx, self.dx, fft=self.bfft, ny=self.ny,\\n dy=self.dy).get_cfft()\\n ]\",\n \"def downsampleConvolveROTF(img, rotf, newfullsize, maxdim=3):\\n # def grad(dy, variables=['tfin','otf']):\\n axes = None\\n if maxdim is not None:\\n axes = [d for d in range(-maxdim, 0)] # transform along all the axes within the maxdim range\\n\\n myrft = rft(img, axes=axes)\\n oldfullsize = img.shape\\n res = resampleRFT(myrft, rotf.shape, oldfullsize, newfullsize, maxdim=maxdim)\\n newfullsz = res.shape[:-len(newfullsize)] + tuple(newfullsize)\\n newfullsz = np.array(newfullsz)\\n res = irft(res * rotf, newfullsz, axes=axes)\\n mypixelsize = image.getPixelsize(img)\\n if mypixelsize is not None:\\n res.set_pixelsize(mypixelsize, factors=np.array(img.shape) / np.array(res.shape))\\n else:\\n res.pixelsize = None\\n return res\",\n \"def Coherence(wfr, Fx = 1/3, Fy = 1/3, pathX = None, pathY = None, pathC = None, pathCL = None, pathI = None):\\n \\n print(\\\"----Starting Coherence Function---\\\")\\n \\n Sx = int(Fx*wfr.params.Mesh.nx)\\n Sy = int(Fy*wfr.params.Mesh.ny)\\n print(\\\"Sampled area (pixels): {}\\\".format([Sx,Sy]))\\n \\n if Sx > 120 or Sy > 120:\\n print(\\\"Error: Sampled area of wavefront is too large. Change Fx/Fy to a smaller value\\\")\\n import sys\\n sys.exit()\\n \\n start1 = time.time()\\n cfr = getComplex(wfr)\\n print(\\\"Shape of Complex Wavefield: {}\\\".format(np.shape(cfr)))\\n end1 = time.time()\\n print('Time taken to convert to complex wavefield (s): {}'.format(end1 - start1))\\n \\n _x0 = 0 # These are in _pixel_ coordinates!!\\n _y0 = 0\\n _x1 = int(np.max(np.shape(cfr[:,0,0]))) # These are in _pixel_ coordinates!!\\n _y1 = int(np.max(np.shape(cfr[0,:,0])))\\n \\n print(\\\"Nx (pixels): {}\\\".format(_x1))\\n print(\\\"Ny (pixels): {}\\\".format(_y1))\\n \\n numx = _x1 - _x0 # number of points for line profile\\n numy = _y1 - _y0\\n midX = int(numx/2)\\n midY = int(numy/2)\\n \\n print(\\\"mid x: {}\\\".format(midX))\\n print(\\\"mid y: {}\\\".format(midY))\\n\\n # # Fraction of wavefront to calculate coherence over\\n # Fx = 1/3\\n # Fy = 1/3\\n \\n ROI = ((int(midX-((Fx)*midX)),int(midY-((Fy)*midY))),\\n (int(midX+((Fx)*midX)),int(midY+((Fy)*midY)))) \\n \\n lX = ROI[1][0]-ROI[0][0]\\n lY = ROI[1][1]-ROI[0][1]\\n \\n print(\\\"Region of interest (pixels): {}\\\".format((lX,lY)))\\n \\n x0,y0 = ROI[0][0], ROI[0][1]\\n x1,y1 = ROI[1][0], ROI[1][1]\\n \\n A = cfr[y0:y1,x0:x1]\\n \\n A_x1 = int(np.max(np.shape(A[:,0,0]))) # These are in _pixel_ coordinates!!\\n A_y1 = int(np.max(np.shape(A[0,:,0])))\\n \\n print(\\\"Nx (pixels): {}\\\".format(_x1))\\n print(\\\"Ny (pixels): {}\\\".format(_y1))\\n \\n Anumx = A_x1 # number of points for line profile\\n Anumy = A_y1\\n AmidX = int(Anumx/2)\\n AmidY = int(Anumy/2)\\n \\n \\n \\\"\\\"\\\" Cross Spectral Density (W) & Mutual Intensity Functions (Jx,Jy) \\\"\\\"\\\"\\n start2 = time.time()\\n B = np.array([A.conjugate() * a for a in A.flatten()])#[:,:,:,0] \\n Bx = np.array([A[:,AmidY].conjugate() * a for a in A[:,AmidY]])\\n By = np.array([A[AmidX,:].conjugate() * a for a in A[AmidX,:]])\\n end2 = time.time()\\n print('Time taken to calculate Mutual Intensity [J] (s): {}'.format(end2 - start2))\\n \\n print(\\\"Shape of B: {}\\\".format(np.shape(B)))\\n print(\\\"Shape of Bx: {}\\\".format(np.shape(Bx)))\\n print(\\\"Shape of By: {}\\\".format(np.shape(By)))\\n \\n C = abs(B.mean(0))\\n # Cx = abs(Bx.mean(0))\\n # Cy = abs(By.mean(0))\\n \\n print(\\\"Shape of C: {}\\\".format(np.shape(C)))\\n # print(\\\"Shape of Cx: {}\\\".format(np.shape(Cx)))\\n # print(\\\"Shape of Cy: {}\\\".format(np.shape(Cy)))\\n \\n \\n # if wfr is Wavefront():\\n Dx = Fx*wfr.params.Mesh.xMax - Fx*wfr.params.Mesh.xMin\\n Dy = Fy*wfr.params.Mesh.yMax - Fy*wfr.params.Mesh.yMin\\n # # else:\\n # # Dx = Fx*wfr.mesh.xFin - Fx*wfr.mesh.xStart\\n # # Dy = Fy*wfr.mesh.yfin - Fy*wfr.mesh.yStart\\n \\n \\n \\\"\\\"\\\" Creating array of custom tick markers for plotting \\\"\\\"\\\"\\n tickAx = [round_sig(-Dx*1e6/2),round_sig(-Dx*1e6/4),0,round_sig(Dx*1e6/4),round_sig(Dx*1e6/2)]\\n tickAy = [round_sig(Dy*1e6/2),round_sig(Dy*1e6/4),0,round_sig(-Dy*1e6/4),round_sig(-Dy*1e6/2)]\\n \\n print(\\\"Array of horizontal markers: {}\\\".format(tickAx))\\n print(\\\"Array of vertical markers: {}\\\".format(tickAy))\\n \\n plt.imshow(abs(Bx))#,vmin=np.min(C),vmax=np.max(C))\\n plt.title(\\\"Mutual Intensity (x1-x0)\\\")\\n plt.colorbar()\\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\\n plt.yticks(np.arange(0,lY+1,lY/4),tickAy)\\n plt.xlabel(\\\"Horizontal Position [\\\\u03bcm]\\\")#\\\"(\\\\u03bcm)\\\")\\n plt.ylabel(\\\"Vertical Position [\\\\u03bcm]\\\")#\\\"(\\\\u03bcm)\\\")\\n if pathX != None:\\n print(\\\"Saving (x1-x0) figure to path: {}\\\".format(pathX))\\n plt.savefig(pathX)\\n plt.show() \\n \\n plt.imshow(abs(By))#,vmin=np.min(C),vmax=np.max(C))\\n plt.title(\\\"Mutual Intensity (y1-y0)\\\")\\n plt.colorbar()\\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\\n plt.yticks(np.arange(0,lY+1,lY/4),tickAy)\\n plt.xlabel(\\\"Horizontal Position [\\\\u03bcm]\\\")#\\\" (\\\\u03bcm)\\\")\\n plt.ylabel(\\\"Vertical Position [\\\\u03bcm]\\\")#\\\"(\\\\u03bcm)\\\")\\n if pathY != None:\\n print(\\\"Saving (y1-y0) figure to path: {}\\\".format(pathY))\\n plt.savefig(pathY)\\n plt.show() \\n \\n \\\"\\\"\\\" Normalised Degree of Coherence \\\"\\\"\\\"\\n U = 1-(abs((C)/(A.conjugate()*A)))\\n \\n \\n \\\"\\\"\\\" Taking line profiles through U \\\"\\\"\\\"\\n X = U[0:int(np.max(np.shape(U[:,0]))), int((y1-y0)/2)]\\n Y = U[int((x1-x0)/2), 0:int(np.max(np.shape(U[0,:])))]\\n \\n # print(x0,x1)\\n # print(y0,y1)\\n \\n \\n print(\\\"Sampled area dimensions (m): {}\\\".format([Dx,Dy]))\\n \\n pX = Dx/lX\\n pY = Dy/lY\\n \\n print(\\\"Pixel size (m): {}\\\".format([pX,pY]))\\n print(\\\"Shape of U (pixels): {}\\\".format(np.shape(U)))\\n \\n \\n \\\"\\\"\\\"Plotting\\\"\\\"\\\"\\n plt.imshow(U ,vmin=0,vmax=1)\\n plt.title(\\\"Degree of Coherence (1/\\\\u03bc)\\\")\\n plt.colorbar()\\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\\n plt.yticks(np.arange(0,lY+1,lY/4),tickAy)\\n plt.xlabel(\\\"Horizontal Position [\\\\u03bcm]\\\")#\\\"(\\\\u03bcm)\\\")\\n plt.ylabel(\\\"Vertical Position [\\\\u03bcm]\\\")#\\\"(\\\\u03bcm)\\\")\\n if pathC != None:\\n print(\\\"Saving Degree of Coherence figure to path: {}\\\".format(pathC))\\n plt.savefig(pathC)\\n plt.show() \\n \\n plt.plot(X, label=\\\"Horizontal Profile\\\")\\n plt.plot(Y, label=\\\"Vertical Profile\\\")\\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\\n plt.xlabel(\\\"Horizontal Position [\\\\u03bcm]\\\")#\\\"(\\\\u03bcm)\\\")\\n plt.ylim(0,1.1)\\n if pathCL != None:\\n print(\\\"Saving line profile figure to path: {}\\\".format(pathCL))\\n plt.savefig(pathCL)\\n # locs, labels = plt.xticks()\\n # labels = [round(float(item)*pX*1e7, 2 - int(math.floor(math.log10(abs(float(item)*pX*1e7)))) - 1) for item in locs]\\n # plt.xticks(locs, labels)\\n plt.legend()\\n \\n # round(float(item)*pX*1e7, 2 - int(math.floor(math.log10(abs(float(item)*pX*1e7)))) - 1)\\n plt.show()\\n \\n # print('coherence array shape: {}'.format(np.shape(B)))\\n # plt.plot(B)\\n # plt.show()\\n \\n # D = np.reshape(B,())\\n \\n plt.imshow(abs(A.conjugate()*A))\\n plt.title(\\\"intensity\\\")\\n plt.xticks(np.arange(0,lX+1,lX/4),tickAx)\\n plt.yticks(np.arange(0,lY+1,lY/4),tickAy)\\n plt.xlabel(\\\"Horizontal Position [\\\\u03bcm]\\\")#\\\"(\\\\u03bcm)\\\")\\n plt.ylabel(\\\"Vertical Position [\\\\u03bcm]\\\")#\\\"(\\\\u03bcm)\\\")\\n plt.colorbar()\\n if pathI != None:\\n print(\\\"Saving intensity figure to path: {}\\\".format(pathI))\\n plt.savefig(pathI)\\n plt.show()\\n \\n return B ,Dx, Dy\",\n \"def do_fft(self, cs_data):\\n\\n for fbin in range(self.fft_bins):\\n idx1 = int(fbin * floor(nfft * (1. - overlap)))\\n idx2 = idx1 + nfft\\n\\n sx = cs_data[:, idx1:idx2]\\n\\n if detrend == 1:\\n sx = detrend(sx, type='linear', axis=1)\\n sx = detrend(sx, type='constant', axis=1) # subtract mean\\n\\n sx = sx * win # apply window function\\n\\n # get fft\\n SX = np.fft.fft(sx, n=nfft)/nfft # divide by the length\\n if np.mod(nfft, 2) == 0: # even nfft\\n SX = np.hstack([SX[0:int(nfft/2)], np.conj(SX[int(nfft/2)]), SX[int(nfft/2):nfft]])\\n if full == 1: # shift to -fN ~ 0 ~ fN\\n SX = np.fft.fftshift(SX)\\n else: # half 0 ~ fN\\n SX = SX[0:int(nfft/2+1)]\\n\\n fftdata[b,:] = SX\\n\\n return ax, fftdata, win_factor\",\n \"def test_conv2d_fft(self):\\n\\t\\t\\n\\t\\tdetails = self.watcher.describe(layers=[self.first_layer], conv2d_fft=True)\\n\\t\\tprint(details)\\n\\t\\t\\n\\t\\tdetails = self.watcher.analyze(layers=[self.first_layer], conv2d_fft=True)\\n\\t\\tactual = details.alpha.to_numpy()[0]\\n\\t\\texpected = 2.144\\n\\t\\tself.assertAlmostEqual(actual,expected, delta=0.01)\",\n \"def test_frustum_planes_ring_cam() -> None:\\n near_clip_dist = 6.89 # arbitrary value\\n\\n # Set \\\"focal_length_x_px_\\\"\\n fx_px = 1402.4993697398709\\n\\n # Set \\\"focal_length_y_px_\\\"\\n fy_px = 1405.1207294310225\\n\\n # Set \\\"focal_center_x_px_\\\"\\n cx_px = 957.8471720086527\\n\\n # Set \\\"focal_center_y_px_\\\"\\n cy_px = 600.442948946496\\n\\n camera_name = \\\"ring_front_right\\\"\\n height_px = 1550\\n width_px = 2048\\n\\n pinhole_camera = _create_pinhole_camera(\\n fx_px=fx_px,\\n fy_px=fy_px,\\n cx_px=cx_px,\\n cy_px=cy_px,\\n height_px=height_px,\\n width_px=width_px,\\n cam_name=camera_name,\\n )\\n (\\n left_plane,\\n right_plane,\\n near_plane,\\n bottom_plane,\\n top_plane,\\n ) = pinhole_camera.frustum_planes(near_clip_dist)\\n\\n left_plane_expected: NDArrayFloat = np.array([fx_px, 0.0, width_px / 2.0, 0.0])\\n right_plane_expected: NDArrayFloat = np.array([-fx_px, 0.0, width_px / 2.0, 0.0])\\n near_plane_expected: NDArrayFloat = np.array([0.0, 0.0, 1.0, -near_clip_dist])\\n bottom_plane_expected: NDArrayFloat = np.array([0.0, -fx_px, height_px / 2.0, 0.0])\\n top_plane_expected: NDArrayFloat = np.array([0.0, fx_px, height_px / 2.0, 0.0])\\n\\n assert np.allclose(\\n left_plane, left_plane_expected / np.linalg.norm(left_plane_expected)\\n )\\n assert np.allclose(\\n right_plane, right_plane_expected / np.linalg.norm(right_plane_expected)\\n )\\n assert np.allclose(\\n bottom_plane, bottom_plane_expected / np.linalg.norm(bottom_plane_expected)\\n )\\n assert np.allclose(\\n top_plane, top_plane_expected / np.linalg.norm(top_plane_expected)\\n )\\n assert np.allclose(near_plane, near_plane_expected)\",\n \"def fftconvolve(in1, in2, mode=\\\"full\\\", axis=None):\\n\\ts1 = np.array(in1.shape)\\n\\ts2 = np.array(in2.shape)\\n\\tcomplex_result = (np.issubdtype(in1.dtype, np.complex) or\\n\\t\\t\\t\\t\\t np.issubdtype(in2.dtype, np.complex))\\n\\n\\tif axis is None:\\n\\t\\tsize = s1 + s2 - 1\\n\\t\\tfslice = tuple([ slice(0, int(sz)) for sz in size ])\\n\\telse:\\n\\t\\tequal_shapes = s1 == s2\\n\\t\\t# allow equal_shapes[axis] to be False\\n\\t\\tequal_shapes[ axis ] = True\\n\\t\\tassert equal_shapes.all(), 'Shape mismatch on non-convolving axes'\\n\\t\\tsize = s1[ axis ] + s2[ axis ] - 1\\n\\t\\tfslice = [ slice(l) for l in s1 ]\\n\\t\\tfslice[ axis ] = slice(0, int(size))\\n\\t\\tfslice = tuple(fslice)\\n\\n\\t# Always use 2**n-sized FFT\\n\\tfsize = 2**int(np.ceil(np.log2(size)))\\n\\tif axis is None:\\n\\t\\tIN1 = fftpack.fftn(in1, fsize)\\n\\t\\tIN1 *= fftpack.fftn(in2, fsize)\\n\\t\\tret = fftpack.ifftn(IN1)[ fslice ].copy()\\n\\telse:\\n\\t\\tIN1 = fftpack.fft(in1, fsize, axis=axis)\\n\\t\\tIN1 *= fftpack.fft(in2, fsize, axis=axis)\\n\\t\\tret = fftpack.ifft(IN1, axis=axis)[ fslice ].copy()\\n\\tdel IN1\\n\\tif not complex_result:\\n\\t\\tret = ret.real\\n\\tif mode == \\\"full\\\":\\n\\t\\treturn ret\\n\\telif mode == \\\"same\\\":\\n\\t\\tif np.product(s1, axis=0) > np.product(s2, axis=0):\\n\\t\\t\\tosize = s1\\n\\t\\telse:\\n\\t\\t\\tosize = s2\\n\\t\\treturn signaltools._centered(ret, osize)\\n\\telif mode == \\\"valid\\\":\\n\\t\\treturn signaltools._centered(ret, abs(s2 - s1) + 1)\",\n \"def test_fft_spectrum_fieldtrip_01():\\n ft_psd_dpss_3 = [0.00513886191307729, 0.00541235129368216, 0.00637327754180630, 0.00975873992634912, 0.0114961627430138, 0.0121812348620110, 0.0114278017545212, 0.0113668316543143, 0.0112161528645388, 0.0117016241464867]\\n f0, Sxx0 = _fft(x, s_freq, detrend=None, taper='dpss', output='spectraldensity', sides='one', scaling='fieldtrip', halfbandwidth=3)\\n assert_array_almost_equal(Sxx0[100:110], ft_psd_dpss_3, decimal=4)\",\n \"def test_reciprocal_trig_functions(self):\\r\\n angles = ['-pi/4', 'pi/6', 'pi/5', '5*pi/4', '9*pi/4', '1 + j']\\r\\n sec_values = [1.414, 1.155, 1.236, -1.414, 1.414, 0.498 + 0.591j]\\r\\n csc_values = [-1.414, 2, 1.701, -1.414, 1.414, 0.622 - 0.304j]\\r\\n cot_values = [-1, 1.732, 1.376, 1, 1, 0.218 - 0.868j]\\r\\n\\r\\n self.assert_function_values('sec', angles, sec_values)\\r\\n self.assert_function_values('csc', angles, csc_values)\\r\\n self.assert_function_values('cot', angles, cot_values)\\r\\n\\r\\n arcsec_inputs = ['1.1547', '1.2361', '2', '-2', '-1.4142', '0.4983+0.5911*j']\\r\\n arcsec_angles = [0.524, 0.628, 1.047, 2.094, 2.356, 1 + 1j]\\r\\n self.assert_function_values('arcsec', arcsec_inputs, arcsec_angles)\\r\\n\\r\\n arccsc_inputs = ['-1.1547', '-1.4142', '2', '1.7013', '1.1547', '0.6215-0.3039*j']\\r\\n arccsc_angles = [-1.047, -0.785, 0.524, 0.628, 1.047, 1 + 1j]\\r\\n self.assert_function_values('arccsc', arccsc_inputs, arccsc_angles)\\r\\n\\r\\n # Has the same range as arccsc\\r\\n arccot_inputs = ['-0.5774', '-1', '1.7321', '1.3764', '0.5774', '(0.2176-0.868*j)']\\r\\n arccot_angles = arccsc_angles\\r\\n self.assert_function_values('arccot', arccot_inputs, arccot_angles)\",\n \"def fftconvolve(in1, in2, mode=\\\"full\\\", axis=None):\\r\\n s1 = np.array(in1.shape)\\r\\n s2 = np.array(in2.shape)\\r\\n complex_result = (np.issubdtype(in1.dtype, np.complex) or\\r\\n np.issubdtype(in2.dtype, np.complex))\\r\\n\\r\\n if axis is None:\\r\\n size = s1 + s2 - 1\\r\\n fslice = tuple([slice(0, int(sz)) for sz in size])\\r\\n else:\\r\\n equal_shapes = s1 == s2\\r\\n # allow equal_shapes[axis] to be False\\r\\n equal_shapes[axis] = True\\r\\n assert equal_shapes.all(), 'Shape mismatch on non-convolving axes'\\r\\n size = s1[axis] + s2[axis] - 1\\r\\n fslice = [slice(l) for l in s1]\\r\\n fslice[axis] = slice(0, int(size))\\r\\n fslice = tuple(fslice)\\r\\n\\r\\n # Always use 2**n-sized FFT\\r\\n fsize = 2 ** int(np.ceil(np.log2(size)))\\r\\n if axis is None:\\r\\n IN1 = fftpack.fftn(in1, fsize)\\r\\n IN1 *= fftpack.fftn(in2, fsize)\\r\\n ret = fftpack.ifftn(IN1)[fslice].copy()\\r\\n else:\\r\\n IN1 = fftpack.fft(in1, fsize, axis=axis)\\r\\n IN1 *= fftpack.fft(in2, fsize, axis=axis)\\r\\n ret = fftpack.ifft(IN1, axis=axis)[fslice].copy()\\r\\n del IN1\\r\\n if not complex_result:\\r\\n ret = ret.real\\r\\n if mode == \\\"full\\\":\\r\\n return ret\\r\\n elif mode == \\\"same\\\":\\r\\n if np.product(s1, axis=0) > np.product(s2, axis=0):\\r\\n osize = s1\\r\\n else:\\r\\n osize = s2\\r\\n return signaltools._centered(ret, osize)\\r\\n elif mode == \\\"valid\\\":\\r\\n return signaltools._centered(ret, abs(s2 - s1) + 1)\",\n \"def frfest(x, f, dt, windowname=\\\"hanning\\\", ave=bool(True), Hv=bool(False)):\\n if len(f.shape) == 1:\\n f = f.reshape(1, -1, 1)\\n\\n if len(x.shape) == 1:\\n x = x.reshape(1, -1, 1)\\n\\n if len(f.shape) == 2:\\n if (f.shape).index(max(f.shape)) == 0:\\n f = f.reshape(max(f.shape), min(f.shape), 1)\\n else:\\n f = f.reshape(1, max(f.shape), min(f.shape))\\n\\n if len(x.shape) == 2:\\n if (x.shape).index(max(x.shape)) == 0:\\n x = x.reshape(max(x.shape), min(x.shape), 1)\\n else:\\n x = x.reshape(1, max(x.shape), min(x.shape))\\n\\n # Note: Two different ways to ignore returned values shown\\n Pff = asd(f, dt, windowname=windowname)[1]\\n freq, Pxf = crsd(x, f, dt, windowname=windowname)\\n _, Pxx = asd(x, dt)\\n\\n # Note Pfx=conj(Pxf) is applied in the H1 FRF estimation\\n Txf1 = np.conj(Pxf / Pff)\\n Txf2 = Pxx / Pxf\\n # Nulled to avoid output problems/simplify calls if unrequested\\n Txfv = np.zeros_like(Txf1)\\n\\n coh = (Pxf * np.conj(Pxf)).real / Pxx / Pff\\n\\n if Hv:\\n for i in np.arange(Pxx.shape[1]):\\n frfm = np.array(\\n [[Pff[0, i], np.conj(Pxf[0, i])], [Pxf[0, i], Pxx[0, i]]])\\n\\n alpha = 1 # np.sqrt(Pff[0,i]/Pxx[0,i])\\n\\n frfm = np.array([[Pff[0, i], alpha * np.conj(Pxf[0, i])],\\n [alpha * Pxf[0, i], alpha**2 * Pxx[0, i]]])\\n\\n lam, vecs = la.eigh(frfm)\\n\\n index = lam.argsort()\\n\\n lam = lam[index]\\n\\n vecs = vecs[:, index]\\n\\n Txfv[0, i] = -(vecs[0, 0] / vecs[1, 0]) / alpha\\n\\n return freq, Txf1, Txf2, coh, Txfv\",\n \"def coherence_partial(time_series, r, csd_method=None):\\r\\n\\r\\n if csd_method is None:\\r\\n csd_method = {'this_method': 'welch'} # The default\\r\\n\\r\\n f, fxy = get_spectra(time_series, csd_method)\\r\\n\\r\\n # Initialize c according to the size of f:\\r\\n c = np.zeros((time_series.shape[0],\\r\\n time_series.shape[0],\\r\\n f.shape[0]), dtype=complex)\\r\\n\\r\\n for i in range(time_series.shape[0]):\\r\\n for j in range(i, time_series.shape[0]):\\r\\n f, fxx, frr, frx = get_spectra_bi(time_series[i], r, csd_method)\\r\\n f, fyy, frr, fry = get_spectra_bi(time_series[j], r, csd_method)\\r\\n c[i, j] = coherence_partial_spec(fxy[i][j], fxy[i][i],\\r\\n fxy[j][j], frx, fry, frr)\\r\\n\\r\\n idx = tril_indices(time_series.shape[0], -1)\\r\\n c[idx[0], idx[1], ...] = c[idx[1], idx[0], ...].conj() # Make it symmetric\\r\\n\\r\\n return f, c\",\n \"def fRCrim(Swe,Vc1,Vc2,Vc3,Vk,PHIe,Rc1,Rc2,Rc3,Rk,Rw,Rh,Cwv,Ckv,Alpha,Tout):\\n#\\n# 1. Compute and normalise volumetric components:\\n#\\t-----------------------------------------------\\n\\tVw=PHIe*Swe\\n\\tVh=PHIe*(1-Swe)\\n\\tVwe=(Vw-Cwv)/(1-Cwv)\\n\\tVwe=ImposeLimits(Vwe,0,1)\\n\\tVke=(Vk-Ckv)/(1-Ckv)\\n\\tVke=ImposeLimits(Vke,0,1)\\n\\tSum=abs(Vc1)+abs(Vc2)+abs(Vc3)+abs(Vke)+abs(Vwe)+abs(Vh)\\n\\tVc1=abs(Vc1)/Sum\\n\\tVc2=abs(Vc2)/Sum\\n\\tVc3=abs(Vc3)/Sum\\n\\tVk=abs(Vk)/Sum\\n\\tVw=abs(Vw)/Sum\\n\\tVh=abs(Vh)/Sum\\n#\\n#\\t2. Determine conductivity of components:\\n#\\t----------------------------------------\\n\\tSigc1=1/Rc1\\n\\tSigc2=1/Rc2\\n\\tSigc3=1/Rc3\\n\\tSigk=1/Rk\\n\\tSigw=1/Rw\\n\\tSigh=1/Rh\\n#\\n#\\t3. Compute Conductivity:\\n#\\t========================\\n\\tTrm1=Vc1*(Sigc1**(1/Alpha))\\n\\tTrm2=Vc2*(Sigc2**(1/Alpha))\\n\\tTrm3=Vc3*(Sigc3**(1/Alpha))\\n\\tTrm4=(Vk**2.2)*(Sigk**(1/Alpha)) # Factor of 2.2 included to get data to fit to Yang et al\\n\\tTrm5=Vw*(Sigw**(1/Alpha))\\n\\tTrm6=Vh*(Sigh**(1/Alpha))\\n\\tCrf=(Trm1+Trm2+Trm3+Trm4+Trm5+Trm6)**Alpha\\n#\\n#\\n# 4. Output result:\\n#\\t-----------------\\n\\tif(Tout==0):\\n\\t\\tFr=Crf\\n\\telse:\\n\\t\\tFr=1/Crf\\n\\treturn Fr\",\n \"def test_simple(self):\\n with self.subTest(\\\"from np array\\\"):\\n data = np.random.rand(10, 4)\\n mask = np.ones((10, 4))\\n channels = [\\\"a\\\", \\\"b\\\", \\\"c\\\", \\\"d\\\"]\\n fcs.FCSData((data, mask), channels=channels)\",\n \"def test_CorrelationDecoder_smoke(testdata_laird, tmp_path_factory):\\n testdata_laird = testdata_laird.copy()\\n features = testdata_laird.get_labels(ids=testdata_laird.ids[0])[:5]\\n\\n # Make an image to decode\\n meta = mkda.KDA(null_method=\\\"approximate\\\")\\n res = meta.fit(testdata_laird)\\n img = res.get_map(\\\"stat\\\")\\n\\n # Test: train decoder with Dataset object\\n decoder = continuous.CorrelationDecoder(features=features)\\n decoder.fit(testdata_laird)\\n decoded_df = decoder.transform(img)\\n\\n assert isinstance(decoded_df, pd.DataFrame)\\n\\n # Get features and images to compare with other methods\\n features = list(decoder.results_.maps.keys())\\n images = np.array(list(decoder.results_.maps.values()))\\n\\n # Save images to disk to test load_imgs method\\n tmpdir = tmp_path_factory.mktemp(\\\"test_CorrelationDecoder\\\")\\n decoder.results_.save_maps(tmpdir)\\n\\n # Test: load pregenerated maps using a dictionary of feature names and paths\\n img_dict = {feature: os.path.join(tmpdir, f\\\"{feature}.nii.gz\\\") for feature in features}\\n decoder2 = continuous.CorrelationDecoder()\\n decoder2.load_imgs(img_dict, mask=testdata_laird.masker)\\n decoded2_df = decoder2.transform(img)\\n\\n features2 = list(decoder2.results_.maps.keys())\\n images2 = np.array(list(decoder2.results_.maps.values()))\\n\\n assert isinstance(decoded2_df, pd.DataFrame)\\n assert np.array_equal(features, features2)\\n assert np.array_equal(images, images2)\\n assert decoded_df.equals(decoded2_df)\\n\\n # Test: load pregenerated maps from a directory\\n decoder3 = continuous.CorrelationDecoder()\\n decoder3.load_imgs(tmpdir.as_posix(), mask=testdata_laird.masker)\\n decoded3_df = decoder3.transform(img)\\n\\n features3 = list(decoder3.results_.maps.keys())\\n images3 = np.array(list(decoder3.results_.maps.values()))\\n\\n assert isinstance(decoded3_df, pd.DataFrame)\\n assert np.array_equal(features, features3)\\n assert np.array_equal(images, images3)\\n assert decoded_df.equals(decoded3_df)\\n\\n # Test: passing a dataset to load_imgs\\n decoder4 = continuous.CorrelationDecoder()\\n with pytest.raises(ValueError):\\n decoder4.load_imgs(testdata_laird, mask=testdata_laird.masker)\\n\\n # Test: try loading pregenerated maps without a masker\\n decoder5 = continuous.CorrelationDecoder()\\n with pytest.raises(ValueError):\\n decoder5.load_imgs(img_dict)\\n\\n # Test: try transforming an image without fitting the decoder\\n decoder6 = continuous.CorrelationDecoder()\\n with pytest.raises(AttributeError):\\n decoder6.transform(img)\",\n \"def process(self):\\n\\n # noise field generation\\n proto = self.__generate_protoarray(self._n_x, self._n_y, self._variance_expected, self._r_corr_in_points)\\n proto_shifted = fftshift(proto, axes=(0, 1))\\n proto_fft_obj = ifft2(proto_shifted)\\n proto_fft_normalized = self.__normalize_after_fft(proto_fft_obj())\\n self._noise_field = proto_fft_normalized\\n\\n # initialization of arrays for real and imaginary parts\\n self._noise_field_real, self._noise_field_imag = \\\\\\n self._initialize_noise_arrays(self._noise_field, self._n_x, self._n_y)\\n\\n # autocorrelation functions calculation\\n self._calculate_autocorrelations()\",\n \"def test_MFT_flux_conservation(centering='FFTSTYLE', outdir=None, outname='test_MFT_flux', precision=0.01):\\n\\n # Set up constants for either a more precise test or a less precise but much \\n # faster test:\\n print(\\\"Testing MFT flux conservation for centering = \\\"+centering)\\n if precision ==0.001:\\n npupil = 800\\n npix = 4096\\n u = 400 # of lam/D. Must be <= the Nyquist frequency of the pupil sampling or there\\n # will be aliased copies of the PSF.\\n elif precision==0.01: \\n npupil = 400\\n npix = 2048\\n u = 200 # of lam/D. Must be <= the Nyquist frequency of the pupil sampling or there\\n # will be aliased copies of the PSF.\\n else:\\n raise NotImplementedError('Invalid value for precision.')\\n\\n\\n\\n # Create pupil\\n ctr = (float(npupil)/2.0, float(npupil)/2.0 )\\n pupil = makedisk(s=(npupil, npupil), c=ctr, r=float(npupil)/2.0001, t=np.float64, grey=0)\\n pupil /= np.sqrt(pupil.sum())\\n if outdir is not None:\\n fits.PrimaryHDU(pupil.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"pupil.fits\\\", clobber=True)\\n\\n # MFT setup style and execute\\n mft = matrixDFT.MatrixFourierTransform(centering=centering, verbose=True)\\n a = mft.perform(pupil, u, npix)\\n\\n pre = (abs(pupil)**2).sum() # normalized area of input pupil, should be 1 by construction\\n post = (abs(a)**2).sum() # \\n ratio = post / pre\\n print \\\"Pre-FFT total: \\\"+str( pre)\\n print \\\"Post-FFT total: \\\"+str( post )\\n print \\\"Ratio: \\\"+str( ratio)\\n\\n\\n\\n if outdir is not None:\\n complexinfo(a, str=\\\"mft1 asf\\\")\\n asf = a.real.copy()\\n fits.PrimaryHDU(asf.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"asf.fits\\\", clobber=True)\\n cpsf = a * a.conjugate()\\n psf = cpsf.real.copy()\\n #SF.SimpleFitsWrite(fn=outdir+os.sep+outname+\\\"psf.fits\\\", data=psf.astype(np.float32), clobber='y')\\n fits.PrimaryHDU(psf.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"psf.fits\\\", clobber=True)\\n\\n assert np.abs(1.0 - ratio) < precision\",\n \"def inverseSTRF(specgram, rates=[1, 2, 4, 8, 16, 32], scales=[0.5, 1, 2, 4, 8], fl=8, tc=8, fac=-2, shift=0, full_T=0, full_X=0, BP=0, norm=.9, foutt=0, foutx=0):\\n # Retrieve parameters\\n K1 = len(rates)\\n K2 = len(scales)\\n N, M = lastN, lastM\\n N1 = int(2**np.ceil(np.log2(N)))\\n N2 = 2*N1\\n M1 = int(2**np.ceil(np.log2(M)))\\n M2 = 2*M1\\n STF\\t= 1000 / fl\\n SRF\\t= 24;\\n M4 = np.floor(float(M)/2*full_X);\\t# dM\\n N4 = np.floor(float(N)/2*full_T);\\t# dN\\n HH = 0;\\n Z_cum = 0;\\n for rdx in range(K1):\\n # rate filtering\\n fc_rt = rates[rdx]\\n HR = temporal_filter(fc_rt, N1, STF, [1+rdx+BP, K1+BP*2])\\n for sgn in (1, -1):\\n # rate filtering modification\\n if sgn > 0:\\n HR = np.conj(np.hstack((HR, np.zeros(N1))))\\n else:\\n HR = np.hstack( (HR[0], np.conj(HR[N2:0:-1])) )\\n HR[N1] = np.abs(HR[N1+1]) \\n for sdx in range(K2):\\n # scale filtering\\n fc_sc = scales[sdx]\\n HS = frequency_filter(fc_sc, M1, SRF, [1+sdx+BP, K2+BP*2])\\n z = np.squeeze(specgram[sdx, rdx+(sgn==1)*K1, :, :]).copy()\\n # 2-D FFT and cumulation\\n Z_cum, HH = corfftc(z, Z_cum, [N, N1, N2, N4], [M, M1, M2, M4], HR, HS, HH);\\n #qlsdkjcn\\n # normalization\\n HH[:, 0] = HH[:, 0] * 2\\n yh = cornorm(Z_cum, HH, [N, N1, N2, N4], [M, M1, M2, M4], norm, foutt, foutx);\\n return yh\",\n \"def test_solar_cc():\\n\\n features = ['clearsky_ratio', 'rsds', 'clearsky_ghi']\\n input_files = [os.path.join(TEST_DATA_DIR, 'rsds_test.nc')]\\n nsrdb_source_fp = os.path.join(TEST_DATA_DIR, 'test_nsrdb_co_2018.h5')\\n\\n with xr.open_mfdataset(input_files) as fh:\\n min_lat = np.min(fh.lat.values)\\n min_lon = np.min(fh.lon.values) - 360\\n target = (min_lat, min_lon)\\n shape = (len(fh.lat.values), len(fh.lon.values))\\n\\n with pytest.raises(AssertionError):\\n handler = DataHandlerNCforCC(input_files, features=features,\\n target=target, shape=shape,\\n val_split=0.0,\\n worker_kwargs=dict(max_workers=1))\\n\\n handler = DataHandlerNCforCC(input_files, features=features,\\n nsrdb_source_fp=nsrdb_source_fp,\\n target=target, shape=shape,\\n temporal_slice=slice(0, 1),\\n val_split=0.0,\\n worker_kwargs=dict(max_workers=1))\\n\\n cs_ratio = handler.data[..., 0]\\n ghi = handler.data[..., 1]\\n cs_ghi = handler.data[..., 2]\\n cs_ratio_truth = ghi / cs_ghi\\n\\n assert cs_ratio.max() < 1\\n assert cs_ratio.min() > 0\\n assert (ghi < cs_ghi).all()\\n assert np.allclose(cs_ratio, cs_ratio_truth)\\n\\n with Resource(nsrdb_source_fp) as res:\\n meta = res.meta\\n tree = KDTree(meta[['latitude', 'longitude']])\\n cs_ghi_true = res['clearsky_ghi']\\n\\n # check a few sites against NSRDB source file\\n for i in range(4):\\n for j in range(4):\\n test_coord = handler.lat_lon[i, j]\\n _, inn = tree.query(test_coord)\\n\\n assert np.allclose(cs_ghi_true[0:48, inn].mean(), cs_ghi[i, j])\",\n \"def test_matched_filter5():\\n x_size = 80\\n y_size = 90\\n\\n objects = numpy.zeros((1, 5))\\n\\n # Make filter with unit sum.\\n objects[0,:] = [x_size/2, y_size/2, 1.0, 1.0, 1.0]\\n psf = dg.drawGaussians((x_size, y_size), objects)\\n psf = psf/numpy.sum(psf)\\n flt = matchedFilterC.MatchedFilter(psf)\\n\\n # Make test image.\\n image = numpy.zeros((x_size, y_size))\\n image[int(x_size/2), int(y_size/2)] = float(100)\\n\\n mf_conv = flt.convolve(image)\\n\\n t1 = numpy.fft.fft2(recenterPSF.recenterPSF(psf))\\n t2 = numpy.fft.fft2(image)\\n np_conv = numpy.real(numpy.fft.ifft2(t1*t2))\\n\\n assert(numpy.allclose(mf_conv, np_conv))\\n\\n flt.cleanup()\",\n \"def test_fft_spectrum_fieldtrip_02():\\n ft_psd_hann = [0.00106465976843528, 0.00562957700710057, 0.00214937527201723, 0.000405599433993590, 0.00506141871942431, 0.00343922341551741, 0.00223373256323887, 0.00767611770955874, 0.0426550524445195, 0.0376986963169514]\\n f0, Sxx0 = _fft(x, s_freq, detrend=None, taper='hann', output='spectraldensity', sides='one', scaling='fieldtrip')\\n # less precise because different shape of hann window\\n assert_array_almost_equal(Sxx0[100:110], ft_psd_hann, decimal=3)\",\n \"def estimate_F(corrs):\\n N, _ = corrs.shape\\n corrs_temp = np.zeros([N,4])\\n corrs_temp[:,1] = corrs[:,0]\\n corrs_temp[:,0] = corrs[:,1]\\n corrs_temp[:,2] = corrs[:,3]\\n corrs_temp[:,3] = corrs[:,2]\\n corrs = corrs_temp\\n means = []\\n stds = []\\n for i in range(4):\\n mean = np.mean(corrs[:,i])\\n means.append(mean)\\n std = np.std(corrs[:,i])\\n stds.append(std)\\n corrs[:,i] -= mean\\n corrs[:,i] /= std\\n T1 = np.array([[1/stds[0], 0, -means[0]/stds[0]],[0,1/stds[1], -means[1]/stds[1]], [0,0,1]])\\n T2 = np.array([[1/stds[2], 0, -means[2]/stds[2]],[0,1/stds[3], -means[3]/stds[3]], [0,0,1]])\\n Y = []\\n for j in range(N):\\n Y.append(np.outer(np.hstack([corrs[j,2:],1]),np.hstack([corrs[j,:2],1])).flatten())\\n Y = np.array(Y)\\n\\n u, s, v = np.linalg.svd(Y, full_matrices = 0)\\n if s[-1] != 0:\\n F = v[-1]\\n else:\\n F = v[-2]\\n F = F.reshape([3,3])\\n u, s, v = np.linalg.svd(F, full_matrices = 0)\\n if len(s)==3:\\n s[-1] = 0\\n F = u @ np.diag(s) @ v\\n F = T2.T @ F @ T1\\n F = F/np.linalg.norm(F, ord = 'fro')\\n return F\",\n \"def get_crd_fc(self, axis, shaped=False):\\n return self._src_crds.get_fc(axis, shaped=shaped)\",\n \"def scoreCirc_PassiveFilter_2(circuit, gen, indi, makeRedundancyInMatrix):\\n #Calculate density and uniquiness (as in makeNetlist)\\n if makeRedundancyInMatrix == True:\\n FullBigCircuitMatrix = deepcopy(fullRedundancyBigCircuitMatrix(circuit.BigCircuitMatrix))\\n else:\\n FullBigCircuitMatrix = deepcopy(circuit.BigCircuitMatrix)\\n\\n rowsR,columnsR,columnsC,rowsC = sortedNonZeroIndices(FullBigCircuitMatrix)\\n\\n matrixDensity = float(len(rowsR))/float((BigMatrixSize*BigMatrixSize/2))\\t#(ones/(all/2))\\n matrixQuaziID = sum(rowsR)+sum(columnsR)-BigMatrixSize*(BigMatrixSize-1)\\n OcSc, IcNc, SelfConnElm = checkConnsConnected(FullBigCircuitMatrix) #Outer connections Short cut, Inner connections Not connected\\n #print \\\"Kratkih stikov zunanjih povezav:\\\", OcSc\\n \\n results = None\\n if OcSc > 1:\\n score = 1e4*np.exp(OcSc)\\n else:\\n makeNetlist(circuit, gen, indi, FullBigCircuitMatrix)\\n results = runme2.evaluatePassiveFilter_2(gen, indi)\\n \\n disfCount = 0\\n\\n gain = np.array(results['gain']['nominal'], dtype=float)\\n if np.isnan(gain):\\n disfCount = disfCount + 1\\n g = 0\\n else:\\n g = abs(gain - 0) if gain < 0 else 0\\n\\n ripple = np.array(results['ripple']['nominal'], dtype=float)\\n if np.isnan(ripple):\\n disfCount = disfCount + 1\\n r = 0 \\n else:\\n r = abs(ripple - 0.5) if ripple > 0.5 else 0\\n \\n damping = np.array(results['damping']['nominal'], dtype=float)\\n if np.isnan(damping):\\n disfCount = disfCount + 1\\n d = 0\\n else:\\n d = abs(40 - damping) if damping < 40 else 0\\n\\n slope = np.array(results['dumpingSlope']['nominal'], dtype=float)\\n if np.isnan(slope):\\n disfCount = disfCount + 1\\n slo = 0\\n else:\\n slo = 0 if slope>60 else 60-slope\\n \\n bandwidth = np.array(results['bw']['nominal'], dtype=float)\\n if np.isnan(bandwidth):\\n disfCount = disfCount + 1\\n bw = 0\\n else:\\n bw = abs(bandwidth-1000)/100\\n \\n #THD = np.array(results['THD']['nominal'], dtype=float)\\n #if np.isnan(THD):\\n # disfCount = disfCount + 1\\n # thd = 0\\n #else:\\n # thd = THD-1 if THD > 1 else 0\\n #print 10*r, g, d, slo, bw\\n score = 10*r + g + d + slo + bw\\n\\n if disfCount > 0:\\n score += np.exp(disfCount) * 1e3\\n\\n #score = score + (IcNc*IcNc+1)# + abs(BW-bw)*1e2 + abs(CUTOFF-cutoff)*1e2 #add small punishment if not all nodes connected and bw and cutoff are off\\n\\n #print \\\"\\\\t\\\\t\\\\t\\\\t\\\\tG_\\\" + str(gen) + \\\"_I_\\\" + str(indi) + \\\" SCORE:\\\", score\\n #cleanup current subcircuit\\n filename = \\\"g_\\\" + str(gen) + \\\"_i_\\\" + str(indi) + \\\"_subckt.cir\\\"\\n os.remove(filename)\\n return score, matrixDensity, matrixQuaziID, results\",\n \"def test_standard_mfcc():\\n run_framesync(MFCC)\",\n \"def mfcc(signal, sampling_rate, factor=0.095, frame_size=0.025, frame_overlap=0.015, NFFT=512, num_filt = 40):\\n pre_emphasized = pre_emphasize(signal)\\n frames = make_frames(pre_emphasized, rate)\\n\\n #FFT and Power Spectrum\\n #NFFT = 512\\n mag_frames = np.absolute(np.fft.rfft(frames, NFFT)) # Magnitude of the FFT\\n power_frames = ((1.0 / NFFT) * (np.power(mag_frames,2))) # Power Spectrum\\n\\n filter_banks = make_filter_banks(power_frames, rate, NFFT)\\n\\n #MFCC\\n num_ceps = 20\\n mfcc_40 = dct(filter_banks, type=2, axis=1, norm='ortho') \\n mfcc = mfcc_40 #[:, 1 : (num_ceps + 1)] # Keep 2-13\\n\\n #Mean Normalization\\n mfcc = mfcc - (np.mean(mfcc, axis=0) + 1e-6)\\n\\n mfcc_features = np.hstack((np.mean(mfcc.T, axis=1), np.std(mfcc.T, axis=1), skew(mfcc.T, axis = 1), \\n np.max(mfcc.T, axis = 1), np.median(mfcc.T, axis = 1), np.min(mfcc.T, axis = 1)))\\n \\n return mfcc_features\",\n \"def test_corr_transform_performance(meta_cres, corr, signal_masks, simulatedata_cbma):\\n _, (ground_truth_foci, _) = simulatedata_cbma\\n mask = meta_cres.masker.mask_img\\n ground_truth_foci_ijks = [tuple(mm2vox(focus, mask.affine)) for focus in ground_truth_foci]\\n sig_idx, nonsig_idx = [\\n meta_cres.masker.transform(img).astype(bool).squeeze() for img in signal_masks\\n ]\\n\\n p_array = meta_cres.maps.get(\\\"p\\\")\\n if p_array is None or corr.method == \\\"montecarlo\\\":\\n p_array = 10 ** -meta_cres.maps.get(\\\"logp_level-voxel_corr-FWE_method-montecarlo\\\")\\n\\n n_iters = corr.parameters.get(\\\"n_iters\\\")\\n\\n # ALE with MKDA kernel with montecarlo correction\\n # combination gives poor performance\\n if (\\n isinstance(meta_cres.estimator, ale.ALE)\\n and isinstance(meta_cres.estimator.kernel_transformer, kernel.MKDAKernel)\\n and meta_cres.estimator.get_params().get(\\\"null_method\\\") == \\\"approximate\\\"\\n and corr.method != \\\"montecarlo\\\"\\n ):\\n good_sensitivity = True\\n good_specificity = False\\n elif (\\n isinstance(meta_cres.estimator, ale.ALE)\\n and isinstance(meta_cres.estimator.kernel_transformer, kernel.MKDAKernel)\\n and \\\"montecarlo\\\" in meta_cres.estimator.get_params().get(\\\"null_method\\\")\\n ):\\n good_sensitivity = False\\n good_specificity = True\\n elif (\\n isinstance(meta_cres.estimator, ale.ALE)\\n and isinstance(meta_cres.estimator.kernel_transformer, kernel.MKDAKernel)\\n and meta_cres.estimator.get_params().get(\\\"null_method\\\") == \\\"approximate\\\"\\n and corr.method == \\\"montecarlo\\\"\\n ):\\n good_sensitivity = False\\n good_specificity = True\\n elif (\\n isinstance(meta_cres.estimator, ale.ALE)\\n and type(meta_cres.estimator.kernel_transformer) == kernel.KDAKernel\\n and (\\n \\\"montecarlo\\\" in meta_cres.estimator.get_params().get(\\\"null_method\\\")\\n or (\\n meta_cres.estimator.get_params().get(\\\"null_method\\\") == \\\"approximate\\\"\\n and corr.method == \\\"montecarlo\\\"\\n )\\n )\\n ):\\n good_sensitivity = False\\n good_specificity = True\\n elif (\\n isinstance(meta_cres.estimator, ale.ALE)\\n and type(meta_cres.estimator.kernel_transformer) == kernel.KDAKernel\\n and meta_cres.estimator.get_params().get(\\\"null_method\\\") == \\\"approximate\\\"\\n ):\\n good_sensitivity = True\\n good_specificity = False\\n elif (\\n isinstance(meta_cres.estimator, mkda.MKDADensity)\\n and isinstance(meta_cres.estimator.kernel_transformer, kernel.ALEKernel)\\n and meta_cres.estimator.get_params().get(\\\"null_method\\\") != \\\"reduced_montecarlo\\\"\\n and corr.method != \\\"montecarlo\\\"\\n ):\\n good_sensitivity = False\\n good_specificity = True\\n else:\\n good_sensitivity = True\\n good_specificity = True\\n\\n _check_p_values(\\n p_array,\\n meta_cres.masker,\\n sig_idx,\\n nonsig_idx,\\n ALPHA,\\n ground_truth_foci_ijks,\\n n_iters=n_iters,\\n good_sensitivity=good_sensitivity,\\n good_specificity=good_specificity,\\n )\",\n \"def is_rfft(obj):\\n if not (hasattr(obj, 'nx') and hasattr(obj, 'dx') and hasattr(obj, 'ny')\\n and hasattr(obj, 'dy') and hasattr(obj, 'fft')):\\n return False\\n\\n return obj.fft.shape == (obj.nx, obj.ny / 2 + 1)\",\n \"def test_fft_complex_1d():\\n\\ta = np.exp(2j * np.pi * np.arange(8) / 8)\\n\\tdummy_array = xr.DataArray(a, dims=['x'])\\n\\tchunked_array = dummy_array.chunk(chunks={'x': 2})\\n\\tspectrum_array, spectrum_coords, spectrum_dims = \\\\\\n\\t\\txfft._fft(chunked_array, nfft={'x': 16}, dim=['x'], dx={'x': 0.5})\\n\\tassert np.array_equal(spectrum_array.compute(), np.fft.fft(a, n=16))\\n\\tassert np.array_equal(spectrum_coords['f_x'], np.fft.fftfreq(16, d=0.5))\\n\\tassert 'f_x' in spectrum_dims\",\n \"def test_width_z_to_f_f(mf, ncf, t3f, qf):\\n pre = EL / (SW * CW)\\n gl = pre * (t3f - qf * SW**2)\\n gr = -pre * qf * SW**2\\n\\n def msqrd_z_to_f_f(_):\\n return (\\n ncf\\n * 2\\n / 3\\n * (6 * gl * gr * mf**2 + (gl**2 + gr**2) * (-(mf**2) + MZ**2))\\n )\\n\\n mr2 = (mf / MZ) ** 2\\n af = t3f - qf * SW**2\\n bf = -qf * SW**2\\n\\n analytic = (\\n ncf\\n * EL**2\\n * MZ\\n / (24 * np.pi * CW**2 * SW**2)\\n * np.sqrt(1 - 4 * mr2)\\n * ((af**2 + bf**2) * (1 - mr2) + 6 * af * bf * mr2)\\n )\\n\\n phase_space = Rambo(MZ, [mf, mf], msqrd=msqrd_z_to_f_f)\\n width = phase_space.decay_width(10_000, seed=SEED)[0]\\n\\n assert width == pytest.approx(analytic)\",\n \"def NIR_flatfield_corr(tif): \\n _,_,_,flat_file_N,_=return_flatfield_set_path(2)\\n \\n print(tif)\\n \\n N=gdal_array.LoadFile(tif)\\n \\n file_path=os.path.dirname(os.path.abspath(tif))+\\\"/corr/\\\"+os.path.basename(tif)[:-4]+\\\"_corr.tif\\\"\\n \\n N=BLUE_simple_flatfield_corr(gdal_array.LoadFile(flat_file_N), N)\\n \\n options = ['PROFILE=GeoTIFF']\\n driver=osgeo.gdal.GetDriverByName(\\\"GTiff\\\")\\n basename=os.path.basename(tif)\\n basename=basename[:3]+\\\"N\\\"+basename[4:]\\n \\n file_path=os.path.dirname(os.path.abspath(tif))+\\\"/corr/\\\"+basename[:-4]+\\\"_corr.tif\\\"\\n dataset=driver.Create(file_path, N.shape[1],N.shape[0], 1, osgeo.gdal.GDT_UInt16, options) \\n dataset.GetRasterBand(1).WriteArray(N)\\n dataset.FlushCache()\\n dataset = None\",\n \"def simple_flatfield_corr(flat, real, Mfaktor, Pfaktor):\\n real=real.astype(np.float64)\\n flat=flat.astype(np.float64)\\n # init_max=np.max(real)/4095\\n print(np.max(real))\\n flat=NormalizeData(flat)\\n flat=flat*Mfaktor \\n m=np.average(flat)\\n gain=m/(flat+Pfaktor) \\n C=np.multiply(gain, real) \\n print(np.max(C))\\n return C\",\n \"def automorphism_group_FF_alg2(rational_function):\\n # define ground field and ambient function field\\n if rational_function.parent().is_field():\\n K = rational_function.parent()\\n R = K.ring()\\n else:\\n R = rational_function.parent()\\n K = R.fraction_field()\\n\\n F = R.base_ring()\\n if not F.is_finite() or not F.is_field():\\n raise TypeError(\\\"coefficient ring is not a finite field\\\")\\n p = F.characteristic()\\n z = R.gen(0)\\n phi = K(rational_function)\\n f = phi.numerator()\\n g = phi.denominator()\\n D = max(f.degree(), g.degree())\\n\\n # Build an invariant set for phi\\n fix = f(z) - z*g(z)\\n factor_list = fix.factor()\\n minimal_fix_poly = R(prod(x[0] for x in factor_list))\\n n = sum(x[0].degree() for x in factor_list) + bool(fix.degree() < D+1)\\n\\n if n >= 3:\\n T_poly = minimal_fix_poly\\n infinity_check = bool(fix.degree() < D+1)\\n elif n == 2:\\n # Infinity is a fixed point\\n if bool(fix.degree() < D+1):\\n y = fix.roots(multiplicities=False)[0]\\n preimage = g*(f(z) - y*g(z))\\n infinity_check = 1\\n # Infinity is not a fixed point\\n else:\\n C = minimal_fix_poly.coefficients(sparse=False)\\n preimage = C[2]*f(z)**2 + C[1]*f(z)*g(z) + C[0]*g(z)**2\\n infinity_check = bool(preimage.degree() < 2*D)\\n\\n T_poly = R(prod(x[0] for x in preimage.factor()))\\n\\n else: #case n=1\\n # Infinity is the fixed point\\n if bool(fix.degree() < D+1):\\n minimal_preimage = R(prod(x[0] for x in g.factor()))\\n if minimal_preimage.degree() + 1 >= 3:\\n T_poly = minimal_preimage\\n infinity_check = 1\\n else:\\n T_poly = R(prod(x[0] for x in phi(phi(z)).denominator().factor() ) )\\n infinity_check = 1\\n\\n # Infinity is not a fixed point\\n else:\\n y = fix.roots(multiplicities=False)[0]\\n preimage = R(f(z) - y*g(z))\\n minimal_preimage = R(prod(x[0] for x in preimage.factor()))\\n if minimal_preimage.degree() + bool(preimage.degree()<D) >= 3:\\n T_poly = minimal_preimage\\n infinity_check = bool(preimage.degree()<D)\\n else:\\n preimage2 = R(phi(phi(z)).numerator() - y*phi(phi(z)).denominator())\\n T_poly = R(prod(x[0] for x in preimage2.factor() ) )\\n infinity_check = infinity_check = bool(preimage2.degree() < D**2)\\n\\n # Define a field of definition for the absolute automorphism group\\n r = lcm([x[0].degree() for x in T_poly.factor()])*F.degree()\\n E = GF(p**r,'b')\\n b = E.gen(0)\\n sigma = F.Hom(E)[0]\\n S = PolynomialRing(E,'w')\\n w = S.gen(0)\\n E_poly = rational_function_coerce(T_poly, sigma, S)\\n\\n T = [ [alpha, E(1)] for alpha in E_poly.roots(ring=E, multiplicities=False)]\\n if infinity_check == 1:\\n T.append([E(1),E(0)])\\n\\n # Coerce phi into the larger ring and call Algorithm 1\\n Phi = rational_function_coerce(phi, sigma, S)\\n return [S, three_stable_points(Phi, T)]\",\n \"def test_DFT_rect(centering='FFTRECT', outdir=None, outname='DFT1R_', npix=None, sampling=10., nlamd=None):\\n\\n print \\\"Testing DFT, style = \\\"+centering\\n\\n\\n npupil = 156\\n pctr = int(npupil/2)\\n s = (npupil,npupil)\\n\\n\\n # make things rectangular:\\n if nlamd is None and npix is None:\\n nlamd = (10,20)\\n npix = [val*sampling for val in nlamd] #(100, 200) \\n elif npix is None:\\n npix = [val*sampling for val in nlamd] #(100, 200) \\n elif nlamd is None:\\n nlamd = [val/sampling for val in npix]\\n u = nlamd\\n print u\\n #(u, float(u)/npix[0]*npix[1])\\n #npix = (npix, 2*npix)\\n\\n\\n # FFT style\\n mft1 = matrixDFT.MatrixFourierTransform(centering=centering)\\n\\n #ctr = (float(npupil)/2.0 + mft1.offset(), float(npupil)/2.0 + mft1.offset())\\n ctr = (float(npupil)/2.0 , float(npupil)/2.0)\\n #print ctr\\n pupil = makedisk(s=s, c=ctr, r=float(npupil)/2.0001, t=np.float64, grey=0)\\n\\n pupil[0:60, 0:60] = 0\\n pupil[0:10] = 0\\n\\n pupil /= np.sqrt(pupil.sum())\\n\\n plt.clf()\\n plt.subplots_adjust(left=0.02, right=0.98)\\n plt.subplot(141)\\n\\n pmx = pupil.max()\\n plt.imshow(pupil, vmin=0, vmax=pmx*1.5)\\n\\n\\n if outdir is not None:\\n fits.PrimaryHDU(pupil.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"pupil.fits\\\", clobber=True)\\n\\n a = mft1.perform(pupil, u, npix)\\n\\n pre = (abs(pupil)**2).sum() \\n post = (abs(a)**2).sum() \\n ratio = post / pre\\n calcr = 1./(1.0*u[0]*u[1] *npix[0]*npix[1]) # multiply post by this to make them equal\\n print \\\"Pre-FFT total: \\\"+str( pre)\\n print \\\"Post-FFT total: \\\"+str( post )\\n print \\\"Ratio: \\\"+str( ratio)\\n #print \\\"Calc ratio : \\\"+str( calcr)\\n #print \\\"uncorrected: \\\"+str( ratio/calcr)\\n\\n\\n complexinfo(a, str=\\\",ft1 asf\\\")\\n asf = a.real.copy()\\n if outdir is not None:\\n fits.PrimaryHDU(asf.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"asf.fits\\\", clobber=True)\\n cpsf = a * a.conjugate()\\n psf = cpsf.real.copy()\\n if outdir is not None:\\n fits.PrimaryHDU(psf.astype(np.float32)).writeto(outdir+os.sep+outname+\\\"psf.fits\\\", clobber=True)\\n\\n ax=plt.subplot(142)\\n plt.imshow(asf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\\n ax.set_title='ASF'\\n\\n ax=plt.subplot(143)\\n plt.imshow(psf, norm=matplotlib.colors.LogNorm(1e-8, 1.0))\\n ax.set_title='PSF'\\n\\n plt.subplot(144)\\n\\n pupil2 = mft1.inverse(a, u, npupil)\\n pupil2r = (pupil2 * pupil2.conjugate()).real\\n plt.imshow( pupil2r, vmin=0,vmax=pmx*1.5*0.01) # FIXME flux normalization is not right?? I think this has to do with squaring the pupil here, that's all.\\n plt.gca().set_title='back to pupil'\\n plt.draw()\\n print \\\"Post-inverse FFT total: \\\"+str( abs(pupil2r).sum() )\\n print \\\"Post-inverse pupil max: \\\"+str(pupil2r.max())\\n\\n plt.suptitle('Matrix DFT with rectangular arrays using centering={0}'.format(centering))\\n\\n plt.savefig('test_DFT_rectangular_results_{0}.pdf'.format(centering))\",\n \"def cross_correlation(f, g):\\n\\n out = None\\n k = np.flip(np.flip(g, 0), 1)\\n out = conv_fast(f, k)\\n\\n return out\",\n \"def test_fft_spectrum_02():\\n f, t, Sxx = _spectral_helper(x, x, fs=s_freq,\\n window='hann',\\n nperseg=x.shape[0],\\n noverlap=0,\\n nfft=None,\\n return_onesided=True,\\n mode='psd',\\n scaling='spectrum')\\n\\n f0, Sxx0 = _fft(x, s_freq, detrend=None, taper='hann', scaling='energy', sides='one')\\n\\n assert_array_equal(f0, f)\\n assert_array_almost_equal(Sxx0, Sxx[:, 0] * CORRECTION_FACTOR)\",\n \"def pairCorrelationR(frametracks, dr=0.5, cutoff=50, subset=None, fast=False,\\n nnmaxcount=None):\\n ftr = frametracks\\n ndens = numberDensity(ftr)\\n hist_bin_edges = np.arange(0, cutoff + dr/2.0, dr, dtype=float)\\n histaccum = np.zeros((len(hist_bin_edges) - 1), dtype=int)\\n if nnmaxcount is None:\\n # Set 'maxcount' to a safe value\\n maxcount = np.pi * cutoff**2 * ndens * 10\\n else:\\n maxcount = nnmaxcount\\n NNE = NNEngine(ftr, cutoff, maxcount, fast=fast, subset=subset)\\n for xy, dists in NNE.iter_dist():\\n try:\\n hist = _fast_hist(dists, hist_bin_edges)\\n except ValueError: # zero neighbors\\n continue\\n histaccum += hist\\n histareas = np.diff(np.pi * hist_bin_edges**2)\\n return histaccum / float(NNE.loopcount()) / (histareas * ndens), hist_bin_edges\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.638313","0.630608","0.6283942","0.62651575","0.62496763","0.6248945","0.6202985","0.6131658","0.6022188","0.5948053","0.58898234","0.5878836","0.585236","0.584517","0.5792167","0.57854164","0.5775085","0.57525617","0.57479095","0.57201385","0.5718814","0.57139385","0.56727904","0.5659346","0.5657125","0.5651425","0.5646454","0.56170815","0.55940956","0.5574021","0.5569541","0.55690646","0.5560479","0.55584216","0.5536202","0.5524352","0.55235636","0.5522647","0.5518928","0.5515114","0.5504018","0.54862523","0.548356","0.5481864","0.5478458","0.54563713","0.54460096","0.5441196","0.5431409","0.54271597","0.5425819","0.5414444","0.5413996","0.5413969","0.5411935","0.54118526","0.5404983","0.5396344","0.5395585","0.5388413","0.53628254","0.5334124","0.53326523","0.5327995","0.5326847","0.53116447","0.5306066","0.53052276","0.52978903","0.5292533","0.52903295","0.52898484","0.5284515","0.52706635","0.52673054","0.5259263","0.52581215","0.52579105","0.52395064","0.52385634","0.5237206","0.5235838","0.52322555","0.5231041","0.52292895","0.5223329","0.52075964","0.5192","0.5187939","0.51842403","0.51829326","0.5181422","0.51687634","0.5154651","0.51538306","0.5152912","0.51523906","0.5149504","0.5148732","0.51460683"],"string":"[\n \"0.638313\",\n \"0.630608\",\n \"0.6283942\",\n \"0.62651575\",\n \"0.62496763\",\n \"0.6248945\",\n \"0.6202985\",\n \"0.6131658\",\n \"0.6022188\",\n \"0.5948053\",\n \"0.58898234\",\n \"0.5878836\",\n \"0.585236\",\n \"0.584517\",\n \"0.5792167\",\n \"0.57854164\",\n \"0.5775085\",\n \"0.57525617\",\n \"0.57479095\",\n \"0.57201385\",\n \"0.5718814\",\n \"0.57139385\",\n \"0.56727904\",\n \"0.5659346\",\n \"0.5657125\",\n \"0.5651425\",\n \"0.5646454\",\n \"0.56170815\",\n \"0.55940956\",\n \"0.5574021\",\n \"0.5569541\",\n \"0.55690646\",\n \"0.5560479\",\n \"0.55584216\",\n \"0.5536202\",\n \"0.5524352\",\n \"0.55235636\",\n \"0.5522647\",\n \"0.5518928\",\n \"0.5515114\",\n \"0.5504018\",\n \"0.54862523\",\n \"0.548356\",\n \"0.5481864\",\n \"0.5478458\",\n \"0.54563713\",\n \"0.54460096\",\n \"0.5441196\",\n \"0.5431409\",\n \"0.54271597\",\n \"0.5425819\",\n \"0.5414444\",\n \"0.5413996\",\n \"0.5413969\",\n \"0.5411935\",\n \"0.54118526\",\n \"0.5404983\",\n \"0.5396344\",\n \"0.5395585\",\n \"0.5388413\",\n \"0.53628254\",\n \"0.5334124\",\n \"0.53326523\",\n \"0.5327995\",\n \"0.5326847\",\n \"0.53116447\",\n \"0.5306066\",\n \"0.53052276\",\n \"0.52978903\",\n \"0.5292533\",\n \"0.52903295\",\n \"0.52898484\",\n \"0.5284515\",\n \"0.52706635\",\n \"0.52673054\",\n \"0.5259263\",\n \"0.52581215\",\n \"0.52579105\",\n \"0.52395064\",\n \"0.52385634\",\n \"0.5237206\",\n \"0.5235838\",\n \"0.52322555\",\n \"0.5231041\",\n \"0.52292895\",\n \"0.5223329\",\n \"0.52075964\",\n \"0.5192\",\n \"0.5187939\",\n \"0.51842403\",\n \"0.51829326\",\n \"0.5181422\",\n \"0.51687634\",\n \"0.5154651\",\n \"0.51538306\",\n \"0.5152912\",\n \"0.51523906\",\n \"0.5149504\",\n \"0.5148732\",\n \"0.51460683\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6200045"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":86097,"cells":{"query":{"kind":"string","value":"port with all pins inverted"},"document":{"kind":"string","value":"def inverted( self ):\n return self._modifier(\n self,\n lambda x: invert_bits( x, self.nr_of_pins )\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, pin_obj: Pin, invert: bool = False):","def invert_port(self, port, polarity):\n\n if port == 1:\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLB, polarity)\n self.__port_b_polarity = polarity\n else:\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLA, polarity)\n self.__port_a_polarity = polarity\n return","def invert_pin(self, pin, polarity):\n\n pin = pin - 1\n if pin < 8:\n self.__port_a_polarity = self.__helper.updatebyte(\n self.__port_a_polarity,\n pin,\n polarity)\n self.__bus.write_byte_data(\n self.__ioaddress, self.IPOLA, self.__port_a_polarity)\n else:\n self.__port_b_polarity = self.__helper.updatebyte(\n self.__port_b_polarity,\n pin - 8,\n polarity)\n self.__bus.write_byte_data(\n self.__ioaddress, self.IPOLB, self.__port_b_polarity)\n return","def invert_com_scan_direction(do_invert):\n if do_invert:\n send_command(0xC8)\n else:\n send_command(0xC0)","def set_output_pins(gpio_pi, pins):\n for pin in pins:\n gpio_pi.set_mode(pin, pigpio.OUTPUT)","def turn_off(self):\n self.set_pin(0, -1)\n self.set_pin(1, -1)\n self.set_pin(2, -1)","def as_pin_out( self ):\n return _pin_out_from_port_out( self.as_port_out() )","def initialize_light_pins(pi, pins):\n for pin in pins:\n pi.set_mode(pin, pigpio.OUTPUT)\n pi.set_pull_up_down(pin, pigpio.PUD_DOWN)","def update_voutput_pins(self):\n if not pfio:\n raise Exception(\n \"Looks like some sloppy programmer (probably Tom Preston...) \" \\\n \"is trying to update the virtual output pins when the PiFace \" \\\n \"isn't connected. Make sure you check for the pfio before calling \" \\\n \"the update_voutput_pins method. kthxbai.\")\n\n output_bit_map = pfio.read_output()\n for i in range(len(self.output_pins)):\n # updating inner value so that we don't do more SPI reads\n self.output_pins[i]._value = (output_bit_map >> i) & 1 \n\n self.queue_draw()","def out_aux_port(self, port):\n return self.auxout[port - 1]","def port_revert(switch, port):\n print client.port.port_revert(switch, port)","def _set_unconnected_ports(self):\n for name, ip in self._ips.items():\n count = 0\n inst_args = getattr(self, name)\n ports = ip.get_ports()\n for port in ports:\n full_name = (port_direction_to_prefix(port.direction)\n + port.name)\n if full_name not in inst_args.keys():\n sig = Signal(len(port), name=full_name)\n inst_args[full_name] = sig\n count += 1","def __invert__(self):\n return BitBoard(~self.num)","def init():\n print(\"initializing...\")\n print(\"setting relays off\")\n for pin in PINS:\n GPIO.setup(pin, GPIO.OUT)\n GPIO.output(pin, RELAYOFF)","def __init__(self, pinForward, pinBackward, pinControlStraight,pinLeft, pinRight, pinControlSteering):\n\n self.pinForward = pinForward\n self.pinBackward = pinBackward\n self.pinControlStraight = pinControlStraight\n self.pinLeft = pinLeft\n self.pinRight = pinRight\n self.pinControlSteering = pinControlSteering\n GPIO.setup(self.pinForward, GPIO.OUT)\n GPIO.setup(self.pinBackward, GPIO.OUT)\n GPIO.setup(self.pinControlStraight, GPIO.OUT)\n\n GPIO.setup(self.pinLeft, GPIO.OUT)\n GPIO.setup(self.pinRight, GPIO.OUT)\n GPIO.setup(self.pinControlSteering, GPIO.OUT)\n\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\n self.pwm_forward.start(0)\n self.pwm_backward.start(0)\n\n self.pwm_left = GPIO.PWM(self.pinLeft, 100)\n self.pwm_right = GPIO.PWM(self.pinRight, 100)\n self.pwm_left.start(0)\n self.pwm_right.start(0)\n\n GPIO.output(self.pinControlStraight,GPIO.HIGH) \n GPIO.output(self.pinControlSteering,GPIO.HIGH)","def drive_leds():\n pins.D4.next = rotator[3] == 1\n pins.D3.next = rotator[2] == 1\n pins.D2.next = rotator[1] == 1\n pins.D1.next = rotator[0] == 1","def initialize():\n for pin in sorted(OUTPUT_PINS.values()):\n _enable_pin(pin, OUT)\n\n for pin in sorted(INPUT_PINS.values()):\n _enable_pin(pin, IN)","def port_nic():","def set_in_pins(pins):\n for pin in pins:\n GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN)\n\tGPIO.setup(LEDPIN, GPIO.OUT)\n\tGPIO.output(LEDPIN, GPIO.LOW)","def message_ports_out(self):\n return _spacegrant_swig.invert_bit_sptr_message_ports_out(self)","def __init__(self, pinForward1, pinBackward1,pinForward2, pinBackward2):\n\n self.pinForward1 = pinForward1\n self.pinBackward1 = pinBackward1\n self.pinForward2 = pinForward2\n self.pinBackward2 = pinBackward2\n\n GPIO.setup(self.pinForward1, GPIO.OUT)\n GPIO.setup(self.pinBackward1, GPIO.OUT)\n GPIO.setup(self.pinForward2, GPIO.OUT)\n GPIO.setup(self.pinBackward2, GPIO.OUT)\n\n self.pwm_forward1 = GPIO.PWM(self.pinForward1, 100)\n self.pwm_backward1 = GPIO.PWM(self.pinBackward1, 100)\n self.pwm_forward2 = GPIO.PWM(self.pinForward2, 100)\n self.pwm_backward2 = GPIO.PWM(self.pinBackward2, 100)\n \n self.pwm_forward1.start(0)\n self.pwm_backward1.start(0)\n self.pwm_forward2.start(0)\n self.pwm_backward2.start(0)","def pin_toggle(self, pin):\n port_num = self._convert_pin_port(pin)\n if port_num:\n port_state = gpio.HIGH\n if gpio.input(port_num) == gpio.HIGH:\n port_state = gpio.LOW\n gpio.setcfg(port_num, gpio.OUTPUT)\n gpio.output(port_num, port_state)","def message_ports_in(self):\n return _spacegrant_swig.invert_bit_sptr_message_ports_in(self)","def __init__(self):\n GPIO.setmode(GPIO.BOARD)\n for light in self.all:\n GPIO.setup(light, GPIO.OUT)","def pins(self, toggle=None, low=None, high=None):\n\n if toggle != None:\n val = 0\n for pin in toggle.split(\",\"):\n if not pin in PINS_OUT:\n raise ValueError(\"Invalid output pin '{:}'\".format(pin))\n\n val |= PINS_OUT[pin]\n\n self.write_block(REG_PINS, [val])\n\n if low != None:\n res = self.read_block(REG_PINS, 1)\n val = 0\n for pin in low.split(\",\"):\n if not pin in PINS_OUT:\n raise ValueError(\"Invalid output pin '{:}'\".format(pin))\n\n # Only toggle if already high\n if res[0] & PINS_OUT[pin] > 0:\n val |= PINS_OUT[pin]\n\n if val > 0:\n self.write_block(REG_PINS, [val])\n\n if high != None:\n res = self.read_block(REG_PINS, 1)\n val = 0\n for pin in high.split(\",\"):\n if not pin in PINS_OUT:\n raise ValueError(\"Invalid output pin '{:}'\".format(pin))\n\n # Only toggle if already low\n if res[0] & PINS_OUT[pin] == 0:\n val |= PINS_OUT[pin]\n\n if val > 0:\n self.write_block(REG_PINS, [val])\n\n res = self.read_block(REG_PINS, 1)\n ret = {\n \"input\": {k: bool(res[0] & v) for k, v in PINS_IN.iteritems()},\n \"output\": {k: bool(res[0] & v) for k, v in PINS_OUT.iteritems()}\n }\n\n return ret","def invert(self):\n return Rubik2DBoard(\n rows=self.rows, cols=self.cols,\n data=tuple([tuple([0 if cell == 1 else 1 for cell in row]) for row in self.faces]),\n prior_moves=self.moves)","def __init__(self, pinForward, pinBackward, pinControl):\n\n self.pinForward = pinForward\n self.pinBackward = pinBackward\n self.pinControl = pinControl\n GPIO.setup(self.pinForward, GPIO.OUT)\n GPIO.setup(self.pinBackward, GPIO.OUT)\n GPIO.setup(self.pinControl, GPIO.OUT)\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\n self.pwm_forward.start(0)\n self.pwm_backward.start(0)\n GPIO.output(self.pinControl,GPIO.HIGH)","def __init__(self, red_pin, green_pin, blue_pin):\n #self.red = gpiozero.PWMLED(red_pin, frequency=80, initial_value=1)\n #self.green = gpiozero.PWMLED(green_pin, frequency=80, initial_value=1)\n #self.blue = gpiozero.PWMLED(blue_pin, frequency=80, initial_value=1)\n self.red = gpiozero.LED(red_pin)\n self.green = gpiozero.LED(green_pin)\n self.blue = gpiozero.LED(blue_pin)\n self.leds = [self.red, self.green, self.blue]\n self.off()","def write(self):\n mask = 0\n for pin in self.pins:\n if pin.mode == OUTPUT:\n if pin.value == 1:\n pin_nr = pin.pin_number - self.port_number * 8\n mask |= 1 << pin_nr\n msg = chr(DIGITAL_MESSAGE + self.port_number)\n msg += chr(mask % 128)\n msg += chr(mask >> 7)\n self.board.sp.write(msg)","def motorDirection(self, motorPin, direction):\n # print \"motorPin: \", motorPin\n # print \"direction: \", direction\n GPIO.output(motorPin, direction)","def init_switches(inds):\n for i in inds:\n GPIO.setup(i, GPIO.OUT, initial=0)","def toggleEdgeMode(self, PWMpin):\n mask = 1 << PWMpin\n self._injectFault(\"PWM1PCR\", self.PCR, mask)","def write( self, value ) -> None:\n if value:\n self._slave.write( invert_bits( 0, self._slave.nr_of_pins ) )\n else:\n self._slave.write( 0 )","def pin_off(self, pin):\n port_num = self._convert_pin_port(pin)\n if port_num:\n gpio.setcfg(port_num, gpio.OUTPUT)\n gpio.output(port_num, gpio.LOW)","def set_pattern(self, pattern):\n for ir, row in enumerate(pattern):\n for ic, col in enumerate(row):\n relay_n = ir*len(row) + ic\n self.relay.set(relay_n, bool(col))","def __init__(__self__, *,\n from_port: pulumi.Input[int],\n to_port: pulumi.Input[int]):\n pulumi.set(__self__, \"from_port\", from_port)\n pulumi.set(__self__, \"to_port\", to_port)","def inverted_board(self):\r\n invert_board = []\r\n for line_index in range(len(self.board) - 1, -1,\r\n -1): # For each number\r\n # (descending) from the max index line\r\n # of the matrix (len-1) to 0 (included)\r\n\r\n invert_board.append(self.board[line_index]) #\r\n return invert_board","def set_pin_direction(self, pin, direction):\n pin = pin - 1\n if pin < 8:\n self.__port_a_direction = self.__helper.updatebyte(\n self.__port_a_direction, pin, direction)\n self.__bus.write_byte_data(\n self.__ioaddress, self.IODIRA, self.__port_a_direction)\n else:\n self.__port_b_direction = self.__helper.updatebyte(\n self.__port_b_direction, pin - 8, direction)\n self.__bus.write_byte_data(\n self.__ioaddress, self.IODIRB, self.__port_b_direction)\n return","def reverse_axis(self, x: bool, y: bool, z: bool) -> None:\n current_directions = self.i2c.read(self.Register.AXIS_MAP_SIGN, 1)[0]\n if x:\n current_directions |= (1 << 2)\n else:\n current_directions &= ~(1 << 2)\n if y:\n current_directions |= (1 << 1)\n else:\n current_directions &= ~(1 << 1)\n if z:\n current_directions |= (1 << 0)\n else:\n current_directions &= ~(1 << 0)\n self.i2c.write(self.Register.AXIS_MAP_SIGN, current_directions)","def setup_gpio(self):\n for row in self._rows:\n GPIO.setup(row, GPIO.IN, pull_up_down=GPIO.PUD_UP)\n for coll in self._colls:\n GPIO.setup(coll, GPIO.OUT)\n GPIO.output(coll, 1)","def __init__(self):\n GPIO.setmode(GPIO.BCM)\n GPIO.setup(pin,GPIO.OUT)","def ext_pins(self, toggle=None, low=None, high=None):\n\n if toggle != None:\n val = 0\n for pin in toggle.split(\",\"):\n if not pin in EXT_PINS_OUT:\n raise ValueError(\"Invalid output extension pin '{:}'\".format(pin))\n\n val |= EXT_PINS_OUT[pin]\n\n self.write_block(REG_EXT_PINS, [val])\n\n if low != None:\n res = self.read_block(REG_EXT_PINS, 1)\n val = 0\n for pin in low.split(\",\"):\n if not pin in EXT_PINS_OUT:\n raise ValueError(\"Invalid output extension pin '{:}'\".format(pin))\n\n # Only toggle if already high\n if res[0] & EXT_PINS_OUT[pin] > 0:\n val |= EXT_PINS_OUT[pin]\n\n if val > 0:\n self.write_block(REG_EXT_PINS, [val])\n\n if high != None:\n res = self.read_block(REG_EXT_PINS, 1)\n val = 0\n for pin in high.split(\",\"):\n if not pin in EXT_PINS_OUT:\n raise ValueError(\"Invalid output extension pin '{:}'\".format(pin))\n\n # Only toggle if already low\n if res[0] & EXT_PINS_OUT[pin] == 0:\n val |= EXT_PINS_OUT[pin]\n\n if val > 0:\n self.write_block(REG_EXT_PINS, [val])\n\n res = self.read_block(REG_EXT_PINS, 1)\n ret = {\n \"input\": {k: bool(res[0] & v) for k, v in EXT_PINS_IN.iteritems()},\n \"output\": {k: bool(res[0] & v) for k, v in EXT_PINS_OUT.iteritems()}\n }\n\n return ret","def initialize_relays(self):\n #create list of bytes to clear out relays\n zeroed_bytes = []\n for i in range(self.num_registers):\n zeroed_bytes.append(0x00)\n\n #clear out any data in the shift registers\n ret = self.e.write_SPI_bytes_to_portA(zeroed_bytes)\n self.strobe_relays()\n print \"read from SPI: \",\n print ret\n\n #enable the relays\n self.enable_relays()","def invert(self):\n raise NotImplementedError()","def gpio_edge_listener(port):\n self.schedule_update_ha_state(True)","def __init__(self, pin: int | Pin, /):","def off(self):\n for light in self.all:\n GPIO.output(light, 0)","def init_pins(self):\n for pin in self.SENSOR_PINS:\n self.sensorValues.append(0)\n self.calibratedMax.append(0)\n self.calibratedMin.append(0)\n self.wp.pullUpDnControl(pin, self.wp.PUD_DOWN)\n self.wp.pinMode(self.LEDON_PIN, self.wp.OUTPUT)","def _update(self, mask):\n if self.reporting:\n for pin in self.pins:\n if pin.mode is INPUT:\n pin_nr = pin.pin_number - self.port_number * 8\n pin.value = (mask & (1 << pin_nr)) > 0","def set_PIenable(self,highlow): \n GPIO.output(self.chanlist[4], highlow)","def initialize_pins(self):\n\n for pin_name in self.pin_defs.keys():\n if self.pin_defs[pin_name]['mode'] == 'input':\n self.pin(pin_name).direction = digitalio.Direction.INPUT\n #logging.info('Pin {} set to {}'.format(pin_num, self.pin_defs[pin_num]['mode']))\n\n elif self.pin_defs[pin_name]['mode'] == 'output':\n self.pin(pin_name).switch_to_output(value=self.pin_defs[pin_name]['init'])\n #logging.info('Pin {} set to {}'.format(pin_num, self.pin_defs[pin_num]['mode']))\n\n else:\n logging.error('Error, no direction defined for pin {}, pin_defs: {}'\n .format(pin_name, self.pin_defs[pin_name]))","def setup(self):\n GPIO.setmode(GPIO.BCM)\n for rowp in self.rows:\n GPIO.setup(rowp, GPIO.OUT)\n for colp in self.cols:\n GPIO.setup(colp, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)","def port_disable(self, port_num: int) -> None:\n raise NotImplementedError","def __invert(self, args):","def invert(self):\n self._c = ~self._c","def Index(port,x,y):\n\tcommandString = \"C,\"+\"I\"+str(x)+\"M\"+str(y)+\",R\"\n\tport.write(commandString)","def __invert__(self):\r\n if self.field.characteristic == 2:\r\n return runtime.invert(self)\r\n\r\n return super().__invert__()","def invert(self, invert=True):\n if type(invert) is not bool:\n raise ValueError('invert must be True or False')\n elif invert:\n self._write(self.__class__.__GS + 'B' + '\\x01')\n else:\n self._write(self.__class__.__GS + 'B' + '\\x00')","def set_invert_display(enable):\n if enable:\n send_command(0xA7)\n else:\n send_command(0xA6)","def add_pins(self):\n\n for bit in range(self.addr_size):\n self.add_pin(\"addr_{0}\".format(bit),\"INPUT\")\n \n self.add_pin(\"wl_en\", \"INPUT\")\n\n for bit in range(self.num_rows):\n self.add_pin(\"wl_{0}\".format(bit),\"OUTPUT\")\n \n self.add_pin(\"vdd\",\"POWER\")\n self.add_pin(\"gnd\",\"GROUND\")","def _reverseduty(self):\n if self.ir_pin.duty() == 0:\n self.ir_pin.duty(512)\n else:\n self.ir_pin.duty(0)","def inverse_on(self):\n if self._firmware >= 268:\n self.write(self.ASCII_GS, 'B', 1)\n else:\n self._set_print_mode(self.INVERSE_MASK)","def control_lights(state):\n for led in (RED, AMBER, GREEN):\n GPIO.output(LED[led],state[led])","def disable_digital_reporting(self, pin):\n port = pin // 8\n self._ports_directly[port].disable_digital_reporting()","def setup():\n GPIO.setmode(GPIO.BCM)\n for pin in [CHURCH, CHURCH + 1, HALL, HALL + 1]:\n GPIO.setup(pin, GPIO.OUT, initial=GPIO.HIGH)","def _setup_gpio_in(self):\n for gpio_channel in self.registered_gpio:\n self.gpio_setup(gpio_channel, mode=\"in\")","def mirrored( self ):\n return self._modifier(\n self,\n lambda x: mirror_bits( x, self.nr_of_pins )\n )","def cmd_port(args):","def evert(self):\n for e in self.edges:\n self.invert()\n for f in self.faces:\n f.invert()","def enable(self, port):\n assert port in self.ports, 'bad port name'\n port = ord(port[4:]) - ord('A')\n (_, reg, ofs) = gpio_info[self.device.soc_name]\n hw = self.device.RCC.registers[reg]\n port += ofs\n val = hw.rd()\n val &= ~(1 << port)\n val |= 1 << port\n hw.wr(val)","def __init__(self, *args, **kwargs):\n super(InfinitePinCell, self).__init__(*args, **kwargs)\n self.radii = []\n self.box = []\n self.fills = []\n self.rot = []\n self.finalized = False","def Port(self) -> int:","def input_output_config(self):\r\n\t\tif self.io == 0 :\r\n\t\t\tif self.pin == 0 :\r\n\t\t\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PIN0)\r\n\t\t\telif self.pin == 1 :\r\n\t\t\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PIN1)\r\n\t\telif self.io == 1 :\r\n\t\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PINX)","def turn_off(self):\n self.write(\"OUT0\\n\")","def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\n self.GP = GPIOProcessor()\n self.pin1 = self.GP.getPin(pin1)\n self.pin2 = self.GP.getPin(pin2)\n self.pin3 = self.GP.getPin(pin3)\n self.pin4 = self.GP.getPin(pin4)\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\n\n for k in range(4):\n self.pinl[k].out()\n\n self.speed = 100.0","def __init__(self, pin =0):\n\t\tself.uv_sensor = pin\n\t\tgrovepi.pinMode(self.uv_sensor, \"INPUT\")","def GPIOsetup():\n GPIO.setmode(GPIO.BOARD)\n for led in (RED,YELLOW,GREEN):\n GPIO.setup(LED[led],GPIO.OUT)","def invert_L2_wdls():\n print()","def alias_out_port(from_tuple, to_tuple):\n\n from_unit, from_port = from_tuple\n to_unit, to_port = to_tuple\n\n to_unit.alias_out_port(from_unit, from_port, to_port)","def inverse_off(self):\n if self._firmware >= 268:\n self.write(self.ASCII_GS, 'B', 0)\n else:\n self._unset_print_mode(self.INVERSE_MASK)","def Clear(port):\n\tport.write(\"C\")","def toggle(self):\n try:\n self.pin.toggle()\n except NotImplementedError:\n if self.ison():\n self.off()\n else:\n self.on()","def set_all_pwm(self, on, off):\n self.i2cBus.write_byte_data(self.address, ALL_LED_ON_L, on & 0xFF)\n self.i2cBus.write_byte_data(self.address, ALL_LED_ON_H, on >> 8)\n self.i2cBus.write_byte_data(self.address, ALL_LED_OFF_L, off & 0xFF)\n self.i2cBus.write_byte_data(self.address, ALL_LED_OFF_H, off >> 8)","def inb():","def generate_direction_masks(cols):\n return list(product('01', repeat=cols))","def opposite(direction):\n return (direction+2)%4","def _enable_pin(pin, direction):\n _write_value(pin, \"{}/export\".format(_path_prefix))\n _write_value(direction, \"{0}/gpio{1}/direction\".format(_path_prefix, pin))","def draw_pins():\n\n pass","def relay_buzzer_config(self):\r\n\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PINX)\r\n\t\t\r\n\t\t\"\"\"Select the Output Port Register Configuration data from the given provided value\"\"\"\r\n\t\tif self.pin == 0 :\r\n\t\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_OUTPUT, PCA9537_OUTPUT_PIN0)\r\n\t\telif self.pin == 1 :\r\n\t\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_OUTPUT, PCA9537_OUTPUT_PIN1)","def map_class_to_vert(self, inpainted_mask):\n inpainted_mask[inpainted_mask==1] = self.vertebra_range[0]\n inpainted_mask[inpainted_mask==2] = self.vertebra_range[1]\n inpainted_mask[inpainted_mask==3] = self.vertebra_range[2]\n inpainted_mask[inpainted_mask==4] = self.vertebra_range[3]\n inpainted_mask[inpainted_mask==5] = self.vertebra_range[4]\n return inpainted_mask","def mask(self):","def inneReverse(board):\r\n\theight = len(board)\r\n\twidth = len(board[0])\r\n\tfor row in range(height):\r\n\t\tfor col in range(width):\r\n\t\t\tif board[row][col] == 1:\r\n\t\t\t\tboard[row][col]=0\r\n\t\t\telif board[row][col] == 0:\r\n\t\t\t\tboard[row][col]=1\r\n\treturn board","def invert(self, val):\n self._invert = val\n if val:\n self.write_cmd(self.CMD_SET_DISP_REVERSE)\n else:\n self.write_cmd(self.CMD_SET_DISP_NORMAL)","def ChanOutState(state=\"off\", channel=1, inverted=0):\r\n if inverted == 0:\r\n inst.write(\"OUTP%i %s\" %(channel,state)) \r\n elif inverted == 1:\r\n inst.write(\"OUTP%i:COMP %s\" %(channel,state))","def set_interrupt_on_port(self, port, value):\n\n if port == 0:\n self.__bus.write_byte_data(self.__ioaddress, self.GPINTENA, value)\n self.__inta = value\n else:\n self.__bus.write_byte_data(self.__ioaddress, self.GPINTENB, value)\n self.__intb = value\n return","def input_output_config(self):\r\n\t\tif self.io == 0 :\r\n\t\t\tif self.pin == 0 :\r\n\t\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN0)\r\n\t\t\telif self.pin == 1 :\r\n\t\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN1)\r\n\t\t\telif self.pin == 2 :\r\n\t\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN2)\r\n\t\t\telif self.pin == 3 :\r\n\t\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN3)\r\n\t\telif self.io == 1 :\r\n\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PINX)","def __invert__(self):\n return self.inverse()","def wr(self, port, val):\n hw = self.device.peripherals[port]\n hw.ODR.wr(val)","def set_all_ports_admin_disabled(self):\n pass","def port_in(self, port_in):\n\n self._port_in = port_in"],"string":"[\n \"def __init__(self, pin_obj: Pin, invert: bool = False):\",\n \"def invert_port(self, port, polarity):\\n\\n if port == 1:\\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLB, polarity)\\n self.__port_b_polarity = polarity\\n else:\\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLA, polarity)\\n self.__port_a_polarity = polarity\\n return\",\n \"def invert_pin(self, pin, polarity):\\n\\n pin = pin - 1\\n if pin < 8:\\n self.__port_a_polarity = self.__helper.updatebyte(\\n self.__port_a_polarity,\\n pin,\\n polarity)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IPOLA, self.__port_a_polarity)\\n else:\\n self.__port_b_polarity = self.__helper.updatebyte(\\n self.__port_b_polarity,\\n pin - 8,\\n polarity)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IPOLB, self.__port_b_polarity)\\n return\",\n \"def invert_com_scan_direction(do_invert):\\n if do_invert:\\n send_command(0xC8)\\n else:\\n send_command(0xC0)\",\n \"def set_output_pins(gpio_pi, pins):\\n for pin in pins:\\n gpio_pi.set_mode(pin, pigpio.OUTPUT)\",\n \"def turn_off(self):\\n self.set_pin(0, -1)\\n self.set_pin(1, -1)\\n self.set_pin(2, -1)\",\n \"def as_pin_out( self ):\\n return _pin_out_from_port_out( self.as_port_out() )\",\n \"def initialize_light_pins(pi, pins):\\n for pin in pins:\\n pi.set_mode(pin, pigpio.OUTPUT)\\n pi.set_pull_up_down(pin, pigpio.PUD_DOWN)\",\n \"def update_voutput_pins(self):\\n if not pfio:\\n raise Exception(\\n \\\"Looks like some sloppy programmer (probably Tom Preston...) \\\" \\\\\\n \\\"is trying to update the virtual output pins when the PiFace \\\" \\\\\\n \\\"isn't connected. Make sure you check for the pfio before calling \\\" \\\\\\n \\\"the update_voutput_pins method. kthxbai.\\\")\\n\\n output_bit_map = pfio.read_output()\\n for i in range(len(self.output_pins)):\\n # updating inner value so that we don't do more SPI reads\\n self.output_pins[i]._value = (output_bit_map >> i) & 1 \\n\\n self.queue_draw()\",\n \"def out_aux_port(self, port):\\n return self.auxout[port - 1]\",\n \"def port_revert(switch, port):\\n print client.port.port_revert(switch, port)\",\n \"def _set_unconnected_ports(self):\\n for name, ip in self._ips.items():\\n count = 0\\n inst_args = getattr(self, name)\\n ports = ip.get_ports()\\n for port in ports:\\n full_name = (port_direction_to_prefix(port.direction)\\n + port.name)\\n if full_name not in inst_args.keys():\\n sig = Signal(len(port), name=full_name)\\n inst_args[full_name] = sig\\n count += 1\",\n \"def __invert__(self):\\n return BitBoard(~self.num)\",\n \"def init():\\n print(\\\"initializing...\\\")\\n print(\\\"setting relays off\\\")\\n for pin in PINS:\\n GPIO.setup(pin, GPIO.OUT)\\n GPIO.output(pin, RELAYOFF)\",\n \"def __init__(self, pinForward, pinBackward, pinControlStraight,pinLeft, pinRight, pinControlSteering):\\n\\n self.pinForward = pinForward\\n self.pinBackward = pinBackward\\n self.pinControlStraight = pinControlStraight\\n self.pinLeft = pinLeft\\n self.pinRight = pinRight\\n self.pinControlSteering = pinControlSteering\\n GPIO.setup(self.pinForward, GPIO.OUT)\\n GPIO.setup(self.pinBackward, GPIO.OUT)\\n GPIO.setup(self.pinControlStraight, GPIO.OUT)\\n\\n GPIO.setup(self.pinLeft, GPIO.OUT)\\n GPIO.setup(self.pinRight, GPIO.OUT)\\n GPIO.setup(self.pinControlSteering, GPIO.OUT)\\n\\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\\n self.pwm_forward.start(0)\\n self.pwm_backward.start(0)\\n\\n self.pwm_left = GPIO.PWM(self.pinLeft, 100)\\n self.pwm_right = GPIO.PWM(self.pinRight, 100)\\n self.pwm_left.start(0)\\n self.pwm_right.start(0)\\n\\n GPIO.output(self.pinControlStraight,GPIO.HIGH) \\n GPIO.output(self.pinControlSteering,GPIO.HIGH)\",\n \"def drive_leds():\\n pins.D4.next = rotator[3] == 1\\n pins.D3.next = rotator[2] == 1\\n pins.D2.next = rotator[1] == 1\\n pins.D1.next = rotator[0] == 1\",\n \"def initialize():\\n for pin in sorted(OUTPUT_PINS.values()):\\n _enable_pin(pin, OUT)\\n\\n for pin in sorted(INPUT_PINS.values()):\\n _enable_pin(pin, IN)\",\n \"def port_nic():\",\n \"def set_in_pins(pins):\\n for pin in pins:\\n GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN)\\n\\tGPIO.setup(LEDPIN, GPIO.OUT)\\n\\tGPIO.output(LEDPIN, GPIO.LOW)\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.invert_bit_sptr_message_ports_out(self)\",\n \"def __init__(self, pinForward1, pinBackward1,pinForward2, pinBackward2):\\n\\n self.pinForward1 = pinForward1\\n self.pinBackward1 = pinBackward1\\n self.pinForward2 = pinForward2\\n self.pinBackward2 = pinBackward2\\n\\n GPIO.setup(self.pinForward1, GPIO.OUT)\\n GPIO.setup(self.pinBackward1, GPIO.OUT)\\n GPIO.setup(self.pinForward2, GPIO.OUT)\\n GPIO.setup(self.pinBackward2, GPIO.OUT)\\n\\n self.pwm_forward1 = GPIO.PWM(self.pinForward1, 100)\\n self.pwm_backward1 = GPIO.PWM(self.pinBackward1, 100)\\n self.pwm_forward2 = GPIO.PWM(self.pinForward2, 100)\\n self.pwm_backward2 = GPIO.PWM(self.pinBackward2, 100)\\n \\n self.pwm_forward1.start(0)\\n self.pwm_backward1.start(0)\\n self.pwm_forward2.start(0)\\n self.pwm_backward2.start(0)\",\n \"def pin_toggle(self, pin):\\n port_num = self._convert_pin_port(pin)\\n if port_num:\\n port_state = gpio.HIGH\\n if gpio.input(port_num) == gpio.HIGH:\\n port_state = gpio.LOW\\n gpio.setcfg(port_num, gpio.OUTPUT)\\n gpio.output(port_num, port_state)\",\n \"def message_ports_in(self):\\n return _spacegrant_swig.invert_bit_sptr_message_ports_in(self)\",\n \"def __init__(self):\\n GPIO.setmode(GPIO.BOARD)\\n for light in self.all:\\n GPIO.setup(light, GPIO.OUT)\",\n \"def pins(self, toggle=None, low=None, high=None):\\n\\n if toggle != None:\\n val = 0\\n for pin in toggle.split(\\\",\\\"):\\n if not pin in PINS_OUT:\\n raise ValueError(\\\"Invalid output pin '{:}'\\\".format(pin))\\n\\n val |= PINS_OUT[pin]\\n\\n self.write_block(REG_PINS, [val])\\n\\n if low != None:\\n res = self.read_block(REG_PINS, 1)\\n val = 0\\n for pin in low.split(\\\",\\\"):\\n if not pin in PINS_OUT:\\n raise ValueError(\\\"Invalid output pin '{:}'\\\".format(pin))\\n\\n # Only toggle if already high\\n if res[0] & PINS_OUT[pin] > 0:\\n val |= PINS_OUT[pin]\\n\\n if val > 0:\\n self.write_block(REG_PINS, [val])\\n\\n if high != None:\\n res = self.read_block(REG_PINS, 1)\\n val = 0\\n for pin in high.split(\\\",\\\"):\\n if not pin in PINS_OUT:\\n raise ValueError(\\\"Invalid output pin '{:}'\\\".format(pin))\\n\\n # Only toggle if already low\\n if res[0] & PINS_OUT[pin] == 0:\\n val |= PINS_OUT[pin]\\n\\n if val > 0:\\n self.write_block(REG_PINS, [val])\\n\\n res = self.read_block(REG_PINS, 1)\\n ret = {\\n \\\"input\\\": {k: bool(res[0] & v) for k, v in PINS_IN.iteritems()},\\n \\\"output\\\": {k: bool(res[0] & v) for k, v in PINS_OUT.iteritems()}\\n }\\n\\n return ret\",\n \"def invert(self):\\n return Rubik2DBoard(\\n rows=self.rows, cols=self.cols,\\n data=tuple([tuple([0 if cell == 1 else 1 for cell in row]) for row in self.faces]),\\n prior_moves=self.moves)\",\n \"def __init__(self, pinForward, pinBackward, pinControl):\\n\\n self.pinForward = pinForward\\n self.pinBackward = pinBackward\\n self.pinControl = pinControl\\n GPIO.setup(self.pinForward, GPIO.OUT)\\n GPIO.setup(self.pinBackward, GPIO.OUT)\\n GPIO.setup(self.pinControl, GPIO.OUT)\\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\\n self.pwm_forward.start(0)\\n self.pwm_backward.start(0)\\n GPIO.output(self.pinControl,GPIO.HIGH)\",\n \"def __init__(self, red_pin, green_pin, blue_pin):\\n #self.red = gpiozero.PWMLED(red_pin, frequency=80, initial_value=1)\\n #self.green = gpiozero.PWMLED(green_pin, frequency=80, initial_value=1)\\n #self.blue = gpiozero.PWMLED(blue_pin, frequency=80, initial_value=1)\\n self.red = gpiozero.LED(red_pin)\\n self.green = gpiozero.LED(green_pin)\\n self.blue = gpiozero.LED(blue_pin)\\n self.leds = [self.red, self.green, self.blue]\\n self.off()\",\n \"def write(self):\\n mask = 0\\n for pin in self.pins:\\n if pin.mode == OUTPUT:\\n if pin.value == 1:\\n pin_nr = pin.pin_number - self.port_number * 8\\n mask |= 1 << pin_nr\\n msg = chr(DIGITAL_MESSAGE + self.port_number)\\n msg += chr(mask % 128)\\n msg += chr(mask >> 7)\\n self.board.sp.write(msg)\",\n \"def motorDirection(self, motorPin, direction):\\n # print \\\"motorPin: \\\", motorPin\\n # print \\\"direction: \\\", direction\\n GPIO.output(motorPin, direction)\",\n \"def init_switches(inds):\\n for i in inds:\\n GPIO.setup(i, GPIO.OUT, initial=0)\",\n \"def toggleEdgeMode(self, PWMpin):\\n mask = 1 << PWMpin\\n self._injectFault(\\\"PWM1PCR\\\", self.PCR, mask)\",\n \"def write( self, value ) -> None:\\n if value:\\n self._slave.write( invert_bits( 0, self._slave.nr_of_pins ) )\\n else:\\n self._slave.write( 0 )\",\n \"def pin_off(self, pin):\\n port_num = self._convert_pin_port(pin)\\n if port_num:\\n gpio.setcfg(port_num, gpio.OUTPUT)\\n gpio.output(port_num, gpio.LOW)\",\n \"def set_pattern(self, pattern):\\n for ir, row in enumerate(pattern):\\n for ic, col in enumerate(row):\\n relay_n = ir*len(row) + ic\\n self.relay.set(relay_n, bool(col))\",\n \"def __init__(__self__, *,\\n from_port: pulumi.Input[int],\\n to_port: pulumi.Input[int]):\\n pulumi.set(__self__, \\\"from_port\\\", from_port)\\n pulumi.set(__self__, \\\"to_port\\\", to_port)\",\n \"def inverted_board(self):\\r\\n invert_board = []\\r\\n for line_index in range(len(self.board) - 1, -1,\\r\\n -1): # For each number\\r\\n # (descending) from the max index line\\r\\n # of the matrix (len-1) to 0 (included)\\r\\n\\r\\n invert_board.append(self.board[line_index]) #\\r\\n return invert_board\",\n \"def set_pin_direction(self, pin, direction):\\n pin = pin - 1\\n if pin < 8:\\n self.__port_a_direction = self.__helper.updatebyte(\\n self.__port_a_direction, pin, direction)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IODIRA, self.__port_a_direction)\\n else:\\n self.__port_b_direction = self.__helper.updatebyte(\\n self.__port_b_direction, pin - 8, direction)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IODIRB, self.__port_b_direction)\\n return\",\n \"def reverse_axis(self, x: bool, y: bool, z: bool) -> None:\\n current_directions = self.i2c.read(self.Register.AXIS_MAP_SIGN, 1)[0]\\n if x:\\n current_directions |= (1 << 2)\\n else:\\n current_directions &= ~(1 << 2)\\n if y:\\n current_directions |= (1 << 1)\\n else:\\n current_directions &= ~(1 << 1)\\n if z:\\n current_directions |= (1 << 0)\\n else:\\n current_directions &= ~(1 << 0)\\n self.i2c.write(self.Register.AXIS_MAP_SIGN, current_directions)\",\n \"def setup_gpio(self):\\n for row in self._rows:\\n GPIO.setup(row, GPIO.IN, pull_up_down=GPIO.PUD_UP)\\n for coll in self._colls:\\n GPIO.setup(coll, GPIO.OUT)\\n GPIO.output(coll, 1)\",\n \"def __init__(self):\\n GPIO.setmode(GPIO.BCM)\\n GPIO.setup(pin,GPIO.OUT)\",\n \"def ext_pins(self, toggle=None, low=None, high=None):\\n\\n if toggle != None:\\n val = 0\\n for pin in toggle.split(\\\",\\\"):\\n if not pin in EXT_PINS_OUT:\\n raise ValueError(\\\"Invalid output extension pin '{:}'\\\".format(pin))\\n\\n val |= EXT_PINS_OUT[pin]\\n\\n self.write_block(REG_EXT_PINS, [val])\\n\\n if low != None:\\n res = self.read_block(REG_EXT_PINS, 1)\\n val = 0\\n for pin in low.split(\\\",\\\"):\\n if not pin in EXT_PINS_OUT:\\n raise ValueError(\\\"Invalid output extension pin '{:}'\\\".format(pin))\\n\\n # Only toggle if already high\\n if res[0] & EXT_PINS_OUT[pin] > 0:\\n val |= EXT_PINS_OUT[pin]\\n\\n if val > 0:\\n self.write_block(REG_EXT_PINS, [val])\\n\\n if high != None:\\n res = self.read_block(REG_EXT_PINS, 1)\\n val = 0\\n for pin in high.split(\\\",\\\"):\\n if not pin in EXT_PINS_OUT:\\n raise ValueError(\\\"Invalid output extension pin '{:}'\\\".format(pin))\\n\\n # Only toggle if already low\\n if res[0] & EXT_PINS_OUT[pin] == 0:\\n val |= EXT_PINS_OUT[pin]\\n\\n if val > 0:\\n self.write_block(REG_EXT_PINS, [val])\\n\\n res = self.read_block(REG_EXT_PINS, 1)\\n ret = {\\n \\\"input\\\": {k: bool(res[0] & v) for k, v in EXT_PINS_IN.iteritems()},\\n \\\"output\\\": {k: bool(res[0] & v) for k, v in EXT_PINS_OUT.iteritems()}\\n }\\n\\n return ret\",\n \"def initialize_relays(self):\\n #create list of bytes to clear out relays\\n zeroed_bytes = []\\n for i in range(self.num_registers):\\n zeroed_bytes.append(0x00)\\n\\n #clear out any data in the shift registers\\n ret = self.e.write_SPI_bytes_to_portA(zeroed_bytes)\\n self.strobe_relays()\\n print \\\"read from SPI: \\\",\\n print ret\\n\\n #enable the relays\\n self.enable_relays()\",\n \"def invert(self):\\n raise NotImplementedError()\",\n \"def gpio_edge_listener(port):\\n self.schedule_update_ha_state(True)\",\n \"def __init__(self, pin: int | Pin, /):\",\n \"def off(self):\\n for light in self.all:\\n GPIO.output(light, 0)\",\n \"def init_pins(self):\\n for pin in self.SENSOR_PINS:\\n self.sensorValues.append(0)\\n self.calibratedMax.append(0)\\n self.calibratedMin.append(0)\\n self.wp.pullUpDnControl(pin, self.wp.PUD_DOWN)\\n self.wp.pinMode(self.LEDON_PIN, self.wp.OUTPUT)\",\n \"def _update(self, mask):\\n if self.reporting:\\n for pin in self.pins:\\n if pin.mode is INPUT:\\n pin_nr = pin.pin_number - self.port_number * 8\\n pin.value = (mask & (1 << pin_nr)) > 0\",\n \"def set_PIenable(self,highlow): \\n GPIO.output(self.chanlist[4], highlow)\",\n \"def initialize_pins(self):\\n\\n for pin_name in self.pin_defs.keys():\\n if self.pin_defs[pin_name]['mode'] == 'input':\\n self.pin(pin_name).direction = digitalio.Direction.INPUT\\n #logging.info('Pin {} set to {}'.format(pin_num, self.pin_defs[pin_num]['mode']))\\n\\n elif self.pin_defs[pin_name]['mode'] == 'output':\\n self.pin(pin_name).switch_to_output(value=self.pin_defs[pin_name]['init'])\\n #logging.info('Pin {} set to {}'.format(pin_num, self.pin_defs[pin_num]['mode']))\\n\\n else:\\n logging.error('Error, no direction defined for pin {}, pin_defs: {}'\\n .format(pin_name, self.pin_defs[pin_name]))\",\n \"def setup(self):\\n GPIO.setmode(GPIO.BCM)\\n for rowp in self.rows:\\n GPIO.setup(rowp, GPIO.OUT)\\n for colp in self.cols:\\n GPIO.setup(colp, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\",\n \"def port_disable(self, port_num: int) -> None:\\n raise NotImplementedError\",\n \"def __invert(self, args):\",\n \"def invert(self):\\n self._c = ~self._c\",\n \"def Index(port,x,y):\\n\\tcommandString = \\\"C,\\\"+\\\"I\\\"+str(x)+\\\"M\\\"+str(y)+\\\",R\\\"\\n\\tport.write(commandString)\",\n \"def __invert__(self):\\r\\n if self.field.characteristic == 2:\\r\\n return runtime.invert(self)\\r\\n\\r\\n return super().__invert__()\",\n \"def invert(self, invert=True):\\n if type(invert) is not bool:\\n raise ValueError('invert must be True or False')\\n elif invert:\\n self._write(self.__class__.__GS + 'B' + '\\\\x01')\\n else:\\n self._write(self.__class__.__GS + 'B' + '\\\\x00')\",\n \"def set_invert_display(enable):\\n if enable:\\n send_command(0xA7)\\n else:\\n send_command(0xA6)\",\n \"def add_pins(self):\\n\\n for bit in range(self.addr_size):\\n self.add_pin(\\\"addr_{0}\\\".format(bit),\\\"INPUT\\\")\\n \\n self.add_pin(\\\"wl_en\\\", \\\"INPUT\\\")\\n\\n for bit in range(self.num_rows):\\n self.add_pin(\\\"wl_{0}\\\".format(bit),\\\"OUTPUT\\\")\\n \\n self.add_pin(\\\"vdd\\\",\\\"POWER\\\")\\n self.add_pin(\\\"gnd\\\",\\\"GROUND\\\")\",\n \"def _reverseduty(self):\\n if self.ir_pin.duty() == 0:\\n self.ir_pin.duty(512)\\n else:\\n self.ir_pin.duty(0)\",\n \"def inverse_on(self):\\n if self._firmware >= 268:\\n self.write(self.ASCII_GS, 'B', 1)\\n else:\\n self._set_print_mode(self.INVERSE_MASK)\",\n \"def control_lights(state):\\n for led in (RED, AMBER, GREEN):\\n GPIO.output(LED[led],state[led])\",\n \"def disable_digital_reporting(self, pin):\\n port = pin // 8\\n self._ports_directly[port].disable_digital_reporting()\",\n \"def setup():\\n GPIO.setmode(GPIO.BCM)\\n for pin in [CHURCH, CHURCH + 1, HALL, HALL + 1]:\\n GPIO.setup(pin, GPIO.OUT, initial=GPIO.HIGH)\",\n \"def _setup_gpio_in(self):\\n for gpio_channel in self.registered_gpio:\\n self.gpio_setup(gpio_channel, mode=\\\"in\\\")\",\n \"def mirrored( self ):\\n return self._modifier(\\n self,\\n lambda x: mirror_bits( x, self.nr_of_pins )\\n )\",\n \"def cmd_port(args):\",\n \"def evert(self):\\n for e in self.edges:\\n self.invert()\\n for f in self.faces:\\n f.invert()\",\n \"def enable(self, port):\\n assert port in self.ports, 'bad port name'\\n port = ord(port[4:]) - ord('A')\\n (_, reg, ofs) = gpio_info[self.device.soc_name]\\n hw = self.device.RCC.registers[reg]\\n port += ofs\\n val = hw.rd()\\n val &= ~(1 << port)\\n val |= 1 << port\\n hw.wr(val)\",\n \"def __init__(self, *args, **kwargs):\\n super(InfinitePinCell, self).__init__(*args, **kwargs)\\n self.radii = []\\n self.box = []\\n self.fills = []\\n self.rot = []\\n self.finalized = False\",\n \"def Port(self) -> int:\",\n \"def input_output_config(self):\\r\\n\\t\\tif self.io == 0 :\\r\\n\\t\\t\\tif self.pin == 0 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PIN0)\\r\\n\\t\\t\\telif self.pin == 1 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PIN1)\\r\\n\\t\\telif self.io == 1 :\\r\\n\\t\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PINX)\",\n \"def turn_off(self):\\n self.write(\\\"OUT0\\\\n\\\")\",\n \"def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\\n self.GP = GPIOProcessor()\\n self.pin1 = self.GP.getPin(pin1)\\n self.pin2 = self.GP.getPin(pin2)\\n self.pin3 = self.GP.getPin(pin3)\\n self.pin4 = self.GP.getPin(pin4)\\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\\n\\n for k in range(4):\\n self.pinl[k].out()\\n\\n self.speed = 100.0\",\n \"def __init__(self, pin =0):\\n\\t\\tself.uv_sensor = pin\\n\\t\\tgrovepi.pinMode(self.uv_sensor, \\\"INPUT\\\")\",\n \"def GPIOsetup():\\n GPIO.setmode(GPIO.BOARD)\\n for led in (RED,YELLOW,GREEN):\\n GPIO.setup(LED[led],GPIO.OUT)\",\n \"def invert_L2_wdls():\\n print()\",\n \"def alias_out_port(from_tuple, to_tuple):\\n\\n from_unit, from_port = from_tuple\\n to_unit, to_port = to_tuple\\n\\n to_unit.alias_out_port(from_unit, from_port, to_port)\",\n \"def inverse_off(self):\\n if self._firmware >= 268:\\n self.write(self.ASCII_GS, 'B', 0)\\n else:\\n self._unset_print_mode(self.INVERSE_MASK)\",\n \"def Clear(port):\\n\\tport.write(\\\"C\\\")\",\n \"def toggle(self):\\n try:\\n self.pin.toggle()\\n except NotImplementedError:\\n if self.ison():\\n self.off()\\n else:\\n self.on()\",\n \"def set_all_pwm(self, on, off):\\n self.i2cBus.write_byte_data(self.address, ALL_LED_ON_L, on & 0xFF)\\n self.i2cBus.write_byte_data(self.address, ALL_LED_ON_H, on >> 8)\\n self.i2cBus.write_byte_data(self.address, ALL_LED_OFF_L, off & 0xFF)\\n self.i2cBus.write_byte_data(self.address, ALL_LED_OFF_H, off >> 8)\",\n \"def inb():\",\n \"def generate_direction_masks(cols):\\n return list(product('01', repeat=cols))\",\n \"def opposite(direction):\\n return (direction+2)%4\",\n \"def _enable_pin(pin, direction):\\n _write_value(pin, \\\"{}/export\\\".format(_path_prefix))\\n _write_value(direction, \\\"{0}/gpio{1}/direction\\\".format(_path_prefix, pin))\",\n \"def draw_pins():\\n\\n pass\",\n \"def relay_buzzer_config(self):\\r\\n\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PINX)\\r\\n\\t\\t\\r\\n\\t\\t\\\"\\\"\\\"Select the Output Port Register Configuration data from the given provided value\\\"\\\"\\\"\\r\\n\\t\\tif self.pin == 0 :\\r\\n\\t\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_OUTPUT, PCA9537_OUTPUT_PIN0)\\r\\n\\t\\telif self.pin == 1 :\\r\\n\\t\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_OUTPUT, PCA9537_OUTPUT_PIN1)\",\n \"def map_class_to_vert(self, inpainted_mask):\\n inpainted_mask[inpainted_mask==1] = self.vertebra_range[0]\\n inpainted_mask[inpainted_mask==2] = self.vertebra_range[1]\\n inpainted_mask[inpainted_mask==3] = self.vertebra_range[2]\\n inpainted_mask[inpainted_mask==4] = self.vertebra_range[3]\\n inpainted_mask[inpainted_mask==5] = self.vertebra_range[4]\\n return inpainted_mask\",\n \"def mask(self):\",\n \"def inneReverse(board):\\r\\n\\theight = len(board)\\r\\n\\twidth = len(board[0])\\r\\n\\tfor row in range(height):\\r\\n\\t\\tfor col in range(width):\\r\\n\\t\\t\\tif board[row][col] == 1:\\r\\n\\t\\t\\t\\tboard[row][col]=0\\r\\n\\t\\t\\telif board[row][col] == 0:\\r\\n\\t\\t\\t\\tboard[row][col]=1\\r\\n\\treturn board\",\n \"def invert(self, val):\\n self._invert = val\\n if val:\\n self.write_cmd(self.CMD_SET_DISP_REVERSE)\\n else:\\n self.write_cmd(self.CMD_SET_DISP_NORMAL)\",\n \"def ChanOutState(state=\\\"off\\\", channel=1, inverted=0):\\r\\n if inverted == 0:\\r\\n inst.write(\\\"OUTP%i %s\\\" %(channel,state)) \\r\\n elif inverted == 1:\\r\\n inst.write(\\\"OUTP%i:COMP %s\\\" %(channel,state))\",\n \"def set_interrupt_on_port(self, port, value):\\n\\n if port == 0:\\n self.__bus.write_byte_data(self.__ioaddress, self.GPINTENA, value)\\n self.__inta = value\\n else:\\n self.__bus.write_byte_data(self.__ioaddress, self.GPINTENB, value)\\n self.__intb = value\\n return\",\n \"def input_output_config(self):\\r\\n\\t\\tif self.io == 0 :\\r\\n\\t\\t\\tif self.pin == 0 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN0)\\r\\n\\t\\t\\telif self.pin == 1 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN1)\\r\\n\\t\\t\\telif self.pin == 2 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN2)\\r\\n\\t\\t\\telif self.pin == 3 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN3)\\r\\n\\t\\telif self.io == 1 :\\r\\n\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PINX)\",\n \"def __invert__(self):\\n return self.inverse()\",\n \"def wr(self, port, val):\\n hw = self.device.peripherals[port]\\n hw.ODR.wr(val)\",\n \"def set_all_ports_admin_disabled(self):\\n pass\",\n \"def port_in(self, port_in):\\n\\n self._port_in = port_in\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63888365","0.6374163","0.6296547","0.5969197","0.59159297","0.58010113","0.57998306","0.57990515","0.56984675","0.5620566","0.56079745","0.5602531","0.5586794","0.5572789","0.55686104","0.55678266","0.55626017","0.5534482","0.5527071","0.5523599","0.55229497","0.55068856","0.5501181","0.5478181","0.54637015","0.5431695","0.5393695","0.5386914","0.5351191","0.5351118","0.5348087","0.53235507","0.52930516","0.52806115","0.5278652","0.52746075","0.5273342","0.52715605","0.5262373","0.5255646","0.52395475","0.5226274","0.5218137","0.5215035","0.5205994","0.52030295","0.519685","0.51849043","0.5183119","0.5182704","0.516547","0.5164348","0.5156887","0.51453763","0.5144392","0.51354223","0.51300824","0.51147735","0.5106187","0.5089697","0.5064143","0.50630575","0.5057245","0.50560683","0.50470525","0.5019651","0.5018224","0.50144035","0.5013827","0.50057054","0.4995175","0.4987381","0.49872568","0.49865204","0.4981807","0.49810445","0.4977982","0.49746436","0.49727115","0.49649918","0.49640667","0.4959466","0.49538112","0.4948514","0.49475875","0.49362648","0.49351057","0.49316698","0.49245286","0.49241364","0.49236402","0.49136037","0.4911955","0.49086252","0.49076232","0.4907365","0.48991138","0.4898559","0.48915973","0.48841056"],"string":"[\n \"0.63888365\",\n \"0.6374163\",\n \"0.6296547\",\n \"0.5969197\",\n \"0.59159297\",\n \"0.58010113\",\n \"0.57998306\",\n \"0.57990515\",\n \"0.56984675\",\n \"0.5620566\",\n \"0.56079745\",\n \"0.5602531\",\n \"0.5586794\",\n \"0.5572789\",\n \"0.55686104\",\n \"0.55678266\",\n \"0.55626017\",\n \"0.5534482\",\n \"0.5527071\",\n \"0.5523599\",\n \"0.55229497\",\n \"0.55068856\",\n \"0.5501181\",\n \"0.5478181\",\n \"0.54637015\",\n \"0.5431695\",\n \"0.5393695\",\n \"0.5386914\",\n \"0.5351191\",\n \"0.5351118\",\n \"0.5348087\",\n \"0.53235507\",\n \"0.52930516\",\n \"0.52806115\",\n \"0.5278652\",\n \"0.52746075\",\n \"0.5273342\",\n \"0.52715605\",\n \"0.5262373\",\n \"0.5255646\",\n \"0.52395475\",\n \"0.5226274\",\n \"0.5218137\",\n \"0.5215035\",\n \"0.5205994\",\n \"0.52030295\",\n \"0.519685\",\n \"0.51849043\",\n \"0.5183119\",\n \"0.5182704\",\n \"0.516547\",\n \"0.5164348\",\n \"0.5156887\",\n \"0.51453763\",\n \"0.5144392\",\n \"0.51354223\",\n \"0.51300824\",\n \"0.51147735\",\n \"0.5106187\",\n \"0.5089697\",\n \"0.5064143\",\n \"0.50630575\",\n \"0.5057245\",\n \"0.50560683\",\n \"0.50470525\",\n \"0.5019651\",\n \"0.5018224\",\n \"0.50144035\",\n \"0.5013827\",\n \"0.50057054\",\n \"0.4995175\",\n \"0.4987381\",\n \"0.49872568\",\n \"0.49865204\",\n \"0.4981807\",\n \"0.49810445\",\n \"0.4977982\",\n \"0.49746436\",\n \"0.49727115\",\n \"0.49649918\",\n \"0.49640667\",\n \"0.4959466\",\n \"0.49538112\",\n \"0.4948514\",\n \"0.49475875\",\n \"0.49362648\",\n \"0.49351057\",\n \"0.49316698\",\n \"0.49245286\",\n \"0.49241364\",\n \"0.49236402\",\n \"0.49136037\",\n \"0.4911955\",\n \"0.49086252\",\n \"0.49076232\",\n \"0.4907365\",\n \"0.48991138\",\n \"0.4898559\",\n \"0.48915973\",\n \"0.48841056\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6363903"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":86098,"cells":{"query":{"kind":"string","value":"port with the pins mirrored (pin order reversed)"},"document":{"kind":"string","value":"def mirrored( self ):\n return self._modifier(\n self,\n lambda x: mirror_bits( x, self.nr_of_pins )\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def op_mirror():\n mir = np.array([[1, 0, 0, 0],\n [0, 1, 0, 0],\n [0, 0, -1, 0],\n [0, 0, 0, -1]])\n return mir","def as_pin_out( self ):\n return _pin_out_from_port_out( self.as_port_out() )","def rotate(self):\n\n self.pins = self.pins[1:] + list(self.pins[0])\n self.mapping = self.mapping[1:] + list(self.mapping[0])","def mirror(self):\n return RequirePort(self)","def port_revert(switch, port):\n print client.port.port_revert(switch, port)","def invert_pin(self, pin, polarity):\n\n pin = pin - 1\n if pin < 8:\n self.__port_a_polarity = self.__helper.updatebyte(\n self.__port_a_polarity,\n pin,\n polarity)\n self.__bus.write_byte_data(\n self.__ioaddress, self.IPOLA, self.__port_a_polarity)\n else:\n self.__port_b_polarity = self.__helper.updatebyte(\n self.__port_b_polarity,\n pin - 8,\n polarity)\n self.__bus.write_byte_data(\n self.__ioaddress, self.IPOLB, self.__port_b_polarity)\n return","def mirror(to='IN'):\n to = to.strip().upper()\n if (to==\"OUT\"):\n opticalcoupler.MoveMirror(0)\n logger.info('Mirror: '+to)\n camera.status.mirror = 'OUT'\n elif (to==\"IN\"):\n opticalcoupler.MoveMirror(opticalcoupler.MIRROR_IN)\n logger.info('Mirror: '+to)\n camera.status.mirror = 'IN'\n else:\n logger.error(\"Usage: 'mirror IN' or 'mirror OUT'\")","def mirror(self):\n return ProvidePort(self)","def invert_port(self, port, polarity):\n\n if port == 1:\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLB, polarity)\n self.__port_b_polarity = polarity\n else:\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLA, polarity)\n self.__port_a_polarity = polarity\n return","def __init__(self, pin_obj: Pin, invert: bool = False):","def turn_off(self):\n self.set_pin(0, -1)\n self.set_pin(1, -1)\n self.set_pin(2, -1)","def drive_leds():\n pins.D4.next = rotator[3] == 1\n pins.D3.next = rotator[2] == 1\n pins.D2.next = rotator[1] == 1\n pins.D1.next = rotator[0] == 1","def mirror(self):\n self.__mirror = not self.__mirror","def mirror(self):\n for l in range(self.numRows):\n mirrorGrid = []\n for l in range(self.numCols):\n row = self.grid[l][::-1]\n mirrorGrid.append(row)\n return mirrorGrid","def set_pin_direction(self, pin, direction):\n pin = pin - 1\n if pin < 8:\n self.__port_a_direction = self.__helper.updatebyte(\n self.__port_a_direction, pin, direction)\n self.__bus.write_byte_data(\n self.__ioaddress, self.IODIRA, self.__port_a_direction)\n else:\n self.__port_b_direction = self.__helper.updatebyte(\n self.__port_b_direction, pin - 8, direction)\n self.__bus.write_byte_data(\n self.__ioaddress, self.IODIRB, self.__port_b_direction)\n return","def lr_flip(self):\n for g in self.grid:\n g.reverse()","def mirror(img):\n return img[:, ::-1]","def out_aux_port(self, port):\n return self.auxout[port - 1]","def mirror_y(board):\n new_board = board[:]\n new_board.reverse()\n return new_board","def message_ports_out(self):\n return _spacegrant_swig.invert_bit_sptr_message_ports_out(self)","def invert(self):\n return Rubik2DBoard(\n rows=self.rows, cols=self.cols,\n data=tuple([tuple([0 if cell == 1 else 1 for cell in row]) for row in self.faces]),\n prior_moves=self.moves)","def _set_unconnected_ports(self):\n for name, ip in self._ips.items():\n count = 0\n inst_args = getattr(self, name)\n ports = ip.get_ports()\n for port in ports:\n full_name = (port_direction_to_prefix(port.direction)\n + port.name)\n if full_name not in inst_args.keys():\n sig = Signal(len(port), name=full_name)\n inst_args[full_name] = sig\n count += 1","def __invert__(self):\n return BitBoard(~self.num)","def inverted( self ):\n return self._modifier(\n self,\n lambda x: invert_bits( x, self.nr_of_pins )\n )","def initialize_light_pins(pi, pins):\n for pin in pins:\n pi.set_mode(pin, pigpio.OUTPUT)\n pi.set_pull_up_down(pin, pigpio.PUD_DOWN)","def message_ports_in(self):\n return _spacegrant_swig.invert_bit_sptr_message_ports_in(self)","def portpreserveparity(self) :\n\t\ttry :\n\t\t\treturn self._portpreserveparity\n\t\texcept Exception as e:\n\t\t\traise e","def invert_com_scan_direction(do_invert):\n if do_invert:\n send_command(0xC8)\n else:\n send_command(0xC0)","def port_nic():","def setAsMirror(self, mirrorNp):\r\n mirrorNp.setTexture( self.mirrorBuffer.getTexture(), 1 )","def pin(self, name, mn, direction=None, netname=None, params=None):\n #pin0 = Pin(xy=[[0, 0], [100, 100]], layer=['M1', 'drawing'], netname='net0', master=rect0,\n # params={'direction': 'input'})\n xy0 = self.abs2phy[mn[0]]\n xy1 = self.abs2phy[mn[1]]\n #_xy = np.array([[xy0[0], xy0[1]], [xy1[0], xy1[1]]])\n if np.all(xy0 == xy1): # if two points are identical, generate a metal stub on the bottom layer.\n if (direction == 'vertical') or ((direction is None) and (self.primary_grid == 'vertical')):\n width = self.vwidth[mn[0][0]]\n hextension = int(width / 2)\n vextension = 0\n layer = self.pin_vlayer[mn[0][0]]\n else:\n width = self.hwidth[mn[0][1]]\n hextension = 0\n vextension = int(width / 2)\n layer = self.pin_hlayer[mn[0][1]]\n else:\n if (xy0[0] == xy1[0]) or (direction == 'vertical'): # vertical routing\n width = self.vwidth[mn[0][0]]\n hextension = int(width / 2)\n vextension = 0\n layer = self.pin_vlayer[mn[0][0]]\n else: # horizontal routing\n width = self.hwidth[mn[0][1]]\n hextension = 0\n vextension = int(width / 2)\n layer = self.pin_hlayer[mn[0][1]]\n # TODO: pin.xy differ from tech.py.\n _xy = np.array([[xy0[0]-hextension, xy0[1]-vextension], [xy1[0]+hextension, xy1[1]+vextension]]) ## need to check\n p = laygo2.object.physical.Pin(name=name, xy=_xy, layer=layer, netname=netname, params=params)\n return p","def cw_rotate(self):\n self.grid = [list(x) for x in zip(*self.grid[::-1])]\n self.find_edges()","def reverse_axis(self, x: bool, y: bool, z: bool) -> None:\n current_directions = self.i2c.read(self.Register.AXIS_MAP_SIGN, 1)[0]\n if x:\n current_directions |= (1 << 2)\n else:\n current_directions &= ~(1 << 2)\n if y:\n current_directions |= (1 << 1)\n else:\n current_directions &= ~(1 << 1)\n if z:\n current_directions |= (1 << 0)\n else:\n current_directions &= ~(1 << 0)\n self.i2c.write(self.Register.AXIS_MAP_SIGN, current_directions)","def reverse(self, lon, lat):","def set_pattern(self, pattern):\n for ir, row in enumerate(pattern):\n for ic, col in enumerate(row):\n relay_n = ir*len(row) + ic\n self.relay.set(relay_n, bool(col))","def mirrorImage(self):\n\n im = Image.open(self.ActivePhoto)\n out = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\n out.save(self.ActivePhoto)\n self.photo.setPixmap(QtGui.QPixmap(self.ActivePhoto))\n print (\"Flipped image\")","def inneReverse(board):\r\n\theight = len(board)\r\n\twidth = len(board[0])\r\n\tfor row in range(height):\r\n\t\tfor col in range(width):\r\n\t\t\tif board[row][col] == 1:\r\n\t\t\t\tboard[row][col]=0\r\n\t\t\telif board[row][col] == 0:\r\n\t\t\t\tboard[row][col]=1\r\n\treturn board","def mirror_x(board):\n new_board = board[:]\n for (ix, item) in enumerate(board):\n new_board[ix] = (len(board) - 1) - item\n\n return new_board","def _reverseduty(self):\n if self.ir_pin.duty() == 0:\n self.ir_pin.duty(512)\n else:\n self.ir_pin.duty(0)","def mirror_augmentation():\n return lambda image: ImageOps.mirror(image)","def arm_mirror():\n MOVEMENTS.disable_all_joints()\n while True:\n for i in range(3):\n angle = MOVEMENTS.get_raw_angle(i*2)\n MOVEMENTS.set_raw_angle(i*2 +1, angle)\n sleep(0.01)","def upsidedownmirror(self):\n for l in range(self.numRows):\n upsideDownGrid = []\n for l in range(self.numCols-1,-1,-1):\n upsideDownGrid.append(self.grid[l][::-1])\n return upsideDownGrid","def __mirror(self, x, y):\n return (self.width - x - 1, self.height - y - 1)","def set_output_pins(gpio_pi, pins):\n for pin in pins:\n gpio_pi.set_mode(pin, pigpio.OUTPUT)","def opposite(direction):\n return (direction+2)%4","def mirror(self):\n newRot = [x for x in self.rot]\n newRot[1] = -newRot[1]\n newLRot = [x for x in self.lrot]\n newLRot[1] = -newLRot[1]\n newLRot[2] = -newLRot[2]\n return Wall(self.beat, self.dur, -self.r, -self.l, self.d, self.u, newRot, newLRot)","def alias_out_port(from_tuple, to_tuple):\n\n from_unit, from_port = from_tuple\n to_unit, to_port = to_tuple\n\n to_unit.alias_out_port(from_unit, from_port, to_port)","def generate_direction_masks(cols):\n return list(product('01', repeat=cols))","def mirrorTour(tour):\n M0 = reflection_matrix((0,0,0), (1,0,0))\n mvps = []\n for vp in tour:\n p = vp.camera.position\n q = vp.camera.orientation\n print(p,q)\n mp = np.array((p.x,p.y,p.z,1.0))*np.matrix(M0)\n mp = np.squeeze(np.asarray(mp))\n # mq = quaternion_matrix((q.x,q.y,q.z,q.w))*np.matrix(M0)\n # mq = quaternion_from_matrix(mq)\n mq = (q.x,-q.y,-q.z,q.w)\n # print(mp,mq)\n mvp = ViewPoint(vp.id+10000,mp[0],mp[1],mp[2],mq[0],mq[1],mq[2],mq[3])\n mvps.append(mvp)\n return mvps","def rotate(self, matrix):\n n = len(matrix)\n #转置\n for i in range(n):\n for j in range(i+1,n):\n matrix[i][j],matrix[j][i] = matrix[j][i],matrix[i][j]\n #镜像\n mid = n//2\n for i in range(n):\n for j in range(mid):\n matrix[i][j],matrix[i][n-j-1] = matrix[i][n-j-1],matrix[i][j]","def flip(self):","def inverted_board(self):\r\n invert_board = []\r\n for line_index in range(len(self.board) - 1, -1,\r\n -1): # For each number\r\n # (descending) from the max index line\r\n # of the matrix (len-1) to 0 (included)\r\n\r\n invert_board.append(self.board[line_index]) #\r\n return invert_board","def mirror(f, j=0):\n return f.per(dmp_mirror_in(f.rep, j, f.lev, f.dom))","def rotatable_bonds(self):\n raise NotImplementedError","def pin_off(self, pin):\n port_num = self._convert_pin_port(pin)\n if port_num:\n gpio.setcfg(port_num, gpio.OUTPUT)\n gpio.output(port_num, gpio.LOW)","def mirror_gun (glider_gun):\n return glider_gun[2] (-1, 0, swap_xy)","def pin(self) -> int:","def dest(side):\n return (side - 1) % 3 # cw(side)","def reset_directions(directions, dir='from'):\n if dir == 'from':\n # reverse the direction, so it plots \"to\"\n print(\"reversing direction\")\n directions = (directions + 90) * -1\n elif dir == 'to':\n # don't reverse, so it plots \"to\"\n directions = (directions - 90) * -1\n else:\n raise ValueError('dir has to be either \"from\" or \"to\"')\n return directions","def motorDirection(self, motorPin, direction):\n # print \"motorPin: \", motorPin\n # print \"direction: \", direction\n GPIO.output(motorPin, direction)","def flip(self):\n self._start, self._end = self._end, self._start","def set_pin_pullup(self, pin, value):\n pin = pin - 1\n if pin < 8:\n self.__port_a_pullup = self.__helper.updatebyte(\n self.__port_a_pullup, pin, value)\n self.__bus.write_byte_data(\n self.__ioaddress, self.GPPUA, self.__port_a_pullup)\n else:\n self.__port_b_pullup = self.__helper.updatebyte(\n self.__port_b_pullup, pin - 8, value)\n self.__bus.write_byte_data(\n self.__ioaddress, self.GPPUB, self.__port_b_pullup)\n return","def draw_mirrored_cell(self, pos, color):\n self.hexes.set_cells(helpfunc.mirror_hexes(pos), color)","def __init__(self, pinForward1, pinBackward1,pinForward2, pinBackward2):\n\n self.pinForward1 = pinForward1\n self.pinBackward1 = pinBackward1\n self.pinForward2 = pinForward2\n self.pinBackward2 = pinBackward2\n\n GPIO.setup(self.pinForward1, GPIO.OUT)\n GPIO.setup(self.pinBackward1, GPIO.OUT)\n GPIO.setup(self.pinForward2, GPIO.OUT)\n GPIO.setup(self.pinBackward2, GPIO.OUT)\n\n self.pwm_forward1 = GPIO.PWM(self.pinForward1, 100)\n self.pwm_backward1 = GPIO.PWM(self.pinBackward1, 100)\n self.pwm_forward2 = GPIO.PWM(self.pinForward2, 100)\n self.pwm_backward2 = GPIO.PWM(self.pinBackward2, 100)\n \n self.pwm_forward1.start(0)\n self.pwm_backward1.start(0)\n self.pwm_forward2.start(0)\n self.pwm_backward2.start(0)","def Port(self) -> int:","def TestSlipDualReverse(port,N):\n\tfor its in range(N):\n\t\tprint \"backward iteration \" + str(its)\n\t\tfor i in range(10):\n\t\t\tIndexS(port,1,-133)\n\t\t\tIndexS(port,2,400)\n\n\t\tprint \"forward iteration \" + str(its)\n\t\tfor i in range(10):\n\t\t\tIndexS(port,1,133)\n\t\t\tIndexS(port,2,-400)","def rotate(self, direction):\n new_board = deepcopy(self.board)\n if direction == Direction.CLOCKWISE:\n new_board[2] = self.board[0]\n new_board[5] = self.board[1]\n new_board[8] = self.board[2]\n new_board[1] = self.board[3]\n new_board[7] = self.board[5]\n new_board[0] = self.board[6]\n new_board[3] = self.board[7]\n new_board[6] = self.board[8]\n else:\n new_board[6] = self.board[0]\n new_board[3] = self.board[1]\n new_board[0] = self.board[2]\n new_board[7] = self.board[3]\n new_board[1] = self.board[5]\n new_board[8] = self.board[6]\n new_board[5] = self.board[7]\n new_board[2] = self.board[8]\n self.board = new_board","def coordinate_migration_between_islands(self):\n island_partners = self._shuffle_island_indices()\n\n for i in range(self._num_islands//2):\n self._shuffle_island_and_swap_pairs(island_partners, i)","def switch_relay(sensor):\n relay_results=select_sql(\"SELECT relay,board FROM sensor_master WHERE sensors = '{0}'\".format(sensor))\n for relay in relay_results:\n relay_no=int(relay[0])\n relay_board=int(relay[1])\n bv4627 = i2c_raw.i2c(relay_board, 1)\n logging.info(\"switching on relay \"+str(relay_no)+\" on board \"+str(relay_board))\n bv4627.write(bytearray([relay_no,1,0,1]))\n time.sleep(.4)\n logging.info(\"switching off relay \"+str(relay_no)+\" on board \"+str(relay_board))\n bv4627.write(bytearray([relay_no,0,0,1]))","def create_pin_port(self, name, xpos=0, ypos=0, rotation=0, top_layer=None, bot_layer=None):\n self.modeler.layers.refresh_all_layers()\n layers = self.modeler.layers.all_signal_layers\n if not top_layer:\n top_layer = layers[0]\n if not bot_layer:\n bot_layer = layers[len(layers) - 1]\n self.modeler.oeditor.CreatePin(\n [\n \"NAME:Contents\",\n [\"NAME:Port\", \"Name:=\", name],\n \"ReferencedPadstack:=\",\n \"Padstacks:NoPad SMT East\",\n \"vposition:=\",\n [\"x:=\", str(xpos) + self.modeler.model_units, \"y:=\", str(ypos) + self.modeler.model_units],\n \"vrotation:=\",\n [str(rotation) + \"deg\"],\n \"overrides hole:=\",\n False,\n \"hole diameter:=\",\n [\"0mm\"],\n \"Pin:=\",\n True,\n \"highest_layer:=\",\n top_layer,\n \"lowest_layer:=\",\n bot_layer,\n ]\n )\n return True","def rotateBoard(self, board):\n #board is a list of boolean value to show the position of \"X\"\n return [board[6], board[3], board[0], board[7], board[4], board[1], board[8],\\\n board[5], board[2]]","def get_port_direction(self, port):\n if port == 1:\n self.__port_b_direction = self.__bus.read_byte_data(\n self.__ioaddress, self.IODIRB)\n return self.__port_b_direction\n else:\n self.__port_a_direction = self.__bus.read_byte_data(\n self.__ioaddress, self.IODIRA)\n return self.__port_a_direction\n return","def read_rotor(self):\n self.sig_a = self.pin_a.read_digital()\n self.sig_b = self.pin_b.read_digital()\n # catch the rising edge of A\n if self.sig_a and not self.old_sig_a:\n # if b is also high, clockwise\n if self.sig_b:\n self.x += 1\n\n else:\n self.x -= 1\n if self.x > 9:\n self.x = 0\n elif self.x < 0:\n self.x = 9\n self.old_sig_a = self.sig_a\n return self.x","def set_port_direction(self, port, direction):\n\n if port == 1:\n self.__bus.write_byte_data(\n self.__ioaddress, self.IODIRB, direction)\n self.__port_b_direction = direction\n else:\n self.__bus.write_byte_data(\n self.__ioaddress, self.IODIRA, direction)\n self.__port_a_direction = direction\n return","def mirror_horiz(pixels):\n copy = blank_image(len(pixels), len(pixels[0])) \n for r in range(len(pixels)):\n for c in range(len(pixels[0])):\n copy[r][c] = pixels[r][c]\n a = len(pixels[0])//2\n for r in range(len(pixels)):\n for c in range(a, len(pixels[0])):\n copy[r][c] = copy[r][-c-1]\n return copy","def mirrorcross(component):\n a,b,c = component()\n d,e,f = component()\n d.reverse()\n e.reverse()\n f.reverse()\n return b+f+c+e,d+a","def pin_pulldown(self, pin):\n port_num = self._convert_pin_port(pin)\n gpio.pullup(port_num, gpio.PULLDOWN)","def __init__(self, pinForward, pinBackward, pinControl):\n\n self.pinForward = pinForward\n self.pinBackward = pinBackward\n self.pinControl = pinControl\n GPIO.setup(self.pinForward, GPIO.OUT)\n GPIO.setup(self.pinBackward, GPIO.OUT)\n GPIO.setup(self.pinControl, GPIO.OUT)\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\n self.pwm_forward.start(0)\n self.pwm_backward.start(0)\n GPIO.output(self.pinControl,GPIO.HIGH)","def pin_toggle(self, pin):\n port_num = self._convert_pin_port(pin)\n if port_num:\n port_state = gpio.HIGH\n if gpio.input(port_num) == gpio.HIGH:\n port_state = gpio.LOW\n gpio.setcfg(port_num, gpio.OUTPUT)\n gpio.output(port_num, port_state)","def mirrorPair(N,srcdist=89.61e3+1.5e3,primalign=np.zeros(6),\\\n secalign=np.zeros(6),rrays=False,f=None,\\\n plist=[[0],[0],[0]],hlist=[[0],[0],[0]]):\n #Establish subannulus of rays\n rays = sources.subannulus(220.,221.,100./220.,N,zhat=-1.)\n #Transform to node position\n tran.transform(rays,220,0,0,0,0,0)\n #Set up finite source distance\n raydist = sqrt(srcdist**2+rays[1]**2+rays[2]**2)\n rays[4] = rays[1]/raydist\n rays[5] = rays[2]/raydist\n rays[6] = -sqrt(1.-rays[4]**2-rays[5]**2)\n\n #Place mirror pair\n coords = [tran.tr.identity_matrix()]*4\n tran.transform(rays,-220+conic.primrad(8450.,220.,8400.),0,50.,0,0,0,\\\n coords=coords)\n tran.transform(rays,*primalign,coords=coords)\n tran.transform(rays,-conic.primrad(8450.,220.,8400.),0,-8450.,0,0,0,\\\n coords=coords)\n## surf.wolterprimary(rays,220.,8400.)\n surf.primaryLL(rays,220.,8400.,8500.,8400.,100./220,*plist)\n rays = tran.vignette(rays,ind=np.logical_and(rays[3]<8500.,\\\n rays[3]>8400.))\n tran.reflect(rays)\n #Place secondary in primary's reference frame\n tran.transform(rays,conic.secrad(8350.,220.,8400.),0,8350.,0,0,0,\\\n coords=coords)\n tran.transform(rays,*secalign,coords=coords)\n tran.itransform(rays,conic.secrad(8350.,220.,8400.),0,8350.,0,0,0,\\\n coords=coords)\n## surf.woltersecondary(rays,220.,8400.)\n surf.secondaryLL(rays,220.,8400.,1.,8400.,8300.,100./220,*hlist)\n rays = tran.vignette(rays,ind=np.logical_and(rays[3]<8400.,\\\n rays[3]>8300.))\n tran.reflect(rays)\n\n #Go back to nominal node reference frame and down to focus\n rays = tran.applyT(rays,coords,inverse=True)\n\n if f is None:\n f = -surf.focusI(rays)\n print f\n else:\n tran.transform(rays,0,0,-f,0,0,0)\n surf.flat(rays)\n\n if rrays is True:\n return rays\n \n return anal.hpd(rays)/f * 180/np.pi * 60.**2, \\\n airnp.mean(rays[1]), np.mean(rays[2])","def change_port( self ):\n # disconnect and delete controller\n self.delete_controller()\n \n # update port\n self.update_port()","def pin_pullclear(self, pin):\n port_num = self._convert_pin_port(pin)\n if port_num:\n gpio.pullup(port_num, gpio.PULLNONE)","def _post(self, which_port, msg):\n return _spacegrant_swig.invert_bit_sptr__post(self, which_port, msg)","def __init__(self, pin: int | Pin, /):","def __init__(self, pinForward, pinBackward, pinControlStraight,pinLeft, pinRight, pinControlSteering):\n\n self.pinForward = pinForward\n self.pinBackward = pinBackward\n self.pinControlStraight = pinControlStraight\n self.pinLeft = pinLeft\n self.pinRight = pinRight\n self.pinControlSteering = pinControlSteering\n GPIO.setup(self.pinForward, GPIO.OUT)\n GPIO.setup(self.pinBackward, GPIO.OUT)\n GPIO.setup(self.pinControlStraight, GPIO.OUT)\n\n GPIO.setup(self.pinLeft, GPIO.OUT)\n GPIO.setup(self.pinRight, GPIO.OUT)\n GPIO.setup(self.pinControlSteering, GPIO.OUT)\n\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\n self.pwm_forward.start(0)\n self.pwm_backward.start(0)\n\n self.pwm_left = GPIO.PWM(self.pinLeft, 100)\n self.pwm_right = GPIO.PWM(self.pinRight, 100)\n self.pwm_left.start(0)\n self.pwm_right.start(0)\n\n GPIO.output(self.pinControlStraight,GPIO.HIGH) \n GPIO.output(self.pinControlSteering,GPIO.HIGH)","def get_direction_matrix(self) -> int:","def map_bidi(self, src_port, dst_port, command_logger=None):\r\n\r\n #Isolate source and destination port numbers from list provided by Cloudshell\r\n source = src_port[2]\r\n dest = dst_port[2]\r\n #Define URI to set rules via REST\r\n uri = 'http://' + self.address + '/rest/rules?'\r\n #Define rule names for the Packetmaster\r\n rulenameA = source + ' to ' + dest\r\n rulenameB = dest + ' to ' + source\r\n #Create the parameters for each rule to be added to the Packetmaster\r\n paramsA = {'name': rulenameA,\r\n 'priority': 32768,\r\n 'match[in_port]': source,\r\n 'actions': dest}\r\n paramsB = {'name': rulenameB,\r\n 'priority': 32768,\r\n 'match[in_port]': dest,\r\n 'actions': source}\r\n #Make REST post requests for each rule to be created\r\n try:\r\n responseA = requests.post(uri, data=paramsA, auth=(self.username, self.password))\r\n responseB = requests.post(uri, data=paramsB, auth=(self.username, self.password))\r\n except ConnectionError as e:\r\n raise e","def update_voutput_pins(self):\n if not pfio:\n raise Exception(\n \"Looks like some sloppy programmer (probably Tom Preston...) \" \\\n \"is trying to update the virtual output pins when the PiFace \" \\\n \"isn't connected. Make sure you check for the pfio before calling \" \\\n \"the update_voutput_pins method. kthxbai.\")\n\n output_bit_map = pfio.read_output()\n for i in range(len(self.output_pins)):\n # updating inner value so that we don't do more SPI reads\n self.output_pins[i]._value = (output_bit_map >> i) & 1 \n\n self.queue_draw()","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result\n\n\n # isAngleChanged = True\n # pastAngle = Current_Coord['ang']\n # resetStates()\n # # temp\n # angle = 0\n # while current_mode == mode['Mapping']:\n # updateCurrCordinate(distance, angle)\n # # needs a way to keep track if the distance and the angle has changed!!\n # # if angle is changed the first time; add onto the trace.\n # if angle != pastAngle:\n # if not isAngleChanged:\n # addCurrToParameter()\n # isAngleChanged = 1\n # pastAngle = angle\n # # Has stopped rotating and back to moving.\n # if isAngleChanged and distance != 0:\n # isAngleChanged = 0\n # # when it exists the while loop == the bot has stopped. adding stopping point\n # # into the list\n # addCurrToParameter()","def mirror_points_point(points, mirror):\n return [mirror_point_point(point, mirror) for point in points]","def reverse_matrix(self):\n return SWAP.matrix @ self.matrix @ SWAP.matrix","def patch_ports(cls, pair):\n if pair[0] in ('remote_port', 'local_port'):\n return pair[0], pair[1] and int(pair[1]) or None\n return pair","def opposite(self):\n if self.direction == 8: return Direction(8)\n n = self.direction + 4\n if n >= 8: n -= 8\n return Direction(n)","def portpreserveparity(self, portpreserveparity) :\n\t\ttry :\n\t\t\tself._portpreserveparity = portpreserveparity\n\t\texcept Exception as e:\n\t\t\traise e","def __init__(__self__, *,\n from_port: pulumi.Input[int],\n to_port: pulumi.Input[int]):\n pulumi.set(__self__, \"from_port\", from_port)\n pulumi.set(__self__, \"to_port\", to_port)","def rotate(tile, n):\n return 0b1111 & (tile << n | tile >> (4 - n))","def pswitchoff(chan) :\n s.phaseSwitching(False, chan)","def reverse(self):\n self.left_motor.reverse()\n self.right_motor.reverse()","def write( self, value ) -> None:\n if value:\n self._slave.write( invert_bits( 0, self._slave.nr_of_pins ) )\n else:\n self._slave.write( 0 )","def pinModule(self, state):\n\n pass"],"string":"[\n \"def op_mirror():\\n mir = np.array([[1, 0, 0, 0],\\n [0, 1, 0, 0],\\n [0, 0, -1, 0],\\n [0, 0, 0, -1]])\\n return mir\",\n \"def as_pin_out( self ):\\n return _pin_out_from_port_out( self.as_port_out() )\",\n \"def rotate(self):\\n\\n self.pins = self.pins[1:] + list(self.pins[0])\\n self.mapping = self.mapping[1:] + list(self.mapping[0])\",\n \"def mirror(self):\\n return RequirePort(self)\",\n \"def port_revert(switch, port):\\n print client.port.port_revert(switch, port)\",\n \"def invert_pin(self, pin, polarity):\\n\\n pin = pin - 1\\n if pin < 8:\\n self.__port_a_polarity = self.__helper.updatebyte(\\n self.__port_a_polarity,\\n pin,\\n polarity)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IPOLA, self.__port_a_polarity)\\n else:\\n self.__port_b_polarity = self.__helper.updatebyte(\\n self.__port_b_polarity,\\n pin - 8,\\n polarity)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IPOLB, self.__port_b_polarity)\\n return\",\n \"def mirror(to='IN'):\\n to = to.strip().upper()\\n if (to==\\\"OUT\\\"):\\n opticalcoupler.MoveMirror(0)\\n logger.info('Mirror: '+to)\\n camera.status.mirror = 'OUT'\\n elif (to==\\\"IN\\\"):\\n opticalcoupler.MoveMirror(opticalcoupler.MIRROR_IN)\\n logger.info('Mirror: '+to)\\n camera.status.mirror = 'IN'\\n else:\\n logger.error(\\\"Usage: 'mirror IN' or 'mirror OUT'\\\")\",\n \"def mirror(self):\\n return ProvidePort(self)\",\n \"def invert_port(self, port, polarity):\\n\\n if port == 1:\\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLB, polarity)\\n self.__port_b_polarity = polarity\\n else:\\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLA, polarity)\\n self.__port_a_polarity = polarity\\n return\",\n \"def __init__(self, pin_obj: Pin, invert: bool = False):\",\n \"def turn_off(self):\\n self.set_pin(0, -1)\\n self.set_pin(1, -1)\\n self.set_pin(2, -1)\",\n \"def drive_leds():\\n pins.D4.next = rotator[3] == 1\\n pins.D3.next = rotator[2] == 1\\n pins.D2.next = rotator[1] == 1\\n pins.D1.next = rotator[0] == 1\",\n \"def mirror(self):\\n self.__mirror = not self.__mirror\",\n \"def mirror(self):\\n for l in range(self.numRows):\\n mirrorGrid = []\\n for l in range(self.numCols):\\n row = self.grid[l][::-1]\\n mirrorGrid.append(row)\\n return mirrorGrid\",\n \"def set_pin_direction(self, pin, direction):\\n pin = pin - 1\\n if pin < 8:\\n self.__port_a_direction = self.__helper.updatebyte(\\n self.__port_a_direction, pin, direction)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IODIRA, self.__port_a_direction)\\n else:\\n self.__port_b_direction = self.__helper.updatebyte(\\n self.__port_b_direction, pin - 8, direction)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IODIRB, self.__port_b_direction)\\n return\",\n \"def lr_flip(self):\\n for g in self.grid:\\n g.reverse()\",\n \"def mirror(img):\\n return img[:, ::-1]\",\n \"def out_aux_port(self, port):\\n return self.auxout[port - 1]\",\n \"def mirror_y(board):\\n new_board = board[:]\\n new_board.reverse()\\n return new_board\",\n \"def message_ports_out(self):\\n return _spacegrant_swig.invert_bit_sptr_message_ports_out(self)\",\n \"def invert(self):\\n return Rubik2DBoard(\\n rows=self.rows, cols=self.cols,\\n data=tuple([tuple([0 if cell == 1 else 1 for cell in row]) for row in self.faces]),\\n prior_moves=self.moves)\",\n \"def _set_unconnected_ports(self):\\n for name, ip in self._ips.items():\\n count = 0\\n inst_args = getattr(self, name)\\n ports = ip.get_ports()\\n for port in ports:\\n full_name = (port_direction_to_prefix(port.direction)\\n + port.name)\\n if full_name not in inst_args.keys():\\n sig = Signal(len(port), name=full_name)\\n inst_args[full_name] = sig\\n count += 1\",\n \"def __invert__(self):\\n return BitBoard(~self.num)\",\n \"def inverted( self ):\\n return self._modifier(\\n self,\\n lambda x: invert_bits( x, self.nr_of_pins )\\n )\",\n \"def initialize_light_pins(pi, pins):\\n for pin in pins:\\n pi.set_mode(pin, pigpio.OUTPUT)\\n pi.set_pull_up_down(pin, pigpio.PUD_DOWN)\",\n \"def message_ports_in(self):\\n return _spacegrant_swig.invert_bit_sptr_message_ports_in(self)\",\n \"def portpreserveparity(self) :\\n\\t\\ttry :\\n\\t\\t\\treturn self._portpreserveparity\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def invert_com_scan_direction(do_invert):\\n if do_invert:\\n send_command(0xC8)\\n else:\\n send_command(0xC0)\",\n \"def port_nic():\",\n \"def setAsMirror(self, mirrorNp):\\r\\n mirrorNp.setTexture( self.mirrorBuffer.getTexture(), 1 )\",\n \"def pin(self, name, mn, direction=None, netname=None, params=None):\\n #pin0 = Pin(xy=[[0, 0], [100, 100]], layer=['M1', 'drawing'], netname='net0', master=rect0,\\n # params={'direction': 'input'})\\n xy0 = self.abs2phy[mn[0]]\\n xy1 = self.abs2phy[mn[1]]\\n #_xy = np.array([[xy0[0], xy0[1]], [xy1[0], xy1[1]]])\\n if np.all(xy0 == xy1): # if two points are identical, generate a metal stub on the bottom layer.\\n if (direction == 'vertical') or ((direction is None) and (self.primary_grid == 'vertical')):\\n width = self.vwidth[mn[0][0]]\\n hextension = int(width / 2)\\n vextension = 0\\n layer = self.pin_vlayer[mn[0][0]]\\n else:\\n width = self.hwidth[mn[0][1]]\\n hextension = 0\\n vextension = int(width / 2)\\n layer = self.pin_hlayer[mn[0][1]]\\n else:\\n if (xy0[0] == xy1[0]) or (direction == 'vertical'): # vertical routing\\n width = self.vwidth[mn[0][0]]\\n hextension = int(width / 2)\\n vextension = 0\\n layer = self.pin_vlayer[mn[0][0]]\\n else: # horizontal routing\\n width = self.hwidth[mn[0][1]]\\n hextension = 0\\n vextension = int(width / 2)\\n layer = self.pin_hlayer[mn[0][1]]\\n # TODO: pin.xy differ from tech.py.\\n _xy = np.array([[xy0[0]-hextension, xy0[1]-vextension], [xy1[0]+hextension, xy1[1]+vextension]]) ## need to check\\n p = laygo2.object.physical.Pin(name=name, xy=_xy, layer=layer, netname=netname, params=params)\\n return p\",\n \"def cw_rotate(self):\\n self.grid = [list(x) for x in zip(*self.grid[::-1])]\\n self.find_edges()\",\n \"def reverse_axis(self, x: bool, y: bool, z: bool) -> None:\\n current_directions = self.i2c.read(self.Register.AXIS_MAP_SIGN, 1)[0]\\n if x:\\n current_directions |= (1 << 2)\\n else:\\n current_directions &= ~(1 << 2)\\n if y:\\n current_directions |= (1 << 1)\\n else:\\n current_directions &= ~(1 << 1)\\n if z:\\n current_directions |= (1 << 0)\\n else:\\n current_directions &= ~(1 << 0)\\n self.i2c.write(self.Register.AXIS_MAP_SIGN, current_directions)\",\n \"def reverse(self, lon, lat):\",\n \"def set_pattern(self, pattern):\\n for ir, row in enumerate(pattern):\\n for ic, col in enumerate(row):\\n relay_n = ir*len(row) + ic\\n self.relay.set(relay_n, bool(col))\",\n \"def mirrorImage(self):\\n\\n im = Image.open(self.ActivePhoto)\\n out = im.transpose(PIL.Image.FLIP_LEFT_RIGHT)\\n out.save(self.ActivePhoto)\\n self.photo.setPixmap(QtGui.QPixmap(self.ActivePhoto))\\n print (\\\"Flipped image\\\")\",\n \"def inneReverse(board):\\r\\n\\theight = len(board)\\r\\n\\twidth = len(board[0])\\r\\n\\tfor row in range(height):\\r\\n\\t\\tfor col in range(width):\\r\\n\\t\\t\\tif board[row][col] == 1:\\r\\n\\t\\t\\t\\tboard[row][col]=0\\r\\n\\t\\t\\telif board[row][col] == 0:\\r\\n\\t\\t\\t\\tboard[row][col]=1\\r\\n\\treturn board\",\n \"def mirror_x(board):\\n new_board = board[:]\\n for (ix, item) in enumerate(board):\\n new_board[ix] = (len(board) - 1) - item\\n\\n return new_board\",\n \"def _reverseduty(self):\\n if self.ir_pin.duty() == 0:\\n self.ir_pin.duty(512)\\n else:\\n self.ir_pin.duty(0)\",\n \"def mirror_augmentation():\\n return lambda image: ImageOps.mirror(image)\",\n \"def arm_mirror():\\n MOVEMENTS.disable_all_joints()\\n while True:\\n for i in range(3):\\n angle = MOVEMENTS.get_raw_angle(i*2)\\n MOVEMENTS.set_raw_angle(i*2 +1, angle)\\n sleep(0.01)\",\n \"def upsidedownmirror(self):\\n for l in range(self.numRows):\\n upsideDownGrid = []\\n for l in range(self.numCols-1,-1,-1):\\n upsideDownGrid.append(self.grid[l][::-1])\\n return upsideDownGrid\",\n \"def __mirror(self, x, y):\\n return (self.width - x - 1, self.height - y - 1)\",\n \"def set_output_pins(gpio_pi, pins):\\n for pin in pins:\\n gpio_pi.set_mode(pin, pigpio.OUTPUT)\",\n \"def opposite(direction):\\n return (direction+2)%4\",\n \"def mirror(self):\\n newRot = [x for x in self.rot]\\n newRot[1] = -newRot[1]\\n newLRot = [x for x in self.lrot]\\n newLRot[1] = -newLRot[1]\\n newLRot[2] = -newLRot[2]\\n return Wall(self.beat, self.dur, -self.r, -self.l, self.d, self.u, newRot, newLRot)\",\n \"def alias_out_port(from_tuple, to_tuple):\\n\\n from_unit, from_port = from_tuple\\n to_unit, to_port = to_tuple\\n\\n to_unit.alias_out_port(from_unit, from_port, to_port)\",\n \"def generate_direction_masks(cols):\\n return list(product('01', repeat=cols))\",\n \"def mirrorTour(tour):\\n M0 = reflection_matrix((0,0,0), (1,0,0))\\n mvps = []\\n for vp in tour:\\n p = vp.camera.position\\n q = vp.camera.orientation\\n print(p,q)\\n mp = np.array((p.x,p.y,p.z,1.0))*np.matrix(M0)\\n mp = np.squeeze(np.asarray(mp))\\n # mq = quaternion_matrix((q.x,q.y,q.z,q.w))*np.matrix(M0)\\n # mq = quaternion_from_matrix(mq)\\n mq = (q.x,-q.y,-q.z,q.w)\\n # print(mp,mq)\\n mvp = ViewPoint(vp.id+10000,mp[0],mp[1],mp[2],mq[0],mq[1],mq[2],mq[3])\\n mvps.append(mvp)\\n return mvps\",\n \"def rotate(self, matrix):\\n n = len(matrix)\\n #转置\\n for i in range(n):\\n for j in range(i+1,n):\\n matrix[i][j],matrix[j][i] = matrix[j][i],matrix[i][j]\\n #镜像\\n mid = n//2\\n for i in range(n):\\n for j in range(mid):\\n matrix[i][j],matrix[i][n-j-1] = matrix[i][n-j-1],matrix[i][j]\",\n \"def flip(self):\",\n \"def inverted_board(self):\\r\\n invert_board = []\\r\\n for line_index in range(len(self.board) - 1, -1,\\r\\n -1): # For each number\\r\\n # (descending) from the max index line\\r\\n # of the matrix (len-1) to 0 (included)\\r\\n\\r\\n invert_board.append(self.board[line_index]) #\\r\\n return invert_board\",\n \"def mirror(f, j=0):\\n return f.per(dmp_mirror_in(f.rep, j, f.lev, f.dom))\",\n \"def rotatable_bonds(self):\\n raise NotImplementedError\",\n \"def pin_off(self, pin):\\n port_num = self._convert_pin_port(pin)\\n if port_num:\\n gpio.setcfg(port_num, gpio.OUTPUT)\\n gpio.output(port_num, gpio.LOW)\",\n \"def mirror_gun (glider_gun):\\n return glider_gun[2] (-1, 0, swap_xy)\",\n \"def pin(self) -> int:\",\n \"def dest(side):\\n return (side - 1) % 3 # cw(side)\",\n \"def reset_directions(directions, dir='from'):\\n if dir == 'from':\\n # reverse the direction, so it plots \\\"to\\\"\\n print(\\\"reversing direction\\\")\\n directions = (directions + 90) * -1\\n elif dir == 'to':\\n # don't reverse, so it plots \\\"to\\\"\\n directions = (directions - 90) * -1\\n else:\\n raise ValueError('dir has to be either \\\"from\\\" or \\\"to\\\"')\\n return directions\",\n \"def motorDirection(self, motorPin, direction):\\n # print \\\"motorPin: \\\", motorPin\\n # print \\\"direction: \\\", direction\\n GPIO.output(motorPin, direction)\",\n \"def flip(self):\\n self._start, self._end = self._end, self._start\",\n \"def set_pin_pullup(self, pin, value):\\n pin = pin - 1\\n if pin < 8:\\n self.__port_a_pullup = self.__helper.updatebyte(\\n self.__port_a_pullup, pin, value)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.GPPUA, self.__port_a_pullup)\\n else:\\n self.__port_b_pullup = self.__helper.updatebyte(\\n self.__port_b_pullup, pin - 8, value)\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.GPPUB, self.__port_b_pullup)\\n return\",\n \"def draw_mirrored_cell(self, pos, color):\\n self.hexes.set_cells(helpfunc.mirror_hexes(pos), color)\",\n \"def __init__(self, pinForward1, pinBackward1,pinForward2, pinBackward2):\\n\\n self.pinForward1 = pinForward1\\n self.pinBackward1 = pinBackward1\\n self.pinForward2 = pinForward2\\n self.pinBackward2 = pinBackward2\\n\\n GPIO.setup(self.pinForward1, GPIO.OUT)\\n GPIO.setup(self.pinBackward1, GPIO.OUT)\\n GPIO.setup(self.pinForward2, GPIO.OUT)\\n GPIO.setup(self.pinBackward2, GPIO.OUT)\\n\\n self.pwm_forward1 = GPIO.PWM(self.pinForward1, 100)\\n self.pwm_backward1 = GPIO.PWM(self.pinBackward1, 100)\\n self.pwm_forward2 = GPIO.PWM(self.pinForward2, 100)\\n self.pwm_backward2 = GPIO.PWM(self.pinBackward2, 100)\\n \\n self.pwm_forward1.start(0)\\n self.pwm_backward1.start(0)\\n self.pwm_forward2.start(0)\\n self.pwm_backward2.start(0)\",\n \"def Port(self) -> int:\",\n \"def TestSlipDualReverse(port,N):\\n\\tfor its in range(N):\\n\\t\\tprint \\\"backward iteration \\\" + str(its)\\n\\t\\tfor i in range(10):\\n\\t\\t\\tIndexS(port,1,-133)\\n\\t\\t\\tIndexS(port,2,400)\\n\\n\\t\\tprint \\\"forward iteration \\\" + str(its)\\n\\t\\tfor i in range(10):\\n\\t\\t\\tIndexS(port,1,133)\\n\\t\\t\\tIndexS(port,2,-400)\",\n \"def rotate(self, direction):\\n new_board = deepcopy(self.board)\\n if direction == Direction.CLOCKWISE:\\n new_board[2] = self.board[0]\\n new_board[5] = self.board[1]\\n new_board[8] = self.board[2]\\n new_board[1] = self.board[3]\\n new_board[7] = self.board[5]\\n new_board[0] = self.board[6]\\n new_board[3] = self.board[7]\\n new_board[6] = self.board[8]\\n else:\\n new_board[6] = self.board[0]\\n new_board[3] = self.board[1]\\n new_board[0] = self.board[2]\\n new_board[7] = self.board[3]\\n new_board[1] = self.board[5]\\n new_board[8] = self.board[6]\\n new_board[5] = self.board[7]\\n new_board[2] = self.board[8]\\n self.board = new_board\",\n \"def coordinate_migration_between_islands(self):\\n island_partners = self._shuffle_island_indices()\\n\\n for i in range(self._num_islands//2):\\n self._shuffle_island_and_swap_pairs(island_partners, i)\",\n \"def switch_relay(sensor):\\n relay_results=select_sql(\\\"SELECT relay,board FROM sensor_master WHERE sensors = '{0}'\\\".format(sensor))\\n for relay in relay_results:\\n relay_no=int(relay[0])\\n relay_board=int(relay[1])\\n bv4627 = i2c_raw.i2c(relay_board, 1)\\n logging.info(\\\"switching on relay \\\"+str(relay_no)+\\\" on board \\\"+str(relay_board))\\n bv4627.write(bytearray([relay_no,1,0,1]))\\n time.sleep(.4)\\n logging.info(\\\"switching off relay \\\"+str(relay_no)+\\\" on board \\\"+str(relay_board))\\n bv4627.write(bytearray([relay_no,0,0,1]))\",\n \"def create_pin_port(self, name, xpos=0, ypos=0, rotation=0, top_layer=None, bot_layer=None):\\n self.modeler.layers.refresh_all_layers()\\n layers = self.modeler.layers.all_signal_layers\\n if not top_layer:\\n top_layer = layers[0]\\n if not bot_layer:\\n bot_layer = layers[len(layers) - 1]\\n self.modeler.oeditor.CreatePin(\\n [\\n \\\"NAME:Contents\\\",\\n [\\\"NAME:Port\\\", \\\"Name:=\\\", name],\\n \\\"ReferencedPadstack:=\\\",\\n \\\"Padstacks:NoPad SMT East\\\",\\n \\\"vposition:=\\\",\\n [\\\"x:=\\\", str(xpos) + self.modeler.model_units, \\\"y:=\\\", str(ypos) + self.modeler.model_units],\\n \\\"vrotation:=\\\",\\n [str(rotation) + \\\"deg\\\"],\\n \\\"overrides hole:=\\\",\\n False,\\n \\\"hole diameter:=\\\",\\n [\\\"0mm\\\"],\\n \\\"Pin:=\\\",\\n True,\\n \\\"highest_layer:=\\\",\\n top_layer,\\n \\\"lowest_layer:=\\\",\\n bot_layer,\\n ]\\n )\\n return True\",\n \"def rotateBoard(self, board):\\n #board is a list of boolean value to show the position of \\\"X\\\"\\n return [board[6], board[3], board[0], board[7], board[4], board[1], board[8],\\\\\\n board[5], board[2]]\",\n \"def get_port_direction(self, port):\\n if port == 1:\\n self.__port_b_direction = self.__bus.read_byte_data(\\n self.__ioaddress, self.IODIRB)\\n return self.__port_b_direction\\n else:\\n self.__port_a_direction = self.__bus.read_byte_data(\\n self.__ioaddress, self.IODIRA)\\n return self.__port_a_direction\\n return\",\n \"def read_rotor(self):\\n self.sig_a = self.pin_a.read_digital()\\n self.sig_b = self.pin_b.read_digital()\\n # catch the rising edge of A\\n if self.sig_a and not self.old_sig_a:\\n # if b is also high, clockwise\\n if self.sig_b:\\n self.x += 1\\n\\n else:\\n self.x -= 1\\n if self.x > 9:\\n self.x = 0\\n elif self.x < 0:\\n self.x = 9\\n self.old_sig_a = self.sig_a\\n return self.x\",\n \"def set_port_direction(self, port, direction):\\n\\n if port == 1:\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IODIRB, direction)\\n self.__port_b_direction = direction\\n else:\\n self.__bus.write_byte_data(\\n self.__ioaddress, self.IODIRA, direction)\\n self.__port_a_direction = direction\\n return\",\n \"def mirror_horiz(pixels):\\n copy = blank_image(len(pixels), len(pixels[0])) \\n for r in range(len(pixels)):\\n for c in range(len(pixels[0])):\\n copy[r][c] = pixels[r][c]\\n a = len(pixels[0])//2\\n for r in range(len(pixels)):\\n for c in range(a, len(pixels[0])):\\n copy[r][c] = copy[r][-c-1]\\n return copy\",\n \"def mirrorcross(component):\\n a,b,c = component()\\n d,e,f = component()\\n d.reverse()\\n e.reverse()\\n f.reverse()\\n return b+f+c+e,d+a\",\n \"def pin_pulldown(self, pin):\\n port_num = self._convert_pin_port(pin)\\n gpio.pullup(port_num, gpio.PULLDOWN)\",\n \"def __init__(self, pinForward, pinBackward, pinControl):\\n\\n self.pinForward = pinForward\\n self.pinBackward = pinBackward\\n self.pinControl = pinControl\\n GPIO.setup(self.pinForward, GPIO.OUT)\\n GPIO.setup(self.pinBackward, GPIO.OUT)\\n GPIO.setup(self.pinControl, GPIO.OUT)\\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\\n self.pwm_forward.start(0)\\n self.pwm_backward.start(0)\\n GPIO.output(self.pinControl,GPIO.HIGH)\",\n \"def pin_toggle(self, pin):\\n port_num = self._convert_pin_port(pin)\\n if port_num:\\n port_state = gpio.HIGH\\n if gpio.input(port_num) == gpio.HIGH:\\n port_state = gpio.LOW\\n gpio.setcfg(port_num, gpio.OUTPUT)\\n gpio.output(port_num, port_state)\",\n \"def mirrorPair(N,srcdist=89.61e3+1.5e3,primalign=np.zeros(6),\\\\\\n secalign=np.zeros(6),rrays=False,f=None,\\\\\\n plist=[[0],[0],[0]],hlist=[[0],[0],[0]]):\\n #Establish subannulus of rays\\n rays = sources.subannulus(220.,221.,100./220.,N,zhat=-1.)\\n #Transform to node position\\n tran.transform(rays,220,0,0,0,0,0)\\n #Set up finite source distance\\n raydist = sqrt(srcdist**2+rays[1]**2+rays[2]**2)\\n rays[4] = rays[1]/raydist\\n rays[5] = rays[2]/raydist\\n rays[6] = -sqrt(1.-rays[4]**2-rays[5]**2)\\n\\n #Place mirror pair\\n coords = [tran.tr.identity_matrix()]*4\\n tran.transform(rays,-220+conic.primrad(8450.,220.,8400.),0,50.,0,0,0,\\\\\\n coords=coords)\\n tran.transform(rays,*primalign,coords=coords)\\n tran.transform(rays,-conic.primrad(8450.,220.,8400.),0,-8450.,0,0,0,\\\\\\n coords=coords)\\n## surf.wolterprimary(rays,220.,8400.)\\n surf.primaryLL(rays,220.,8400.,8500.,8400.,100./220,*plist)\\n rays = tran.vignette(rays,ind=np.logical_and(rays[3]<8500.,\\\\\\n rays[3]>8400.))\\n tran.reflect(rays)\\n #Place secondary in primary's reference frame\\n tran.transform(rays,conic.secrad(8350.,220.,8400.),0,8350.,0,0,0,\\\\\\n coords=coords)\\n tran.transform(rays,*secalign,coords=coords)\\n tran.itransform(rays,conic.secrad(8350.,220.,8400.),0,8350.,0,0,0,\\\\\\n coords=coords)\\n## surf.woltersecondary(rays,220.,8400.)\\n surf.secondaryLL(rays,220.,8400.,1.,8400.,8300.,100./220,*hlist)\\n rays = tran.vignette(rays,ind=np.logical_and(rays[3]<8400.,\\\\\\n rays[3]>8300.))\\n tran.reflect(rays)\\n\\n #Go back to nominal node reference frame and down to focus\\n rays = tran.applyT(rays,coords,inverse=True)\\n\\n if f is None:\\n f = -surf.focusI(rays)\\n print f\\n else:\\n tran.transform(rays,0,0,-f,0,0,0)\\n surf.flat(rays)\\n\\n if rrays is True:\\n return rays\\n \\n return anal.hpd(rays)/f * 180/np.pi * 60.**2, \\\\\\n airnp.mean(rays[1]), np.mean(rays[2])\",\n \"def change_port( self ):\\n # disconnect and delete controller\\n self.delete_controller()\\n \\n # update port\\n self.update_port()\",\n \"def pin_pullclear(self, pin):\\n port_num = self._convert_pin_port(pin)\\n if port_num:\\n gpio.pullup(port_num, gpio.PULLNONE)\",\n \"def _post(self, which_port, msg):\\n return _spacegrant_swig.invert_bit_sptr__post(self, which_port, msg)\",\n \"def __init__(self, pin: int | Pin, /):\",\n \"def __init__(self, pinForward, pinBackward, pinControlStraight,pinLeft, pinRight, pinControlSteering):\\n\\n self.pinForward = pinForward\\n self.pinBackward = pinBackward\\n self.pinControlStraight = pinControlStraight\\n self.pinLeft = pinLeft\\n self.pinRight = pinRight\\n self.pinControlSteering = pinControlSteering\\n GPIO.setup(self.pinForward, GPIO.OUT)\\n GPIO.setup(self.pinBackward, GPIO.OUT)\\n GPIO.setup(self.pinControlStraight, GPIO.OUT)\\n\\n GPIO.setup(self.pinLeft, GPIO.OUT)\\n GPIO.setup(self.pinRight, GPIO.OUT)\\n GPIO.setup(self.pinControlSteering, GPIO.OUT)\\n\\n self.pwm_forward = GPIO.PWM(self.pinForward, 100)\\n self.pwm_backward = GPIO.PWM(self.pinBackward, 100)\\n self.pwm_forward.start(0)\\n self.pwm_backward.start(0)\\n\\n self.pwm_left = GPIO.PWM(self.pinLeft, 100)\\n self.pwm_right = GPIO.PWM(self.pinRight, 100)\\n self.pwm_left.start(0)\\n self.pwm_right.start(0)\\n\\n GPIO.output(self.pinControlStraight,GPIO.HIGH) \\n GPIO.output(self.pinControlSteering,GPIO.HIGH)\",\n \"def get_direction_matrix(self) -> int:\",\n \"def map_bidi(self, src_port, dst_port, command_logger=None):\\r\\n\\r\\n #Isolate source and destination port numbers from list provided by Cloudshell\\r\\n source = src_port[2]\\r\\n dest = dst_port[2]\\r\\n #Define URI to set rules via REST\\r\\n uri = 'http://' + self.address + '/rest/rules?'\\r\\n #Define rule names for the Packetmaster\\r\\n rulenameA = source + ' to ' + dest\\r\\n rulenameB = dest + ' to ' + source\\r\\n #Create the parameters for each rule to be added to the Packetmaster\\r\\n paramsA = {'name': rulenameA,\\r\\n 'priority': 32768,\\r\\n 'match[in_port]': source,\\r\\n 'actions': dest}\\r\\n paramsB = {'name': rulenameB,\\r\\n 'priority': 32768,\\r\\n 'match[in_port]': dest,\\r\\n 'actions': source}\\r\\n #Make REST post requests for each rule to be created\\r\\n try:\\r\\n responseA = requests.post(uri, data=paramsA, auth=(self.username, self.password))\\r\\n responseB = requests.post(uri, data=paramsB, auth=(self.username, self.password))\\r\\n except ConnectionError as e:\\r\\n raise e\",\n \"def update_voutput_pins(self):\\n if not pfio:\\n raise Exception(\\n \\\"Looks like some sloppy programmer (probably Tom Preston...) \\\" \\\\\\n \\\"is trying to update the virtual output pins when the PiFace \\\" \\\\\\n \\\"isn't connected. Make sure you check for the pfio before calling \\\" \\\\\\n \\\"the update_voutput_pins method. kthxbai.\\\")\\n\\n output_bit_map = pfio.read_output()\\n for i in range(len(self.output_pins)):\\n # updating inner value so that we don't do more SPI reads\\n self.output_pins[i]._value = (output_bit_map >> i) & 1 \\n\\n self.queue_draw()\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\\n\\n\\n # isAngleChanged = True\\n # pastAngle = Current_Coord['ang']\\n # resetStates()\\n # # temp\\n # angle = 0\\n # while current_mode == mode['Mapping']:\\n # updateCurrCordinate(distance, angle)\\n # # needs a way to keep track if the distance and the angle has changed!!\\n # # if angle is changed the first time; add onto the trace.\\n # if angle != pastAngle:\\n # if not isAngleChanged:\\n # addCurrToParameter()\\n # isAngleChanged = 1\\n # pastAngle = angle\\n # # Has stopped rotating and back to moving.\\n # if isAngleChanged and distance != 0:\\n # isAngleChanged = 0\\n # # when it exists the while loop == the bot has stopped. adding stopping point\\n # # into the list\\n # addCurrToParameter()\",\n \"def mirror_points_point(points, mirror):\\n return [mirror_point_point(point, mirror) for point in points]\",\n \"def reverse_matrix(self):\\n return SWAP.matrix @ self.matrix @ SWAP.matrix\",\n \"def patch_ports(cls, pair):\\n if pair[0] in ('remote_port', 'local_port'):\\n return pair[0], pair[1] and int(pair[1]) or None\\n return pair\",\n \"def opposite(self):\\n if self.direction == 8: return Direction(8)\\n n = self.direction + 4\\n if n >= 8: n -= 8\\n return Direction(n)\",\n \"def portpreserveparity(self, portpreserveparity) :\\n\\t\\ttry :\\n\\t\\t\\tself._portpreserveparity = portpreserveparity\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def __init__(__self__, *,\\n from_port: pulumi.Input[int],\\n to_port: pulumi.Input[int]):\\n pulumi.set(__self__, \\\"from_port\\\", from_port)\\n pulumi.set(__self__, \\\"to_port\\\", to_port)\",\n \"def rotate(tile, n):\\n return 0b1111 & (tile << n | tile >> (4 - n))\",\n \"def pswitchoff(chan) :\\n s.phaseSwitching(False, chan)\",\n \"def reverse(self):\\n self.left_motor.reverse()\\n self.right_motor.reverse()\",\n \"def write( self, value ) -> None:\\n if value:\\n self._slave.write( invert_bits( 0, self._slave.nr_of_pins ) )\\n else:\\n self._slave.write( 0 )\",\n \"def pinModule(self, state):\\n\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63303953","0.62193274","0.6186834","0.6178602","0.6171273","0.6046138","0.6041167","0.59468573","0.59202063","0.591281","0.5760961","0.57570535","0.57289064","0.57234144","0.5697887","0.5635463","0.5608617","0.55651623","0.55323","0.55020136","0.5475424","0.5407696","0.5406405","0.53787214","0.53436214","0.53346425","0.5326476","0.53236765","0.5307696","0.53026015","0.5289406","0.5272183","0.52713007","0.5264905","0.525382","0.5241281","0.5221384","0.52120334","0.5208464","0.52063054","0.5196474","0.5180513","0.5169217","0.5166977","0.51536","0.5152651","0.5150738","0.51490587","0.51425594","0.5138781","0.5132944","0.5129569","0.5116671","0.5109587","0.5108678","0.5106663","0.5104349","0.5097184","0.50955516","0.5086379","0.50752324","0.5065766","0.5054476","0.5051875","0.5047617","0.50441766","0.5042687","0.50393397","0.5033491","0.50218093","0.50132066","0.500811","0.50072145","0.50017893","0.4999821","0.49969792","0.49847543","0.4980923","0.49721482","0.49716297","0.4969374","0.49597275","0.49571565","0.49523953","0.49517626","0.49416053","0.4935103","0.49321783","0.49278826","0.49200165","0.49179107","0.49151373","0.49126345","0.49081394","0.49033377","0.4902169","0.49017465","0.48918772","0.48840368","0.48814234"],"string":"[\n \"0.63303953\",\n \"0.62193274\",\n \"0.6186834\",\n \"0.6178602\",\n \"0.6171273\",\n \"0.6046138\",\n \"0.6041167\",\n \"0.59468573\",\n \"0.59202063\",\n \"0.591281\",\n \"0.5760961\",\n \"0.57570535\",\n \"0.57289064\",\n \"0.57234144\",\n \"0.5697887\",\n \"0.5635463\",\n \"0.5608617\",\n \"0.55651623\",\n \"0.55323\",\n \"0.55020136\",\n \"0.5475424\",\n \"0.5407696\",\n \"0.5406405\",\n \"0.53787214\",\n \"0.53436214\",\n \"0.53346425\",\n \"0.5326476\",\n \"0.53236765\",\n \"0.5307696\",\n \"0.53026015\",\n \"0.5289406\",\n \"0.5272183\",\n \"0.52713007\",\n \"0.5264905\",\n \"0.525382\",\n \"0.5241281\",\n \"0.5221384\",\n \"0.52120334\",\n \"0.5208464\",\n \"0.52063054\",\n \"0.5196474\",\n \"0.5180513\",\n \"0.5169217\",\n \"0.5166977\",\n \"0.51536\",\n \"0.5152651\",\n \"0.5150738\",\n \"0.51490587\",\n \"0.51425594\",\n \"0.5138781\",\n \"0.5132944\",\n \"0.5129569\",\n \"0.5116671\",\n \"0.5109587\",\n \"0.5108678\",\n \"0.5106663\",\n \"0.5104349\",\n \"0.5097184\",\n \"0.50955516\",\n \"0.5086379\",\n \"0.50752324\",\n \"0.5065766\",\n \"0.5054476\",\n \"0.5051875\",\n \"0.5047617\",\n \"0.50441766\",\n \"0.5042687\",\n \"0.50393397\",\n \"0.5033491\",\n \"0.50218093\",\n \"0.50132066\",\n \"0.500811\",\n \"0.50072145\",\n \"0.50017893\",\n \"0.4999821\",\n \"0.49969792\",\n \"0.49847543\",\n \"0.4980923\",\n \"0.49721482\",\n \"0.49716297\",\n \"0.4969374\",\n \"0.49597275\",\n \"0.49571565\",\n \"0.49523953\",\n \"0.49517626\",\n \"0.49416053\",\n \"0.4935103\",\n \"0.49321783\",\n \"0.49278826\",\n \"0.49200165\",\n \"0.49179107\",\n \"0.49151373\",\n \"0.49126345\",\n \"0.49081394\",\n \"0.49033377\",\n \"0.4902169\",\n \"0.49017465\",\n \"0.48918772\",\n \"0.48840368\",\n \"0.48814234\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6741525"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":86099,"cells":{"query":{"kind":"string","value":"read and combine the pins that make up the port"},"document":{"kind":"string","value":"def read( self ) -> int:\n\n if self._slave is not None:\n return self._filter( self._slave.read() )\n\n else:\n result = 0\n for pin in self._pins[ :: -1 ]:\n result = result << 1\n if pin.read():\n result |= 0b1\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def add_pins(self):\n\n for bit in range(self.addr_size):\n self.add_pin(\"addr_{0}\".format(bit),\"INPUT\")\n \n self.add_pin(\"wl_en\", \"INPUT\")\n\n for bit in range(self.num_rows):\n self.add_pin(\"wl_{0}\".format(bit),\"OUTPUT\")\n \n self.add_pin(\"vdd\",\"POWER\")\n self.add_pin(\"gnd\",\"GROUND\")","def read_all_rom_ports(self):\n return self.ROM_PORT","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result\n\n\n # isAngleChanged = True\n # pastAngle = Current_Coord['ang']\n # resetStates()\n # # temp\n # angle = 0\n # while current_mode == mode['Mapping']:\n # updateCurrCordinate(distance, angle)\n # # needs a way to keep track if the distance and the angle has changed!!\n # # if angle is changed the first time; add onto the trace.\n # if angle != pastAngle:\n # if not isAngleChanged:\n # addCurrToParameter()\n # isAngleChanged = 1\n # pastAngle = angle\n # # Has stopped rotating and back to moving.\n # if isAngleChanged and distance != 0:\n # isAngleChanged = 0\n # # when it exists the while loop == the bot has stopped. adding stopping point\n # # into the list\n # addCurrToParameter()","def initialize_light_pins(pi, pins):\n for pin in pins:\n pi.set_mode(pin, pigpio.OUTPUT)\n pi.set_pull_up_down(pin, pigpio.PUD_DOWN)","def initialize_pins(self):\n\n for pin_name in self.pin_defs.keys():\n if self.pin_defs[pin_name]['mode'] == 'input':\n self.pin(pin_name).direction = digitalio.Direction.INPUT\n #logging.info('Pin {} set to {}'.format(pin_num, self.pin_defs[pin_num]['mode']))\n\n elif self.pin_defs[pin_name]['mode'] == 'output':\n self.pin(pin_name).switch_to_output(value=self.pin_defs[pin_name]['init'])\n #logging.info('Pin {} set to {}'.format(pin_num, self.pin_defs[pin_num]['mode']))\n\n else:\n logging.error('Error, no direction defined for pin {}, pin_defs: {}'\n .format(pin_name, self.pin_defs[pin_name]))","def activatePinReading(self):\n\n for pin in self.pinsToMeasure:\n arduino.samplePinDuringCapture(self.f, self.pinMap[pin], self.wallClock)","def __status(self, port):\n s = []\n hw = self.device.peripherals[port]\n mode_val = hw.MODER.rd()\n for i in range(16):\n # standard pin name\n pin_name = 'P%s%d' % (port[4:], i)\n # target name\n tgt_name = self.pin2name.get(pin_name, '?')\n # mode for this pin\n mode_name = hw.MODER.fields['MODER%d' % i].field_name(mode_val)\n val_name = ''\n af_name = None\n if mode_name == 'analog':\n mode_name = 'an'\n if mode_name == 'altfunc':\n if i < 8:\n mode_name = 'af%d' % ((hw.AFRL.rd() >> (i << 2)) & 15)\n af_name = hw.AFRL.fields['AFRL%d' % i].field_name(hw.AFRL.rd())\n else:\n mode_name = 'af%d' % ((hw.AFRH.rd() >> ((i - 8) << 2)) & 15)\n af_name = hw.AFRH.fields['AFRH%d' % i].field_name(hw.AFRH.rd())\n elif mode_name == 'output':\n mode_name = 'out(%d)' % self.rd_output(port, i)\n elif mode_name == 'input':\n mode_name = 'in(%d)' % self.rd_input(port, i)\n # combine the target and alternate function name\n if af_name:\n tgt_name += ' (%s)' % af_name\n s.append([pin_name, mode_name, tgt_name])\n return s","def ports(self):\r\n # check connected to chip\r\n if not self._core.is_connected():\r\n raise ka_exceptions.NotConnectedError()\r\n\r\n # check symbols are loaded\r\n self._core.sym.assert_have_symbols()\r\n\r\n # get the symbols we need\r\n READ_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.read_port_offset_addr')\r\n WRITE_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.write_port_offset_addr')\r\n READ_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.read_port_limit_addr')\r\n WRITE_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.write_port_limit_addr')\r\n READ_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.read_port_buffer_size')\r\n WRITE_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.write_port_buffer_size')\r\n\r\n def read_dm(addr):\r\n return self._core.dm[addr]\r\n\r\n # get the read and write offset\r\n read_offset_addr = self._read_var_with_size_check(READ_OFFSET_ADDR.addr, READ_OFFSET_ADDR.size_in_addressable_units)\r\n write_offset_addr = self._read_var_with_size_check(WRITE_OFFSET_ADDR.addr, WRITE_OFFSET_ADDR.size_in_addressable_units)\r\n read_offset = map(read_dm, read_offset_addr)\r\n write_offset = map(read_dm, write_offset_addr)\r\n\r\n # get the read and write limit\r\n read_limit_addr = self._read_var_with_size_check(READ_LIMIT_ADDR.addr, READ_LIMIT_ADDR.size_in_addressable_units)\r\n write_limit_addr = self._read_var_with_size_check(WRITE_LIMIT_ADDR.addr, WRITE_LIMIT_ADDR.size_in_addressable_units)\r\n read_limit = map(read_dm, read_limit_addr)\r\n write_limit = map(read_dm, write_limit_addr)\r\n\r\n # get the port size\r\n read_size = self._read_var_with_size_check(READ_BUFFER_SIZE.addr, READ_BUFFER_SIZE.size_in_addressable_units)\r\n write_size = self._read_var_with_size_check(WRITE_BUFFER_SIZE.addr, WRITE_BUFFER_SIZE.size_in_addressable_units)\r\n # calculate size mask (size-1) for non-zero sizes\r\n read_mask = map(lambda s: s - (s>0), read_size)\r\n write_mask = map(lambda s: s - (s>0), write_size)\r\n\r\n # calculate data/space in port\r\n read_data = map(lambda l,o,m: (l - o) & m, read_limit, read_offset, read_mask)\r\n write_space = map(lambda l,o,m: (l - o) & m - 1, write_limit, write_offset, write_mask)\r\n\r\n # read port configs\r\n READ_CONF_BASE = self._core.sym.constfind('$READ_PORT0_CONFIG').value\r\n WRITE_CONF_BASE = self._core.sym.constfind('$WRITE_PORT0_CONFIG').value\r\n read_conf = self._read_var_with_size_check(READ_CONF_BASE, READ_OFFSET_ADDR.size_in_addressable_units)\r\n write_conf = self._read_var_with_size_check(WRITE_CONF_BASE, WRITE_OFFSET_ADDR.size_in_addressable_units)\r\n\r\n # extract data size (in octets) from config\r\n read_data_size = map(lambda c: (c & 0x3) + 1, read_conf)\r\n write_space_size = map(lambda c: (c & 0x3) + 1, write_conf)\r\n\r\n # decode configs into strings\r\n read_conf_str = map(lambda c,s: (\"8\" if s==1 else (\"16\" if s==2 else (\"24\" if s==3 else \"??\"))) + \"-bit, \" \\\r\n + (\"Big Endian\" if (c & 0x4) else \"Little Endian\") + \", \" \\\r\n + (\"No Sign Ext\" if (c & 0x8) else \"Sign Ext\" ), \\\r\n read_conf, read_data_size)\r\n write_conf_str = map(lambda c,s: (\"8\" if s==1 else (\"16\" if s==2 else (\"24\" if s==3 else \"??\"))) + \"-bit, \" \\\r\n + (\"Big Endian\" if (c & 0x4) else \"Little Endian\") + \", \" \\\r\n + (\"Saturate\" if (c & 0x8) else \"No Saturate\"), \\\r\n write_conf, write_space_size)\r\n\r\n # print information\r\n print \"Read ports:\\n Port Status Offset Address Size(Bytes) Data Config\"\r\n for i in range(len(read_offset_addr)):\r\n if read_offset_addr[i]:\r\n print \" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\" % \\\r\n (i, read_offset_addr[i], read_offset_addr[i], read_size[i], read_size[i], read_data[i]/read_data_size[i], read_conf_str[i])\r\n else:\r\n print \" %2i Disabled\" % i\r\n\r\n print \"Write ports:\\n Port Status Offset Address Size(Bytes) Space Config\"\r\n for i in range(len(write_offset_addr)):\r\n if write_offset_addr[i]:\r\n print \" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\" % \\\r\n (i, write_offset_addr[i], write_offset_addr[i], write_size[i], write_size[i], write_space[i]/write_space_size[i], write_conf_str[i])\r\n else:\r\n print \" %2i Disabled\" % i","def get_port_list(self):\r\n self.ports = Manager().dict()\r\n self.value = Manager().dict()\r\n self.sensors = dict()\r\n for p in self.device.ports['input']:\r\n if p.enabled:\r\n self.ports[p.number] = p\r\n self.value[p.number] = 'Connexion à la carte'\r\n self.sensors[p.number] = Sensor.get(p._type)","def set_in_pins(pins):\n for pin in pins:\n GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN)\n\tGPIO.setup(LEDPIN, GPIO.OUT)\n\tGPIO.output(LEDPIN, GPIO.LOW)","def servo_read_all(self):\n msg = b'\\x25\\x00'\n parameter_len = 16\n ans = self.__bt.read(msg, parameter_len)\n if ans is not None:\n return [x for x in ans]\n return None","def init_pins(self):\n for pin in self.SENSOR_PINS:\n self.sensorValues.append(0)\n self.calibratedMax.append(0)\n self.calibratedMin.append(0)\n self.wp.pullUpDnControl(pin, self.wp.PUD_DOWN)\n self.wp.pinMode(self.LEDON_PIN, self.wp.OUTPUT)","def serial_ports():\n# ports = glob.glob('/dev/tty[A-Za-z]*')\n ports = glob.glob('/dev/ttyACM*')\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (serial.SerialException) as e:\n print(e)\n return result","def set_output_pins(gpio_pi, pins):\n for pin in pins:\n gpio_pi.set_mode(pin, pigpio.OUTPUT)","def analog_read(self, pin_number):\n command = (''.join(('RA', str(pin_number)))).encode()\n self.conn.write(command) \n line_received = self.conn.readline().decode().strip()\n header, value = line_received.split(':') # e.g. A4:1\n if header == ('A'+ str(pin_number)):\n # If header matches\n return int(value)","def setup():\n GPIO.setmode(GPIO.BCM)\n for pin in [config.gpio_pin_p1_stretch,\n config.gpio_pin_p1_serve,\n config.gpio_pin_p2_stretch,\n config.gpio_pin_p2_serve]:\n GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\n\n input_reader_thread = threading.Thread(target=input_reader_worker)\n input_reader_thread.setDaemon(True)\n input_reader_thread.start()","def find_arduino(portsfound):\r\n comPort = 'None'\r\n num_of_connection = len(portsfound)\r\n\r\n for i in range(0, num_of_connection):\r\n port = foundPorts[i]\r\n cnvt_str_port = str(port)\r\n\r\n if 'ttyACM' in cnvt_str_port:\r\n splitPort = cnvt_str_port.split(' ')\r\n comPort = (splitPort[0])\r\n\r\n return comPort","def input_output_config(self):\r\n\t\tif self.io == 0 :\r\n\t\t\tif self.pin == 0 :\r\n\t\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN0)\r\n\t\t\telif self.pin == 1 :\r\n\t\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN1)\r\n\t\t\telif self.pin == 2 :\r\n\t\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN2)\r\n\t\t\telif self.pin == 3 :\r\n\t\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN3)\r\n\t\telif self.io == 1 :\r\n\t\t\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PINX)","def pins(self, toggle=None, low=None, high=None):\n\n if toggle != None:\n val = 0\n for pin in toggle.split(\",\"):\n if not pin in PINS_OUT:\n raise ValueError(\"Invalid output pin '{:}'\".format(pin))\n\n val |= PINS_OUT[pin]\n\n self.write_block(REG_PINS, [val])\n\n if low != None:\n res = self.read_block(REG_PINS, 1)\n val = 0\n for pin in low.split(\",\"):\n if not pin in PINS_OUT:\n raise ValueError(\"Invalid output pin '{:}'\".format(pin))\n\n # Only toggle if already high\n if res[0] & PINS_OUT[pin] > 0:\n val |= PINS_OUT[pin]\n\n if val > 0:\n self.write_block(REG_PINS, [val])\n\n if high != None:\n res = self.read_block(REG_PINS, 1)\n val = 0\n for pin in high.split(\",\"):\n if not pin in PINS_OUT:\n raise ValueError(\"Invalid output pin '{:}'\".format(pin))\n\n # Only toggle if already low\n if res[0] & PINS_OUT[pin] == 0:\n val |= PINS_OUT[pin]\n\n if val > 0:\n self.write_block(REG_PINS, [val])\n\n res = self.read_block(REG_PINS, 1)\n ret = {\n \"input\": {k: bool(res[0] & v) for k, v in PINS_IN.iteritems()},\n \"output\": {k: bool(res[0] & v) for k, v in PINS_OUT.iteritems()}\n }\n\n return ret","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 input_output_config(self):\r\n\t\tif self.io == 0 :\r\n\t\t\tif self.pin == 0 :\r\n\t\t\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PIN0)\r\n\t\t\telif self.pin == 1 :\r\n\t\t\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PIN1)\r\n\t\telif self.io == 1 :\r\n\t\t\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PINX)","def initialize():\n for pin in sorted(OUTPUT_PINS.values()):\n _enable_pin(pin, OUT)\n\n for pin in sorted(INPUT_PINS.values()):\n _enable_pin(pin, IN)","def port_nic():","def rr2_assign_ports():\n print('******* Assigning ports')\n for device in ci_addrs.switches_rr1_12:\n print ('******* Connecting to ', device.get('ip'))\n net_connect = ConnectHandler(**device)\n output_vlan_cp = net_connect.send_config_set(cp_rr2_config_commands)\n print (output_vlan_cp)\n output_vlan_cloud = net_connect.send_config_set(cloud_rr1_config_commands)\n print (output_vlan_cloud)\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\n print (output_vlan_f5)\n net_connect.send_config_set('wr')\n for device in ci_addrs.switches_rr2_12:\n print ('******* Connecting to ', device.get('ip'))\n net_connect = ConnectHandler(**device)\n output_vlan_cp = net_connect.send_config_set(cp_rr2_config_commands)\n print (output_vlan_cp)\n output_vlan_cloud = net_connect.send_config_set(cloud_rr2_config_commands)\n print (output_vlan_cloud)\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\n print (output_vlan_f5)\n net_connect.send_config_set('wr')\n assign_ports_n5k34()","def update_voutput_pins(self):\n if not pfio:\n raise Exception(\n \"Looks like some sloppy programmer (probably Tom Preston...) \" \\\n \"is trying to update the virtual output pins when the PiFace \" \\\n \"isn't connected. Make sure you check for the pfio before calling \" \\\n \"the update_voutput_pins method. kthxbai.\")\n\n output_bit_map = pfio.read_output()\n for i in range(len(self.output_pins)):\n # updating inner value so that we don't do more SPI reads\n self.output_pins[i]._value = (output_bit_map >> i) & 1 \n\n self.queue_draw()","def get_all_port(self, conf, dpid):\n\t\tpass","def setup(self):\n\n for row_pin in keypad_row_pins:\n #Set up row-pins\n self.gpio.setup(row_pin, self.gpio.OUT)\n\n for col_pin in keypad_col_pins:\n #Set up col-pins\n self.gpio.setup(col_pin, self.gpio.IN)","def get_ports(self) -> tuple:\n raise NotImplementedError","def serial_ports():\r\n return list(map(lambda listportinfo: listportinfo.device, list_ports.comports()))","def read_serial(onewire_temperature_c, sensor_mappings, serial_port):\n ser = serial.Serial(serial_port, timeout=60)\n while 1:\n line = ser.readline()\n m = re.match(r'([A-Z0-9]{16}):(-?[0-9.]+)\\n', line.decode('ascii'))\n if m:\n onewire_temperature_c.labels(location=sensor_mappings[m.group(1)]).set(m.group(2))","def read_pin(self, pin):\n value = 0\n pin = pin - 1\n if pin < 8:\n self.__port_a_value = self.__bus.read_byte_data(\n self.__ioaddress, self.GPIOA)\n value = self.__checkbit(self.__port_a_value, pin)\n else:\n pin = pin - 8\n self.__port_b_value = self.__bus.read_byte_data(\n self.__ioaddress, self.GPIOB)\n value = self.__checkbit(self.__port_b_value, pin)\n return value","def setup(self):\n GPIO.setmode(GPIO.BCM)\n for rowp in self.rows:\n GPIO.setup(rowp, GPIO.OUT)\n for colp in self.cols:\n GPIO.setup(colp, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)","def read_port(self, port):\n value = 0\n if port == 1:\n self.__port_b_value = self.__bus.read_byte_data(\n self.__ioaddress, self.GPIOB)\n value = self.__port_b_value\n else:\n self.__port_a_value = self.__bus.read_byte_data(\n self.__ioaddress, self.GPIOA)\n value = self.__port_a_value\n return value","def ext_pins(self, toggle=None, low=None, high=None):\n\n if toggle != None:\n val = 0\n for pin in toggle.split(\",\"):\n if not pin in EXT_PINS_OUT:\n raise ValueError(\"Invalid output extension pin '{:}'\".format(pin))\n\n val |= EXT_PINS_OUT[pin]\n\n self.write_block(REG_EXT_PINS, [val])\n\n if low != None:\n res = self.read_block(REG_EXT_PINS, 1)\n val = 0\n for pin in low.split(\",\"):\n if not pin in EXT_PINS_OUT:\n raise ValueError(\"Invalid output extension pin '{:}'\".format(pin))\n\n # Only toggle if already high\n if res[0] & EXT_PINS_OUT[pin] > 0:\n val |= EXT_PINS_OUT[pin]\n\n if val > 0:\n self.write_block(REG_EXT_PINS, [val])\n\n if high != None:\n res = self.read_block(REG_EXT_PINS, 1)\n val = 0\n for pin in high.split(\",\"):\n if not pin in EXT_PINS_OUT:\n raise ValueError(\"Invalid output extension pin '{:}'\".format(pin))\n\n # Only toggle if already low\n if res[0] & EXT_PINS_OUT[pin] == 0:\n val |= EXT_PINS_OUT[pin]\n\n if val > 0:\n self.write_block(REG_EXT_PINS, [val])\n\n res = self.read_block(REG_EXT_PINS, 1)\n ret = {\n \"input\": {k: bool(res[0] & v) for k, v in EXT_PINS_IN.iteritems()},\n \"output\": {k: bool(res[0] & v) for k, v in EXT_PINS_OUT.iteritems()}\n }\n\n return ret","def testAllRead(self):\n import time,copy\n time.sleep(2)\n to_config = self.config['vdevs']['slave']['icsifaces'][0]\n from_config = self.config['vdevs']['master']['clientifaces'][0]\n points = self.config['vdevs']['slave']['points']\n client = ModbusRTU(to_config, points, from_config)\n\n\n pts = copy.deepcopy(self.config['vdevs']['slave']['points'])\n for i in xrange(50):\n ptnames = [ pt['name'] for pt in pts ]\n reply = client.readPoints(ptnames)\n #print \"Reply: \", reply\n for pt in ptnames:\n value = filter(lambda x: x['name']==pt, pts)[0]['value']\n #assert value == reply[ptnames.index(pt)]\n received = reply[ptnames.index(pt)]\n if not value == received: \n print pt, ' was %s but should be %s'%(str(received),str(value))","def read_bytes(self, ctrl_pin):\n try:\n '''\n ctrl_pin1.value(0)\n time.sleep_ms(2)\n ctrl_pin1.value(1)\n time.sleep_ms(220)\n ctrl_pin1.value(0)\n temp = hspi.read(2)\n ctrl_pin1.value(1)\n '''\n pin_ = self.ctrl_pins[ctrl_pin]\n pin_.value(0)\n time.sleep_ms(2)\n pin_.value(1)\n time.sleep_ms(220)\n pin_.value(0)\n temp = self.hspi.read(2)\n pin_.value(1)\n except KeyError:\n print('requested pin not defined')\n temp = None\n return temp","def init_pins(self, h_p, m_p, s_p):\r\n for seconds_pin in s_p:\r\n self.second_leds.append(LED(seconds_pin))\r\n for minute_pin in m_p:\r\n self.minute_leds.append(LED(minute_pin))\r\n for hour_pin in h_p:\r\n self.hour_leds.append(LED(hour_pin))\r\n return","def look_for_available_ports():\n available_ports = glob.glob('/dev/ttyACM*')\n print(\"Available porst: \")\n print(available_ports)\n\n return available_ports","def port_setup(robot_name, num_cameras):\n\tglobal local_in_port\n\tglobal local_out_port\n\tglobal local_GPS_port\n\tglobal local_Dest_port\n\n\tglobal local_in_port_name\n\tglobal local_out_port_name\n\tglobal local_GPS_port_name\n\tglobal local_Dest_port_name\n\n\tglobal local_Radio_in_port\n\tglobal local_Radio_out_port\n\n\tglobal ors_in_port_name\n\tglobal ors_out_port_name\n\tglobal ors_GPS_port_name\n\tglobal ors_Dest_port_name\n\tglobal ors_Radio_in_port_name\n\tglobal ors_Radio_out_port_name\n\n\t# Define the names for all the ports\n\tport_prefix = \"/ors/robots/\" + robot_name + \"/\"\n\tlocal_port_prefix = \"/atrv_client/\" + robot_name + \"/\"\n\tview_prefix = \"/img/\" + robot_name + \"/\"\n\n\tors_in_port_name = port_prefix + \"in\"\n\tors_out_port_name = port_prefix + \"out\"\n\n\tors_Dest_port_name = port_prefix + \"Motion_Controller/in\"\n\tors_GPS_port_name = port_prefix + \"GPS/out\"\n\n\tors_Radio_out_port_name = port_prefix + \"Radio/out\"\n\tors_Radio_in_port_name = port_prefix + \"Radio/in\"\n\n\tlocal_in_port_name = local_port_prefix + \"in/\"\n\tlocal_out_port_name = local_port_prefix + \"out/\"\n\n\tlocal_GPS_port_name = local_port_prefix + \"GPS/in/\"\n\tlocal_Dest_port_name = local_port_prefix + \"Motion_Controller/out/\"\n\n\tlocal_Radio_in_port_name = local_port_prefix + \"Radio/in\"\n\tlocal_Radio_out_port_name = local_port_prefix + \"Radio/out\"\n\n\t# Start the yarp network connection\n\tyarp.Network.init()\n\n\t# Open the client ports\n\tlocal_in_port = yarp.BufferedPortBottle()\n\tlocal_in_port.open(local_in_port_name)\n\tlocal_out_port = yarp.BufferedPortBottle()\n\tlocal_out_port.open(local_out_port_name)\n\n\tlocal_GPS_port = yarp.BufferedPortBottle()\n\tlocal_GPS_port.open(local_GPS_port_name)\n\tlocal_Dest_port = yarp.BufferedPortBottle()\n\tlocal_Dest_port.open(local_Dest_port_name)\n\n\tlocal_Radio_out_port = yarp.BufferedPortBottle()\n\tlocal_Radio_out_port.open(local_Radio_out_port_name)\n\tlocal_Radio_in_port = yarp.BufferedPortBottle()\n\tlocal_Radio_in_port.open(local_Radio_in_port_name)\n\n\t# Connect the client ports to the simulator ports\n\tyarp.Network.connect (local_out_port_name, ors_in_port_name)\n\tyarp.Network.connect (ors_out_port_name, local_in_port_name)\n\n\tyarp.Network.connect (ors_GPS_port_name, local_GPS_port_name)\n\tyarp.Network.connect (local_Dest_port_name, ors_Dest_port_name)\n\n\tyarp.Network.connect (local_Radio_out_port_name, ors_Radio_in_port_name)\n\tyarp.Network.connect (ors_Radio_out_port_name, local_Radio_in_port_name)\n\n\n\t# Connect the cameras to yarpview windows\n\tprint (\" * Initializing yarpview windows.\")\n\tfor id in range(int(num_cameras)):\n\t\t# Build the name of the camera\n\t\tcamera_name = \"Camera{0}\".format(id+1)\n\n\t\t# Prepare the ports to be used\n\t\timg_view_port = view_prefix + camera_name\n\t\tatrv_camera_port = port_prefix + camera_name\n\n\t\tyarp.Network.connect (atrv_camera_port, img_view_port)","def rr1_assign_ports():\n print('******* Assigning ports')\n for device in ci_addrs.switches_rr1_12:\n print ('******* Connecting to ', device.get('ip'))\n net_connect = ConnectHandler(**device)\n output_vlan_cp = net_connect.send_config_set(cp_rr1_config_commands)\n print (output_vlan_cp)\n output_vlan_cloud = net_connect.send_config_set(cloud_rr1_config_commands)\n print (output_vlan_cloud)\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\n print (output_vlan_f5)\n net_connect.send_config_set('wr')\n for device in ci_addrs.switches_rr2_12:\n print ('******* Connecting to ', device.get('ip'))\n net_connect = ConnectHandler(**device)\n output_vlan_cp = net_connect.send_config_set(cp_rr1_config_commands)\n print (output_vlan_cp)\n output_vlan_cloud = net_connect.send_config_set(cloud_rr2_config_commands)\n print (output_vlan_cloud)\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\n print (output_vlan_f5)\n net_connect.send_config_set('wr') \n assign_ports_n5k34()","def __init__(self, pads):\n mfioCommon.__init__(self, pads)\n\n mfio_width = len(pads)\n #\n mfio_o = Signal(mfio_width)\n mfio_oe = Signal(mfio_width)\n mfio_i = Signal(mfio_width)\n # create single pin tristate buffers\n for b in range(mfio_width):\n self.submodules += mfioSinglePin(pads, b, mfio_i[b], mfio_o[b], mfio_oe[b]) \t\n\n # Wishbone \n self.bus = bus = wishbone.Interface()\n\n #\n sel = Signal(mfio_width)\n inbit = Signal(1)\n\n # todo: dynamic address width calc to optimize the decode logic\n addr_width = 12\n # 1024 IO max\n seladr = Signal(10)\n\n # 10 bits of address = 1024 pins max\n self.comb += seladr.eq(self.bus.adr[:10]) \n \n # address decoder\n for b in range(mfio_width):\n self.comb += sel[b].eq(seladr == b)\n\n self.comb += inbit.eq( (mfio_i & sel) != 0 )\n\n # Read bit\n rdbus = Signal(32)\n self.comb += [\n rdbus[0].eq(inbit),\n bus.dat_r.eq(rdbus)\n ]\t\n\n # process output \n outbit = Signal(1)\n oebit = Signal(1)\n wren = Signal(1)\n\n # PINAPI 1.0 compatible: 0 = drive 0, 1 drive 1, 3 = HiZ\n self.comb += outbit.eq( bus.dat_w[0] )\n self.comb += oebit.eq ( ~bus.dat_w[1] )\n\n # write enable\n self.comb += wren.eq(self.bus.stb & self.bus.cyc & self.bus.we) \n\n for b in range(mfio_width):\n self.sync += If(wren & sel[b], mfio_o[b].eq(outbit), mfio_oe[b].eq(oebit) )\n\n seq = [\n (1, [bus.ack.eq(1)]), #\n (1, [bus.ack.eq(0)]), #\n (0, []),\n ]\n \n t, tseq = 0, []\n for dt, a in seq:\n tseq.append((t, a))\n t += dt\n\n self.sync += timeline(bus.cyc & bus.stb, tseq)","def Port(self) -> int:","def get_port_pullups(self, port):\n if port == 1:\n self.__port_b_pullup = self.__bus.read_byte_data(\n self.__ioaddress, self.GPPUB)\n return self.__port_b_pullup\n else:\n self.__port_a_pullup = self.__bus.read_byte_data(\n self.__ioaddress, self.GPPUA)\n return self.__port_a_pullup\n return","def testAllRead(self):\n import time,copy\n time.sleep(2)\n client = ModbusTCP(self.config['vdevs']['slave']['icsifaces'][0],\n self.config['vdevs']['slave']['points']) \n\n pts = copy.deepcopy(self.config['vdevs']['slave']['points'])\n ptnames = [ pt['name'] for pt in pts ]\n reply = client.readPoints(ptnames)\n #print \"Reply: \", reply\n for pt in ptnames:\n value = filter(lambda x: x['name']==pt, pts)[0]['value']\n #assert value == reply[ptnames.index(pt)]\n received = reply[ptnames.index(pt)]\n if not value == received: \n print pt, ' was %s but should be %s'%(str(received),str(value))","def raw_interfaces(self):\n return self._ports","def draw_pins():\n\n pass","def _GetPorts(self):\n ports = []\n for start, end in self.term.destination_port:\n if start == end:\n ports.append(str(start))\n else:\n ports.append('%d-%d' % (start, end))\n return ports","async def assign_serial_port(self, serial_manager):\n #logstring(\"you are now in assign_serial_port\")\n if serial_manager is None:\n return\n\n if serial_manager.CurrentPort is None:\n return\n\n self._clear_stored_response_dictionaries()\n\n self.serial_manager = serial_manager\n self.serial_port = serial_manager.CurrentPort\n #to remove, only used for testing right now\n self.serial_port_name = serial_manager.CurrentPort.com_port\n\n # set the read and write handles\n self.read = self.serial_manager.CurrentPort.read\n self.write = self.serial_manager.CurrentPort.write\n\n self._valid_target_exists = True\n\n\n #keeps a direct reference to the pins\n self._digital_pins_directly = []\n self._analog_pins_directly = []\n\n #and ports\n self._ports_directly = []\n\n # wait for arduino to go through a reset cycle if need be\n logstring(\"Waiting for 2 seconds...\")\n time.sleep(self.arduino_wait)\n #logstring(\"time is up!\")\n #await asyncio.sleep(self.arduino_wait)\n\n # register the get_command method with the event loop\n self.loop = asyncio.get_event_loop()\n\n logstring(\"Setting up Firmata on port {}\".format(self.serial_port.com_port))\n\n # get arduino firmware version and print it\n logstring(\"Checking Firmware version\")\n firmware_version = await self.get_firmware_version()\n logstring(\"Finished checking Firmware version\")\n if not firmware_version:\n logerr('*** Firmware Version retrieval timed out. ***')\n logerr('Firmata not found')\n try:\n # attempt to autoload firmata here, if fails again, mark the port as error\n self.disconnect_port_due_to_error()\n return\n except RuntimeError:\n self.disconnect_port_due_to_error()\n return\n except TypeError:\n self.disconnect_port_due_to_error()\n return\n logstring(\"\\nFirmware ID: \" + firmware_version)\n logstring(\"On port {}\".format(self.serial_port_name))\n # get an analog pin map\n\n # try to get an analog report. if it comes back as none - shutdown\n # report = await self.get_analog_map()\n logstring(\"Fetching analog mapping\")\n analogreport = await self.get_analog_map()\n #logstring(\"got analog map\")\n if not analogreport:\n logerr('*** Analog map retrieval timed out. ***')\n logerr('Analog Pin Mapping not found')\n try:\n # attempt to autoload firmata here, if fails again, mark the port as error\n self.disconnect_port_due_to_error()\n return\n except RuntimeError:\n self.disconnect_port_due_to_error()\n return\n except TypeError:\n self.disconnect_port_due_to_error()\n return\n\n capabilityreport = await self.get_capability_report()\n if not capabilityreport:\n logerr('*** Capability Report retrieval timed out. ***')\n logerr('Capability Report not found')\n try:\n # attempt to autoload firmata here, if fails again, mark the port as error\n self.disconnect_port_due_to_error()\n return\n except RuntimeError:\n self.disconnect_port_due_to_error()\n return\n except TypeError:\n self.disconnect_port_due_to_error()\n return\n # custom assemble the pin lists\n pininfo = iter(capabilityreport)\n\n\n self._nested_objects = []\n\n\n for i, analogpinmapping in enumerate(analogreport):\n #set up the data structure that captures data that comes from Firmata\n digital_data = PinData()\n self.digital_pins.append(digital_data)\n HasAnalog = False\n analog_data = PinData()\n self.analog_pins.append(analog_data)\n if analogpinmapping != Constants.IGNORE:\n self.analog_pins_analog_numbering.append(analog_data)\n HasAnalog = True\n #set up the data structure that captures data to be sent to Firmata\n port_num = math.floor(i/8)\n pin_num_within_port = i%8\n HasInput = False\n HasOutput = False\n HasPullup = False\n HasAnalog2 = False\n AnalogResolution = 0\n AnalogPinNum = 127\n HasPWM = False\n PWMResolution = 0\n HasI2C = False\n try:\n nextbyte = next(pininfo)\n while nextbyte != 127: #127 signals the end of the information for a pin\n resolutionbyte = next(pininfo)\n if nextbyte == Constants.INPUT:\n HasInput = True\n if nextbyte == Constants.OUTPUT:\n HasOutput = True\n if nextbyte == Constants.PULLUP:\n HasPullup = True\n if nextbyte == Constants.ANALOG:\n HasAnalog2 = True\n AnalogResolution = resolutionbyte\n AnalogPinNum = analogpinmapping\n if nextbyte == Constants.PWM:\n HasPWM = True,\n PWMResolution=14\n if nextbyte == Constants.SERVO:\n pass\n #nothing to do. we treat it like an OUTPUT\n #resolution is fixed...may do something with this\n #in the future if there are issues with some platform?\n if nextbyte == Constants.I2C:\n HasI2C = True\n nextbyte = next(pininfo)\n except StopIteration:\n pass\n\n if HasAnalog2 != HasAnalog:\n #this really shouldn't happen, but might as well catch it anyway\n raise Exception(\"The Analog Pin Map disagrees with the Capabilty Report as to whether pin {} is an analog pin\".format(i))\n\n #this sets the pin number 0-7 within each port\n if pin_num_within_port == 0: #Yay, new port, create it:\n current_port = Port(\"Port {}\".format(port_num),\n port_num)\n self._nested_objects.append(current_port)\n self._ports_directly.append(current_port)\n\n newpin = Pin(ID = \"Pin {} of Port {} hasanalog = {}\".format(pin_num_within_port,\n port_num, HasAnalog),\n PinNum = i, HasInput=HasInput,\n HasPullup=HasPullup, HasOutput=HasOutput,\n HasAnalog=HasAnalog, AnalogPinNum=analogpinmapping,\n AnalogResolution=AnalogResolution, HasPWM=HasPWM,\n PWMResolution=PWMResolution, HasI2C=HasI2C)\n current_port.pins.append(newpin)\n self._digital_pins_directly.append(newpin)\n logstring(\"Appending a new pin {} len {}\".format(newpin._ID, len(self._digital_pins_directly)))\n if HasAnalog:\n self._analog_pins_directly.append(newpin)\n\n\n\n logstring('Auto-discovery complete. Found ' + \\\n str(len(self.digital_pins)) + ' Digital Pins and ' + \\\n str(len(self.analog_pins_analog_numbering)) + ' Analog Pins')\n\n self._numpins = len(self.digital_pins)\n self._numports = math.ceil(self._numpins/8)\n\n\n self.KeepAlive = KeepAlive(\"Keep Alive\")\n self._nested_objects.append(self.KeepAlive)\n\n self.Tone = Tone(\"Tone\", self._numpins)\n self._nested_objects.append(self.Tone)\n\n #self.EncoderConfig = EncoderConfig(\"Encoder Config\", self._numpins)\n #self._nested_objects.append(self.EncoderConfig)","def main(self) :\n\n # Close the serial port in case the previous run didn't closed it properly\n self.serialPortDWM1001_1.close()\n self.serialPortDWM1001_2.close()\n \n # Sleep for one sec\n time.sleep(1)\n \n # Open serial port\n self.serialPortDWM1001_1.open()\n self.serialPortDWM1001_2.open()\n\n # Check if the serial port is opened\n if(self.serialPortDWM1001_1.isOpen()):\n rospy.loginfo(\"Port `O` opened: {}\".format(self.serialPortDWM1001_1.name) )\n else:\n rospy.logerr(\"Can't open port `O`: {}\".format(self.serialPortDWM1001_1.name))\n \n if(self.serialPortDWM1001_2.isOpen()):\n rospy.loginfo(\"Port `P` opened: {}\".format(self.serialPortDWM1001_2.name) )\n else:\n rospy.logerr(\"Can't open port `P`: {}\".format(self.serialPortDWM1001_2.name))\n\n try: \n tags = ['A', 'B', 'C', 'D']\n # Counting the msgs received and processed to check the system status\n msg_portO_cnt = [0,0,0,0]\n msg_portP_cnt = [0,0,0,0]\n while not rospy.is_shutdown():\n self.serialPortDWM1001_1.write(\"S\".encode())\n # just read everything from serial port \n for _ in range(4): \n serialReadLine = self.serialPortDWM1001_1.read_until()\n # print(serialReadLine)\n if not serialReadLine:\n rospy.logwarn(\"Port O: Read a empty line from Serial Port\")\n continue\n self.publishTagPositions('O',serialReadLine)\n msg_portO_cnt[tags.index(serialReadLine[9])] += 1\n self.rate.sleep()\n\n self.serialPortDWM1001_2.write(\"S\".encode()) \n for _ in range(4): \n serialReadLine = self.serialPortDWM1001_2.read_until()\n #print(serialReadLine)\n if not serialReadLine:\n rospy.logwarn(\"Port P: Read a empty line from Serial Port\")\n continue\n self.publishTagPositions('P',serialReadLine) \n msg_portP_cnt[tags.index(serialReadLine[9])] += 1 \n self.rate.sleep()\n\n if sum(msg_portO_cnt) > 100 and self.verbose :\n rospy.loginfo(\"All OK. Done O-> {}, P-> {} times !\".format(msg_portO_cnt, msg_portP_cnt))\n msg_portO_cnt = [0,0,0,0]\n msg_portP_cnt = [0,0,0,0]\n\n finally:\n rospy.loginfo(\"Quitting, and sending reset command to dev board\")","def _init_io(self):\n GPIO.setwarnings(False)\n GPIO.setmode( GPIO.BCM )\n pins = [ self._spi_dc ]\n for pin in pins:\n GPIO.setup( pin, GPIO.OUT )","def list_ports():\n non_working_ports = []\n dev_port = 0\n working_ports = []\n available_ports = []\n while len(non_working_ports) < 6: # if there are more than 5 non working ports stop the testing. \n camera = cv2.VideoCapture(dev_port)\n if not camera.isOpened():\n non_working_ports.append(dev_port)\n print(\"Port %s is not working.\" %dev_port)\n else:\n is_reading, img = camera.read()\n w = camera.get(3)\n h = camera.get(4)\n if is_reading:\n print(\"Port %s is working and reads images (%s x %s)\" %(dev_port,h,w))\n working_ports.append(dev_port)\n else:\n print(\"Port %s for camera ( %s x %s) is present but does not reads.\" %(dev_port,h,w))\n available_ports.append(dev_port)\n dev_port +=1\n return available_ports,working_ports,non_working_ports","def presetRead():\n\n global preset_sw \n \n while True:\n for i in range(6):\n preset_sw[i][1] = GPIO.input(preset_sw[i][0])\n sleep (1)","def resolve(self):\n # Find defines for all ports\n for port_name, port in self.ports.items():\n if not isinstance(port, ElemExportPort):\n print('hha')\n for k, p in port.items():\n name, bit_range = k\n if p:\n continue\n not_find = True\n for io_list in self.all_io.values():\n if name in io_list:\n port[k] = io_list[name]\n not_find = False\n break\n if not_find:\n raise VlogSyntaxError('A port defined in port list of module is NOT defined as input/output/inout')","def write(self):\n mask = 0\n for pin in self.pins:\n if pin.mode == OUTPUT:\n if pin.value == 1:\n pin_nr = pin.pin_number - self.port_number * 8\n mask |= 1 << pin_nr\n msg = chr(DIGITAL_MESSAGE + self.port_number)\n msg += chr(mask % 128)\n msg += chr(mask >> 7)\n self.board.sp.write(msg)","def xtest_find_port(self):\n line, head = self._get_line()\n p1, p2, p3, p4 = self.box1.ports()\n\n head.pos = 110, 50\n port = self.tool.find_port(line, head, self.box1)\n self.assertEquals(p1, port)\n\n head.pos = 140, 60\n port = self.tool.find_port(line, head, self.box1)\n self.assertEquals(p2, port)\n\n head.pos = 110, 95\n port = self.tool.find_port(line, head, self.box1)\n self.assertEquals(p3, port)\n\n head.pos = 100, 55\n port = self.tool.find_port(line, head, self.box1)\n self.assertEquals(p4, port)","def _read(self, pin):\n # Immediately return conversion register result if in CONTINUOUS mode\n # and pin has not changed\n if self.mode == Mode.CONTINUOUS and self._last_pin_read == pin:\n raw_adc = self._read_register(_ADS1X15_POINTER_CONVERSION, True)\n raw_adc = raw_adc.to_bytes(2, \"big\")\n return struct.unpack(\">h\", raw_adc)[0] >> self._shift_fact\n\n # Assign last pin read if in SINGLE mode or first sample in CONTINUOUS\n # mode on this pin\n self._last_pin_read = pin\n\n # Configure ADC every time before a conversion in SINGLE mode\n # or changing channels in CONTINUOUS mode\n config = _ADS1X15_CONFIG_OS_SINGLE if self.mode == Mode.SINGLE else 0\n config |= (pin & 0x07) << _ADS1X15_CONFIG_MUX_OFFSET\n config |= _ADS1X15_CONFIG_GAIN[self.gain]\n config |= self.mode\n config |= self.rate_config[self.data_rate]\n config |= _ADS1X15_CONFIG_COMP_QUE_DISABLE\n self._write_register(_ADS1X15_POINTER_CONFIG, config)\n\n # Wait for conversion to complete\n # ADS1x1x devices settle within a single conversion cycle\n if self.mode == Mode.SINGLE:\n # Continuously poll conversion complete status bit\n #while not self._conversion_complete():\n while not self._read_register(_ADS1X15_POINTER_CONFIG) & 0x8000:\n pass\n else:\n # Can't poll registers in CONTINUOUS mode\n # Wait expected time for two conversions to complete\n time.sleep(2 /self.data_rate)\n\n raw_adc = self._read_register(_ADS1X15_POINTER_CONVERSION, False)\n raw_adc = raw_adc.to_bytes(2, \"big\")\n return struct.unpack(\">h\", raw_adc)[0] >> self._shift_fact","def read_all_ram_ports(self):\n return self.RAM_PORT","def read_pin10(self):\n return self.PIN_10_SIGNAL_TEST","def run(outs, ins_filter='/dev/ttyUSB.*', newport=lambda conn: None, write_queue=None):\r\n data_queue = multiprocessing.Queue()\r\n\r\n multiprocessing.Process(\r\n target=writer,\r\n args=(data_queue, write_queue, outs)\r\n ).start()\r\n\r\n readers = {}\r\n\r\n while True:\r\n\r\n for (path, _, _) in serial.tools.list_ports.grep(ins_filter):\r\n\r\n if path not in readers.keys() or not readers[path].is_alive():\r\n\r\n readers[path] = multiprocessing.Process(\r\n target=reader, args=(data_queue, path, newport)\r\n )\r\n readers[path].start()","def pins_to_address(A2,A1,A0):\n if not all(pin in [0,1] for pin in [A2,A1,A0]): # Check pins are 1 or 0\n raise I2CException(\"Pins should be specified as 1 or 0\")\n return (0b1101000 | (A2 << 2) | (A1 << 1) | A0)","def read_live_data(wearable_port):\r\n IMU1_num = []\r\n IMU2_num = []\r\n IMU3_num = []\r\n\r\n try:\r\n wearable = serial.Serial(wearable_port, baudrate=115200, timeout=5)\r\n #arduino = serial.Serial(arduino_port, timeout=1)\r\n # Delay for 2 seconds to wait for serial port to be ready.\r\n print(\"Waiting 2 seconds for serial to be ready.\")\r\n time.sleep(2)\r\n except Exception as e:\r\n print(e)\r\n print('Please check the port')\r\n return\r\n\r\n input(\"Press Enter to continue...\")\r\n str(wearable.write(bytes(33)))\r\n # Open file to store the data; filename includes date and time; format: data-YYYYMMDDHHmmss.csv\r\n filename = \"data-\" + str(dt.datetime.now().strftime(\"%Y%m%d%H%M%S\")) + \".csv\"\r\n filenamplot = \"plot-\" + str(dt.datetime.now().strftime(\"%Y%m%d%H%M%S\")) + \".png\"\r\n print(\"Opening %s\" % filename)\r\n f = open(filename, \"a+\")\r\n # f.write(\"power,rpm\\n\")\r\n count = 1000\r\n # Get data and continuously yield Power and RPM as integers\r\n\r\n while (count >0):\r\n count = count -1\r\n #if arduino.in_waiting > 0:\r\n wearable.flushInput()\r\n\r\n '''\r\n arduino_output = arduino.readline().decode(\"utf_8\", \"strict\")\r\n print(\"Distance: %s\" % arduino_output)\r\n f.writelines(\"%s\" % arduino_output)\r\n if arduino_output == \"Hard Stop\\r\\n\":\r\n break\r\n arduino_output = arduino_output.replace(\"\\r\\n\", \"\")\r\n Distance.append(int(float(arduino_output)))\r\n '''\r\n\r\n try:\r\n data = wearable.readline().decode(\"utf_8\", \"strict\")\r\n data = data.replace(\"\\r\\n\", \"\\n\").split()\r\n IMU1= data[2].replace(\"\\n\", \"\")\r\n IMU1_num.append(int(IMU1))\r\n IMU2 = data[3].replace(\"\\n\", \"\")\r\n IMU2_num.append(int(IMU2))\r\n IMU3 = data[4].replace(\"\\n\", \"\")\r\n IMU3_num.append(int(IMU3))\r\n print(\"IMU1: %s\\t IMU2: %s\\t IMU3: %s\\t\" % (IMU1, IMU2, IMU3))\r\n f.writelines(\"%s,%s,%s,%s\\n\" % (IMU1, IMU2, IMU3))\r\n yield int(IMU1), int(IMU2), int(IMU3)\r\n except Exception as e:\r\n print('error')\r\n f.writelines(\"Error\\n\")\r\n\r\n print('Program ended.')\r\n t = numpy.linspace(1, len(IMU1_num), len(IMU1_num))\r\n fig, (ax1) = plt.subplots(nrows=1, ncols=1, figsize=(16.0, 9.0)) # create figure & 1 axis\r\n ax1.plot(t, IMU1_num, t, IMU2_num,t, IMU3_num)\r\n ax1.set_title('IMU')\r\n ax1.legend(('IMU1', 'IMU2', 'IMU3'))\r\n # manager = plt.get_current_fig_manager()\r\n # manager.resize(*manager.window.maxsize())\r\n fig.savefig(filenamplot)\r\n plt.show()\r\n\r\n f.close()\r\n #arduino.close()\r\n wearable.close()","def get_ports():\r\n ports = serial.tools.list_ports.comports()\r\n return ports","def auto_discover_board(self, verbose):\n # get current time\n start_time = time.time()\n\n # wait for up to 30 seconds for a successful capability query to occur\n\n while len(self.analog_mapping_query_results) == 0:\n if time.time() - start_time > 30:\n return False\n # keep sending out a capability query until there is a response\n self.send_sysex(self.ANALOG_MAPPING_QUERY, None)\n time.sleep(.1)\n\n if verbose:\n print(\"Board initialized in %d seconds\" % (time.time() - start_time))\n\n for pin in self.analog_mapping_query_results:\n self.total_pins_discovered += 1\n # non analog pins will be marked as IGNORE\n if pin != self.pymata.IGNORE:\n self.number_of_analog_pins_discovered += 1\n\n if verbose:\n print('Total Number of Pins Detected = %d' % self.total_pins_discovered)\n print('Total Number of Analog Pins Detected = %d' % self.number_of_analog_pins_discovered)\n\n # response table initialization\n # for each pin set the mode to input and the last read data value to zero\n for pin in range(0, self.total_pins_discovered):\n response_entry = [self.pymata.INPUT, 0, None]\n self.digital_response_table.append(response_entry)\n\n for pin in range(0, self.number_of_analog_pins_discovered):\n response_entry = [self.pymata.INPUT, 0, None]\n self.analog_response_table.append(response_entry)\n\n # set up latching tables\n for pin in range(0, self.total_pins_discovered):\n digital_latch_table_entry = [0, 0, 0, 0, None]\n self.digital_latch_table.append(digital_latch_table_entry)\n\n for pin in range(0, self.number_of_analog_pins_discovered):\n analog_latch_table_entry = [0, 0, 0, 0, 0, None]\n self.analog_latch_table.append(analog_latch_table_entry)\n\n return True","def gpio_get(self, pins=None):\n if pins is None:\n pins = range(4)\n\n size = len(pins)\n indices = (ctypes.c_uint8 * size)(*pins)\n statuses = (ctypes.c_uint8 * size)()\n result = self._dll.JLINK_EMU_GPIO_GetState(ctypes.byref(indices),\n ctypes.byref(statuses),\n size)\n if result < 0:\n raise errors.JLinkException(result)\n\n return list(statuses)","def scan_serial(self,event):\n if str(platform.system()) == 'Windows':\n tempList = ['COM%s' % (i + 1) for i in range(256)]\n elif str(platform.system()) == 'Linux':\n tempList = glob.glob('/dev/tty[A-Za-z]*')\n elif str(platform.system()) == 'Darwin':\n tempList = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError(\"Unsupported platform\")\n\n results = []\n for a_port in tempList:\n try:\n s = serial.Serial(a_port)\n s.close()\n results.append(a_port)\n except serial.SerialException:\n pass\n return results","def __init__(self, red_pin, green_pin, blue_pin):\n #self.red = gpiozero.PWMLED(red_pin, frequency=80, initial_value=1)\n #self.green = gpiozero.PWMLED(green_pin, frequency=80, initial_value=1)\n #self.blue = gpiozero.PWMLED(blue_pin, frequency=80, initial_value=1)\n self.red = gpiozero.LED(red_pin)\n self.green = gpiozero.LED(green_pin)\n self.blue = gpiozero.LED(blue_pin)\n self.leds = [self.red, self.green, self.blue]\n self.off()","def serial_ports():\n\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith(\n 'cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def setup_gpio(self):\n for row in self._rows:\n GPIO.setup(row, GPIO.IN, pull_up_down=GPIO.PUD_UP)\n for coll in self._colls:\n GPIO.setup(coll, GPIO.OUT)\n GPIO.output(coll, 1)","def pin_read(self, pin, mode=gpio.INPUT):\n port_num = self._convert_pin_port(pin)\n if port_num:\n gpio.setcfg(port_num, gpio.INTPUT)\n value = gpio.input(port_num)\n return value","def read(self, pin, is_differential=False):\n\n self.cs.value(0) # select\n self._out_buf[1] = ((not is_differential) << 7) | (pin << 4)\n self._spi.write_readinto(self._out_buf, self._in_buf)\n self.cs.value(1) # turn off\n return ((self._in_buf[1] & 0x03) << 8) | self._in_buf[2]","def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\n self.GP = GPIOProcessor()\n self.pin1 = self.GP.getPin(pin1)\n self.pin2 = self.GP.getPin(pin2)\n self.pin3 = self.GP.getPin(pin3)\n self.pin4 = self.GP.getPin(pin4)\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\n\n for k in range(4):\n self.pinl[k].out()\n\n self.speed = 100.0","def add_layout_pins(self):\n en_offset = self.dc_inst.get_pin(\"in\").ll()\n self.add_layout_pin(text=\"en\",\n layer=\"metal1\",\n offset=en_offset.scale(1,0),\n width=self.m1_width,\n height=en_offset.y)\n\n out_offset = self.rbl_inv_inst.get_pin(\"Z\").ll()\n self.add_layout_pin(text=\"out\",\n layer=\"metal1\",\n offset=out_offset.scale(1,0),\n width=self.m1_width,\n height=out_offset.y)","def read_dht11_dat():\n GPIO.setup(DHTPIN, GPIO.OUT)\n GPIO.output(DHTPIN, GPIO.HIGH)\n time.sleep(0.05)\n GPIO.output(DHTPIN, GPIO.LOW)\n time.sleep(0.02)\n GPIO.setup(DHTPIN, GPIO.IN, GPIO.PUD_UP)\n\n unchanged_count = 0\n last = -1\n data = []\n while True:\n current = GPIO.input(DHTPIN)\n data.append(current)\n if last != current:\n unchanged_count = 0\n last = current\n else:\n unchanged_count += 1\n if unchanged_count > MAX_UNCHANGE_COUNT:\n break\n\n state = STATE_INIT_PULL_DOWN\n\n lengths = []\n current_length = 0\n\n for current in data:\n current_length += 1\n\n if state == STATE_INIT_PULL_DOWN:\n if current == GPIO.LOW:\n state = STATE_INIT_PULL_UP\n else:\n continue\n if state == STATE_INIT_PULL_UP:\n if current == GPIO.HIGH:\n state = STATE_DATA_FIRST_PULL_DOWN\n else:\n continue\n if state == STATE_DATA_FIRST_PULL_DOWN:\n if current == GPIO.LOW:\n state = STATE_DATA_PULL_UP\n else:\n continue\n if state == STATE_DATA_PULL_UP:\n if current == GPIO.HIGH:\n current_length = 0\n state = STATE_DATA_PULL_DOWN\n else:\n continue\n if state == STATE_DATA_PULL_DOWN:\n if current == GPIO.LOW:\n lengths.append(current_length)\n state = STATE_DATA_PULL_UP\n else:\n continue\n if len(lengths) != 40:\n # print \"Data not good, skip\"\n return False\n\n shortest_pull_up = min(lengths)\n longest_pull_up = max(lengths)\n halfway = (longest_pull_up + shortest_pull_up) / 2\n bits = []\n the_bytes = []\n byte = 0\n\n for length in lengths:\n bit = 0\n if length > halfway:\n bit = 1\n bits.append(bit)\n # print \"bits: %s, length: %d\" % (bits, len(bits))\n for i in range(0, len(bits)):\n byte = byte << 1\n if (bits[i]):\n byte = byte | 1\n else:\n byte = byte | 0\n if ((i + 1) % 8 == 0):\n the_bytes.append(byte)\n byte = 0\n # print the_bytes\n checksum = (the_bytes[0] + the_bytes[1] + the_bytes[2] + the_bytes[3]) & 0xFF\n if the_bytes[4] != checksum:\n # print \"Data not good, skip\"\n return False\n\n return the_bytes[0], the_bytes[2]","def get_all_pins(self):\n return self.allpins","def serial_ports():\n if sys.platform.startswith('win'):\n result = []\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n result.append('COM' + str(i + 1))\n except serial.SerialException:\n pass\n return result\n\n elif sys.platform.startswith('linux'):\n return glob.glob('/dev/rf*')\n\n elif sys.platform.startswith('darwin'):\n return glob.glob('/dev/tty.*')","def analogRead(port):\n spi.open(0, 0)\n if (port > 7) or (port < 0):\n print 'analogRead -- Port Error, Must use a port between 0 and 7'\n return -1\n r = spi.xfer2([1, (8 + port) << 4, 0])\n value = ((r[1] & 3) << 8) + r[2]\n spi.close()\n return value","def __init__(self, pinForward1, pinBackward1,pinForward2, pinBackward2):\n\n self.pinForward1 = pinForward1\n self.pinBackward1 = pinBackward1\n self.pinForward2 = pinForward2\n self.pinBackward2 = pinBackward2\n\n GPIO.setup(self.pinForward1, GPIO.OUT)\n GPIO.setup(self.pinBackward1, GPIO.OUT)\n GPIO.setup(self.pinForward2, GPIO.OUT)\n GPIO.setup(self.pinBackward2, GPIO.OUT)\n\n self.pwm_forward1 = GPIO.PWM(self.pinForward1, 100)\n self.pwm_backward1 = GPIO.PWM(self.pinBackward1, 100)\n self.pwm_forward2 = GPIO.PWM(self.pinForward2, 100)\n self.pwm_backward2 = GPIO.PWM(self.pinBackward2, 100)\n \n self.pwm_forward1.start(0)\n self.pwm_backward1.start(0)\n self.pwm_forward2.start(0)\n self.pwm_backward2.start(0)","def setup():\n GPIO.setmode(GPIO.BCM)\n for pin in [CHURCH, CHURCH + 1, HALL, HALL + 1]:\n GPIO.setup(pin, GPIO.OUT, initial=GPIO.HIGH)","def compass_multi(size = (4, 2), ports = {'N':3,'S':4}, layer = 0):\n D = Device(name = 'compass_multi')\n r = D.add_ref(rectangle(size, layer = layer))\n r.center = (0, 0)\n\n dx = size[0]/2\n dy = size[1]/2\n\n if 'N' in ports:\n num_ports = ports['N']\n m = dx - dx/num_ports\n p_list = np.linspace(-m, m, num_ports)\n [D.add_port(name = ('N%s' % (n+1)), midpoint = [p, dy],\n width = dx/num_ports * 2, orientation = 90)\n for n, p in enumerate(p_list)]\n if 'S' in ports:\n num_ports = ports['S']\n m = dx - dx/num_ports\n p_list = np.linspace(-m, m, num_ports)\n [D.add_port(name = ('S%s' % (n+1)), midpoint = [p, -dy],\n width = dx/num_ports * 2, orientation = -90)\n for n, p in enumerate(p_list)]\n if 'E' in ports:\n num_ports = ports['E']\n m = dy - dy/num_ports\n p_list = np.linspace(-m, m, num_ports)\n [D.add_port(name = ('E%s' % (n+1)), midpoint = [dx, p],\n width = dy/num_ports * 2, orientation = 0)\n for n, p in enumerate(p_list)]\n if 'W' in ports:\n num_ports = ports['W']\n m = dy - dy/num_ports\n p_list = np.linspace(-m, m, num_ports)\n [D.add_port(name = ('W%s' % (n+1)), midpoint = [-dx, p],\n width = dy/num_ports * 2, orientation = 180)\n for n, p in enumerate(p_list)]\n\n return D","def GPIOsetup():\n GPIO.setmode(GPIO.BOARD)\n for led in (RED,YELLOW,GREEN):\n GPIO.setup(LED[led],GPIO.OUT)","def serial_ports():\r\n\tif sys.platform.startswith('win'):\r\n\t\tports = ['COM%s' % (i + 1) for i in range(256)]\r\n\telif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\r\n\t\t# this excludes your current terminal \"/dev/tty\"\r\n\t\tports = glob.glob('/dev/tty[A-Za-z]*')\r\n\telif sys.platform.startswith('darwin'):\r\n\t\tports = glob.glob('/dev/cu.usb*')\r\n\telse:\r\n\t\traise EnvironmentError('Unsupported platform')\r\n\r\n\tresult = []\r\n\tfor port in ports:\r\n\t\t#print(port)\r\n\t\ttry:\r\n\t\t\ts = serial.Serial(port)\r\n\t\t\ts.close()\r\n\t\t\tresult.append(port)\r\n\t\texcept (OSError, serial.SerialException):\r\n\t\t\tpass\r\n\treturn result","def hh_assign_ports():\n print('******* Assigning ports')\n for device in ci_addrs.switches_hh1:\n print ('******* Connecting to ', device.get('ip'))\n net_connect = ConnectHandler(**device)\n output_vlan_cp = net_connect.send_config_set(cp_hh1_config_commands)\n print (output_vlan_cp)\n output_vlan_cloud = net_connect.send_config_set(cloud_hh1_config_commands)\n print (output_vlan_cloud)\n output_vlan_f5 = net_connect.send_config_set(f5_hh_config_commands)\n print (output_vlan_f5)\n net_connect.send_config_set('wr')\n\n for device in ci_addrs.switches_hh2:\n print ('******* Connecting to ', device.get('ip'))\n net_connect = ConnectHandler(**device)\n output_vlan_cp = net_connect.send_config_set(cp_hh2_config_commands)\n print (output_vlan_cp)\n output_vlan_cloud = net_connect.send_config_set(cloud_hh2_config_commands)\n print (output_vlan_cloud)\n output_vlan_f5 = net_connect.send_config_set(f5_hh_config_commands)\n print (output_vlan_f5)\n net_connect.send_config_set('wr')","def _update(self, mask):\n if self.reporting:\n for pin in self.pins:\n if pin.mode is INPUT:\n pin_nr = pin.pin_number - self.port_number * 8\n pin.value = (mask & (1 << pin_nr)) > 0","def __init__(__self__, *,\n from_port: pulumi.Input[int],\n to_port: pulumi.Input[int]):\n pulumi.set(__self__, \"from_port\", from_port)\n pulumi.set(__self__, \"to_port\", to_port)","def _convert_pin_port(self, pin):\n if pin in dir(port):\n port_num = getattr(port, pin)\n elif pin in dir(connector):\n port_num = getattr(connector, pin)\n else:\n errmsg = \"Unknown pin {}\".format(pin)\n self._logger.error(errmsg)\n return 0\n return port_num","def s_read(self, timeout = 1):\n if self.s.is_open:\n data = [] \n b = bytearray()\n try:\n self.s.timeout = 3\n data = self.s.read(1)\n \n if not len(data):\n return b\n\n self.s.timeout = .04\n data += self.s.read(500)\n except Exception as e:\n print(\"Could not read from port\" + str(e))\n\n start = data.find(b'\\x7e')\n end = data.find(b'\\x7f')\n\n txt_start = b''\n txt_end = b''\n if start < 0:\n txt_start = data\n elif end < 0:\n txt_start = data\n else:\n txt_start = data[0:start]\n txt_end = data[end+1:]\n\n txt = txt_start + txt_end\n if len(txt):\n if self.log_ascii:\n self.logfile.write(txt)\n\n # End logging \n if Connection.START_UP_STRING in data:\n raise Reset_Exception('ChipSHOUTER unit has reset - wait 5 seconds then reinitialize.') \n\n if start < 0 or end < 0 or end < start:\n b = bytearray()\n return b\n if self.log_input:\n self.logfile.write('\\nIN :' + str(len(data)) + '[' + hexlify(data) + ']' + '\\n')\n b.extend(data[start:end])\n return b\n else:\n raise IOError('Comport is not open, use ctl_connect()')","def connect_ports(self, port1_name: str, ip1_name: str,\n port2_name: str, ip2_name: str):\n if (ip1_name not in self._ips.keys() or\n ip2_name not in self._ips.keys()):\n raise ValueError(\n f'No such IP in this module: {ip1_name}, {ip2_name}.'\n ' Use add_ip method to add the IPs first')\n # get the 'WrapperPort's\n port1 = self._ips[ip1_name].get_port_by_name(port1_name)\n port2 = self._ips[ip2_name].get_port_by_name(port2_name)\n\n if len(port1) != len(port2):\n warning(f'ports: {ip1_name}:{port1.name}({len(port1)}), '\n f'{ip2_name}:{port2.name}({len(port2)})'\n ' have different widths!')\n\n inst1_args = getattr(self, ip1_name)\n inst2_args = getattr(self, ip2_name)\n\n full_name1 = port_direction_to_prefix(port1.direction) + port1.name\n full_name2 = port_direction_to_prefix(port2.direction) + port2.name\n\n # If a port was connected previoulsy,\n # take the previoulsy created signal, instead of creating a new one\n if full_name1 in inst1_args.keys():\n sig = inst1_args[full_name1]\n elif full_name2 in inst2_args.keys():\n sig = inst2_args[full_name2]\n else:\n # neither of the ports was connected previously\n # create a new signal for the connection\n combined_name = port1.name + '_' + port2.name\n self._signals_between_ips.append(combined_name)\n sig = Signal(len(port1), name=combined_name)\n setattr(self, combined_name, sig)\n\n inst1_args[full_name1] = sig\n inst2_args[full_name2] = sig","async def _digital_message(self, data):\n port = data[0]\n port_data = (data[PrivateConstants.MSB] << 7) + \\\n data[PrivateConstants.LSB]\n pin = port * 8\n for pin in range(pin, min(pin + 8, len(self.digital_pins))):\n # get pin value\n value = port_data & 0x01\n\n # set the current value in the pin structure\n self.digital_pins[pin].current_value = value\n\n # append pin number, pin value, and pin type to return value and return as a list\n message = [pin, value, Constants.INPUT]\n\n if self.digital_pins[pin].cb:\n if self.digital_pins[pin].cb_type:\n await self.digital_pins[pin].cb(message)\n else:\n # self.digital_pins[pin].cb(data)\n loop = self.loop\n loop.call_soon(self.digital_pins[pin].cb, message)\n\n # is there a latch entry for this pin?\n key = 'D' + str(pin)\n if key in self.latch_map:\n await self._check_latch_data(key, port_data & 0x01)\n port_data >>= 1","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def read(pin):\n return _read_value(\"{0}/gpio{1}/value\".format(_path_prefix, pin))","def serial_ports():\r\n if sys.platform.startswith('win'):\r\n ports = ['COM%s' % (i + 1) for i in range(256)]\r\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\r\n # this excludes your current terminal \"/dev/tty\"\r\n ports = glob.glob('/dev/tty[A-Za-z]*')\r\n elif sys.platform.startswith('darwin'):\r\n ports = glob.glob('/dev/tty.*')\r\n else:\r\n raise EnvironmentError('Unsupported platform')\r\n\r\n result = []\r\n for port in ports:\r\n try:\r\n s = serial.Serial(port)\r\n s.close()\r\n result.append(port)\r\n except (OSError, serial.SerialException):\r\n pass\r\n return result","def serial_ports():\r\n if sys.platform.startswith('win'):\r\n ports = ['COM%s' % (i + 1) for i in range(256)]\r\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\r\n # this excludes your current terminal \"/dev/tty\"\r\n ports = glob.glob('/dev/tty[A-Za-z]*')\r\n elif sys.platform.startswith('darwin'):\r\n ports = glob.glob('/dev/tty.*')\r\n else:\r\n raise EnvironmentError('Unsupported platform')\r\n\r\n result = []\r\n for port in ports:\r\n try:\r\n s = serial.Serial(port)\r\n s.close()\r\n result.append(port)\r\n except (OSError, serial.SerialException):\r\n pass\r\n return result","def cmd(self,bits,char_mode=False):\n\n if( rpi_device ):\n sleep(0.0012)\n bits = bin(bits)[2:].zfill(8)\n GPIO.output(self.pin_rs,char_mode)\n\n for pin in self.pins_db:\n GPIO.output(pin,False)\n\n for i in range(4):\n if bits[i] == \"1\":\n GPIO.output(self.pins_db[::-1][i],True)\n \n GPIO.output(self.pin_e,True)\n GPIO.output(self.pin_e,False)\n\n for pin in self.pins_db:\n GPIO.output(pin,False)\n \n for i in range(4,8):\n if bits[i] == \"1\":\n GPIO.output(self.pins_db[::-1][i-4],True)\n\n GPIO.output(self.pin_e,True)\n GPIO.output(self.pin_e,False)","def update(self):\r\n self._state = self.iobus.read_pin(self.targetpin)","def sequential_connect(self):\r\n\r\n # Connect to rendezvous server.\r\n try:\r\n mappings = sequential_bind(self.mapping_no + 1, self.interface)\r\n con = self.server_connect(mappings[0][\"sock\"])\r\n except Exception as e:\r\n log.debug(e)\r\n log.debug(\"this err\")\r\n return None\r\n\r\n # First mapping is used to talk to server.\r\n mappings.remove(mappings[0])\r\n\r\n # Receive port mapping.\r\n msg = \"SOURCE TCP %s\" % (str(mappings[0][\"source\"]))\r\n con.send_line(msg)\r\n reply = con.recv_line(timeout=2)\r\n remote_port = self.parse_remote_port(reply)\r\n if not remote_port:\r\n return None\r\n\r\n # Generate port predictions.\r\n predictions = \"\"\r\n if self.nat_type != \"random\":\r\n mappings = self.predict_mappings(mappings)\r\n for mapping in mappings:\r\n predictions += str(mapping[\"remote\"]) + \" \"\r\n predictions = predictions.rstrip()\r\n else:\r\n predictions = \"1337\"\r\n\r\n return [con, mappings, predictions]","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(32)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/ttyUSB*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def add_layout_pins(self):\n\n # All wordlines\n # Main array wl and bl/br\n for pin_name in self.all_wordline_names:\n pin_list = self.bitcell_array_inst.get_pins(pin_name)\n for pin in pin_list:\n self.add_layout_pin(text=pin_name,\n layer=pin.layer,\n offset=pin.ll().scale(0, 1),\n width=self.width,\n height=pin.height())\n\n # Replica wordlines (go by the row instead of replica column because we may have to add a pin\n # even though the column is in another local bitcell array)\n for (names, inst) in zip(self.rbl_wordline_names, self.dummy_row_replica_insts):\n for (wl_name, pin_name) in zip(names, self.dummy_row.get_wordline_names()):\n if wl_name in self.gnd_wordline_names:\n continue\n pin = inst.get_pin(pin_name)\n self.add_layout_pin(text=wl_name,\n layer=pin.layer,\n offset=pin.ll().scale(0, 1),\n width=self.width,\n height=pin.height())\n\n for pin_name in self.all_bitline_names:\n pin_list = self.bitcell_array_inst.get_pins(pin_name)\n for pin in pin_list:\n self.add_layout_pin(text=pin_name,\n layer=pin.layer,\n offset=pin.ll().scale(1, 0),\n width=pin.width(),\n height=self.height)\n\n # Replica bitlines\n if len(self.rbls) > 0:\n for (names, inst) in zip(self.rbl_bitline_names, self.replica_col_insts):\n pin_names = self.replica_columns[self.rbls[0]].all_bitline_names\n for (bl_name, pin_name) in zip(names, pin_names):\n pin = inst.get_pin(pin_name)\n self.add_layout_pin(text=bl_name,\n layer=pin.layer,\n offset=pin.ll().scale(1, 0),\n width=pin.width(),\n height=self.height)","def get_outputs(self):\n return [x[1] for x in self.io_mapping]"],"string":"[\n \"def add_pins(self):\\n\\n for bit in range(self.addr_size):\\n self.add_pin(\\\"addr_{0}\\\".format(bit),\\\"INPUT\\\")\\n \\n self.add_pin(\\\"wl_en\\\", \\\"INPUT\\\")\\n\\n for bit in range(self.num_rows):\\n self.add_pin(\\\"wl_{0}\\\".format(bit),\\\"OUTPUT\\\")\\n \\n self.add_pin(\\\"vdd\\\",\\\"POWER\\\")\\n self.add_pin(\\\"gnd\\\",\\\"GROUND\\\")\",\n \"def read_all_rom_ports(self):\\n return self.ROM_PORT\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\\n\\n\\n # isAngleChanged = True\\n # pastAngle = Current_Coord['ang']\\n # resetStates()\\n # # temp\\n # angle = 0\\n # while current_mode == mode['Mapping']:\\n # updateCurrCordinate(distance, angle)\\n # # needs a way to keep track if the distance and the angle has changed!!\\n # # if angle is changed the first time; add onto the trace.\\n # if angle != pastAngle:\\n # if not isAngleChanged:\\n # addCurrToParameter()\\n # isAngleChanged = 1\\n # pastAngle = angle\\n # # Has stopped rotating and back to moving.\\n # if isAngleChanged and distance != 0:\\n # isAngleChanged = 0\\n # # when it exists the while loop == the bot has stopped. adding stopping point\\n # # into the list\\n # addCurrToParameter()\",\n \"def initialize_light_pins(pi, pins):\\n for pin in pins:\\n pi.set_mode(pin, pigpio.OUTPUT)\\n pi.set_pull_up_down(pin, pigpio.PUD_DOWN)\",\n \"def initialize_pins(self):\\n\\n for pin_name in self.pin_defs.keys():\\n if self.pin_defs[pin_name]['mode'] == 'input':\\n self.pin(pin_name).direction = digitalio.Direction.INPUT\\n #logging.info('Pin {} set to {}'.format(pin_num, self.pin_defs[pin_num]['mode']))\\n\\n elif self.pin_defs[pin_name]['mode'] == 'output':\\n self.pin(pin_name).switch_to_output(value=self.pin_defs[pin_name]['init'])\\n #logging.info('Pin {} set to {}'.format(pin_num, self.pin_defs[pin_num]['mode']))\\n\\n else:\\n logging.error('Error, no direction defined for pin {}, pin_defs: {}'\\n .format(pin_name, self.pin_defs[pin_name]))\",\n \"def activatePinReading(self):\\n\\n for pin in self.pinsToMeasure:\\n arduino.samplePinDuringCapture(self.f, self.pinMap[pin], self.wallClock)\",\n \"def __status(self, port):\\n s = []\\n hw = self.device.peripherals[port]\\n mode_val = hw.MODER.rd()\\n for i in range(16):\\n # standard pin name\\n pin_name = 'P%s%d' % (port[4:], i)\\n # target name\\n tgt_name = self.pin2name.get(pin_name, '?')\\n # mode for this pin\\n mode_name = hw.MODER.fields['MODER%d' % i].field_name(mode_val)\\n val_name = ''\\n af_name = None\\n if mode_name == 'analog':\\n mode_name = 'an'\\n if mode_name == 'altfunc':\\n if i < 8:\\n mode_name = 'af%d' % ((hw.AFRL.rd() >> (i << 2)) & 15)\\n af_name = hw.AFRL.fields['AFRL%d' % i].field_name(hw.AFRL.rd())\\n else:\\n mode_name = 'af%d' % ((hw.AFRH.rd() >> ((i - 8) << 2)) & 15)\\n af_name = hw.AFRH.fields['AFRH%d' % i].field_name(hw.AFRH.rd())\\n elif mode_name == 'output':\\n mode_name = 'out(%d)' % self.rd_output(port, i)\\n elif mode_name == 'input':\\n mode_name = 'in(%d)' % self.rd_input(port, i)\\n # combine the target and alternate function name\\n if af_name:\\n tgt_name += ' (%s)' % af_name\\n s.append([pin_name, mode_name, tgt_name])\\n return s\",\n \"def ports(self):\\r\\n # check connected to chip\\r\\n if not self._core.is_connected():\\r\\n raise ka_exceptions.NotConnectedError()\\r\\n\\r\\n # check symbols are loaded\\r\\n self._core.sym.assert_have_symbols()\\r\\n\\r\\n # get the symbols we need\\r\\n READ_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.read_port_offset_addr')\\r\\n WRITE_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.write_port_offset_addr')\\r\\n READ_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.read_port_limit_addr')\\r\\n WRITE_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.write_port_limit_addr')\\r\\n READ_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.read_port_buffer_size')\\r\\n WRITE_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.write_port_buffer_size')\\r\\n\\r\\n def read_dm(addr):\\r\\n return self._core.dm[addr]\\r\\n\\r\\n # get the read and write offset\\r\\n read_offset_addr = self._read_var_with_size_check(READ_OFFSET_ADDR.addr, READ_OFFSET_ADDR.size_in_addressable_units)\\r\\n write_offset_addr = self._read_var_with_size_check(WRITE_OFFSET_ADDR.addr, WRITE_OFFSET_ADDR.size_in_addressable_units)\\r\\n read_offset = map(read_dm, read_offset_addr)\\r\\n write_offset = map(read_dm, write_offset_addr)\\r\\n\\r\\n # get the read and write limit\\r\\n read_limit_addr = self._read_var_with_size_check(READ_LIMIT_ADDR.addr, READ_LIMIT_ADDR.size_in_addressable_units)\\r\\n write_limit_addr = self._read_var_with_size_check(WRITE_LIMIT_ADDR.addr, WRITE_LIMIT_ADDR.size_in_addressable_units)\\r\\n read_limit = map(read_dm, read_limit_addr)\\r\\n write_limit = map(read_dm, write_limit_addr)\\r\\n\\r\\n # get the port size\\r\\n read_size = self._read_var_with_size_check(READ_BUFFER_SIZE.addr, READ_BUFFER_SIZE.size_in_addressable_units)\\r\\n write_size = self._read_var_with_size_check(WRITE_BUFFER_SIZE.addr, WRITE_BUFFER_SIZE.size_in_addressable_units)\\r\\n # calculate size mask (size-1) for non-zero sizes\\r\\n read_mask = map(lambda s: s - (s>0), read_size)\\r\\n write_mask = map(lambda s: s - (s>0), write_size)\\r\\n\\r\\n # calculate data/space in port\\r\\n read_data = map(lambda l,o,m: (l - o) & m, read_limit, read_offset, read_mask)\\r\\n write_space = map(lambda l,o,m: (l - o) & m - 1, write_limit, write_offset, write_mask)\\r\\n\\r\\n # read port configs\\r\\n READ_CONF_BASE = self._core.sym.constfind('$READ_PORT0_CONFIG').value\\r\\n WRITE_CONF_BASE = self._core.sym.constfind('$WRITE_PORT0_CONFIG').value\\r\\n read_conf = self._read_var_with_size_check(READ_CONF_BASE, READ_OFFSET_ADDR.size_in_addressable_units)\\r\\n write_conf = self._read_var_with_size_check(WRITE_CONF_BASE, WRITE_OFFSET_ADDR.size_in_addressable_units)\\r\\n\\r\\n # extract data size (in octets) from config\\r\\n read_data_size = map(lambda c: (c & 0x3) + 1, read_conf)\\r\\n write_space_size = map(lambda c: (c & 0x3) + 1, write_conf)\\r\\n\\r\\n # decode configs into strings\\r\\n read_conf_str = map(lambda c,s: (\\\"8\\\" if s==1 else (\\\"16\\\" if s==2 else (\\\"24\\\" if s==3 else \\\"??\\\"))) + \\\"-bit, \\\" \\\\\\r\\n + (\\\"Big Endian\\\" if (c & 0x4) else \\\"Little Endian\\\") + \\\", \\\" \\\\\\r\\n + (\\\"No Sign Ext\\\" if (c & 0x8) else \\\"Sign Ext\\\" ), \\\\\\r\\n read_conf, read_data_size)\\r\\n write_conf_str = map(lambda c,s: (\\\"8\\\" if s==1 else (\\\"16\\\" if s==2 else (\\\"24\\\" if s==3 else \\\"??\\\"))) + \\\"-bit, \\\" \\\\\\r\\n + (\\\"Big Endian\\\" if (c & 0x4) else \\\"Little Endian\\\") + \\\", \\\" \\\\\\r\\n + (\\\"Saturate\\\" if (c & 0x8) else \\\"No Saturate\\\"), \\\\\\r\\n write_conf, write_space_size)\\r\\n\\r\\n # print information\\r\\n print \\\"Read ports:\\\\n Port Status Offset Address Size(Bytes) Data Config\\\"\\r\\n for i in range(len(read_offset_addr)):\\r\\n if read_offset_addr[i]:\\r\\n print \\\" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\\\" % \\\\\\r\\n (i, read_offset_addr[i], read_offset_addr[i], read_size[i], read_size[i], read_data[i]/read_data_size[i], read_conf_str[i])\\r\\n else:\\r\\n print \\\" %2i Disabled\\\" % i\\r\\n\\r\\n print \\\"Write ports:\\\\n Port Status Offset Address Size(Bytes) Space Config\\\"\\r\\n for i in range(len(write_offset_addr)):\\r\\n if write_offset_addr[i]:\\r\\n print \\\" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\\\" % \\\\\\r\\n (i, write_offset_addr[i], write_offset_addr[i], write_size[i], write_size[i], write_space[i]/write_space_size[i], write_conf_str[i])\\r\\n else:\\r\\n print \\\" %2i Disabled\\\" % i\",\n \"def get_port_list(self):\\r\\n self.ports = Manager().dict()\\r\\n self.value = Manager().dict()\\r\\n self.sensors = dict()\\r\\n for p in self.device.ports['input']:\\r\\n if p.enabled:\\r\\n self.ports[p.number] = p\\r\\n self.value[p.number] = 'Connexion à la carte'\\r\\n self.sensors[p.number] = Sensor.get(p._type)\",\n \"def set_in_pins(pins):\\n for pin in pins:\\n GPIO.setup(pin, GPIO.IN, GPIO.PUD_DOWN)\\n\\tGPIO.setup(LEDPIN, GPIO.OUT)\\n\\tGPIO.output(LEDPIN, GPIO.LOW)\",\n \"def servo_read_all(self):\\n msg = b'\\\\x25\\\\x00'\\n parameter_len = 16\\n ans = self.__bt.read(msg, parameter_len)\\n if ans is not None:\\n return [x for x in ans]\\n return None\",\n \"def init_pins(self):\\n for pin in self.SENSOR_PINS:\\n self.sensorValues.append(0)\\n self.calibratedMax.append(0)\\n self.calibratedMin.append(0)\\n self.wp.pullUpDnControl(pin, self.wp.PUD_DOWN)\\n self.wp.pinMode(self.LEDON_PIN, self.wp.OUTPUT)\",\n \"def serial_ports():\\n# ports = glob.glob('/dev/tty[A-Za-z]*')\\n ports = glob.glob('/dev/ttyACM*')\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (serial.SerialException) as e:\\n print(e)\\n return result\",\n \"def set_output_pins(gpio_pi, pins):\\n for pin in pins:\\n gpio_pi.set_mode(pin, pigpio.OUTPUT)\",\n \"def analog_read(self, pin_number):\\n command = (''.join(('RA', str(pin_number)))).encode()\\n self.conn.write(command) \\n line_received = self.conn.readline().decode().strip()\\n header, value = line_received.split(':') # e.g. A4:1\\n if header == ('A'+ str(pin_number)):\\n # If header matches\\n return int(value)\",\n \"def setup():\\n GPIO.setmode(GPIO.BCM)\\n for pin in [config.gpio_pin_p1_stretch,\\n config.gpio_pin_p1_serve,\\n config.gpio_pin_p2_stretch,\\n config.gpio_pin_p2_serve]:\\n GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\\n\\n input_reader_thread = threading.Thread(target=input_reader_worker)\\n input_reader_thread.setDaemon(True)\\n input_reader_thread.start()\",\n \"def find_arduino(portsfound):\\r\\n comPort = 'None'\\r\\n num_of_connection = len(portsfound)\\r\\n\\r\\n for i in range(0, num_of_connection):\\r\\n port = foundPorts[i]\\r\\n cnvt_str_port = str(port)\\r\\n\\r\\n if 'ttyACM' in cnvt_str_port:\\r\\n splitPort = cnvt_str_port.split(' ')\\r\\n comPort = (splitPort[0])\\r\\n\\r\\n return comPort\",\n \"def input_output_config(self):\\r\\n\\t\\tif self.io == 0 :\\r\\n\\t\\t\\tif self.pin == 0 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN0)\\r\\n\\t\\t\\telif self.pin == 1 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN1)\\r\\n\\t\\t\\telif self.pin == 2 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN2)\\r\\n\\t\\t\\telif self.pin == 3 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PIN3)\\r\\n\\t\\telif self.io == 1 :\\r\\n\\t\\t\\tbus.write_byte_data(PCA9536_WDBZ_DEFAULT_ADDRESS, PCA9536_WDBZ_REG_CONFIG, PCA9536_WDBZ_CONFIG_PINX)\",\n \"def pins(self, toggle=None, low=None, high=None):\\n\\n if toggle != None:\\n val = 0\\n for pin in toggle.split(\\\",\\\"):\\n if not pin in PINS_OUT:\\n raise ValueError(\\\"Invalid output pin '{:}'\\\".format(pin))\\n\\n val |= PINS_OUT[pin]\\n\\n self.write_block(REG_PINS, [val])\\n\\n if low != None:\\n res = self.read_block(REG_PINS, 1)\\n val = 0\\n for pin in low.split(\\\",\\\"):\\n if not pin in PINS_OUT:\\n raise ValueError(\\\"Invalid output pin '{:}'\\\".format(pin))\\n\\n # Only toggle if already high\\n if res[0] & PINS_OUT[pin] > 0:\\n val |= PINS_OUT[pin]\\n\\n if val > 0:\\n self.write_block(REG_PINS, [val])\\n\\n if high != None:\\n res = self.read_block(REG_PINS, 1)\\n val = 0\\n for pin in high.split(\\\",\\\"):\\n if not pin in PINS_OUT:\\n raise ValueError(\\\"Invalid output pin '{:}'\\\".format(pin))\\n\\n # Only toggle if already low\\n if res[0] & PINS_OUT[pin] == 0:\\n val |= PINS_OUT[pin]\\n\\n if val > 0:\\n self.write_block(REG_PINS, [val])\\n\\n res = self.read_block(REG_PINS, 1)\\n ret = {\\n \\\"input\\\": {k: bool(res[0] & v) for k, v in PINS_IN.iteritems()},\\n \\\"output\\\": {k: bool(res[0] & v) for k, v in PINS_OUT.iteritems()}\\n }\\n\\n return ret\",\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 input_output_config(self):\\r\\n\\t\\tif self.io == 0 :\\r\\n\\t\\t\\tif self.pin == 0 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PIN0)\\r\\n\\t\\t\\telif self.pin == 1 :\\r\\n\\t\\t\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PIN1)\\r\\n\\t\\telif self.io == 1 :\\r\\n\\t\\t\\tbus.write_byte_data(PCA9537_DEFAULT_ADDRESS, PCA9537_REG_CONFIG, PCA9537_CONFIG_PINX)\",\n \"def initialize():\\n for pin in sorted(OUTPUT_PINS.values()):\\n _enable_pin(pin, OUT)\\n\\n for pin in sorted(INPUT_PINS.values()):\\n _enable_pin(pin, IN)\",\n \"def port_nic():\",\n \"def rr2_assign_ports():\\n print('******* Assigning ports')\\n for device in ci_addrs.switches_rr1_12:\\n print ('******* Connecting to ', device.get('ip'))\\n net_connect = ConnectHandler(**device)\\n output_vlan_cp = net_connect.send_config_set(cp_rr2_config_commands)\\n print (output_vlan_cp)\\n output_vlan_cloud = net_connect.send_config_set(cloud_rr1_config_commands)\\n print (output_vlan_cloud)\\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\\n print (output_vlan_f5)\\n net_connect.send_config_set('wr')\\n for device in ci_addrs.switches_rr2_12:\\n print ('******* Connecting to ', device.get('ip'))\\n net_connect = ConnectHandler(**device)\\n output_vlan_cp = net_connect.send_config_set(cp_rr2_config_commands)\\n print (output_vlan_cp)\\n output_vlan_cloud = net_connect.send_config_set(cloud_rr2_config_commands)\\n print (output_vlan_cloud)\\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\\n print (output_vlan_f5)\\n net_connect.send_config_set('wr')\\n assign_ports_n5k34()\",\n \"def update_voutput_pins(self):\\n if not pfio:\\n raise Exception(\\n \\\"Looks like some sloppy programmer (probably Tom Preston...) \\\" \\\\\\n \\\"is trying to update the virtual output pins when the PiFace \\\" \\\\\\n \\\"isn't connected. Make sure you check for the pfio before calling \\\" \\\\\\n \\\"the update_voutput_pins method. kthxbai.\\\")\\n\\n output_bit_map = pfio.read_output()\\n for i in range(len(self.output_pins)):\\n # updating inner value so that we don't do more SPI reads\\n self.output_pins[i]._value = (output_bit_map >> i) & 1 \\n\\n self.queue_draw()\",\n \"def get_all_port(self, conf, dpid):\\n\\t\\tpass\",\n \"def setup(self):\\n\\n for row_pin in keypad_row_pins:\\n #Set up row-pins\\n self.gpio.setup(row_pin, self.gpio.OUT)\\n\\n for col_pin in keypad_col_pins:\\n #Set up col-pins\\n self.gpio.setup(col_pin, self.gpio.IN)\",\n \"def get_ports(self) -> tuple:\\n raise NotImplementedError\",\n \"def serial_ports():\\r\\n return list(map(lambda listportinfo: listportinfo.device, list_ports.comports()))\",\n \"def read_serial(onewire_temperature_c, sensor_mappings, serial_port):\\n ser = serial.Serial(serial_port, timeout=60)\\n while 1:\\n line = ser.readline()\\n m = re.match(r'([A-Z0-9]{16}):(-?[0-9.]+)\\\\n', line.decode('ascii'))\\n if m:\\n onewire_temperature_c.labels(location=sensor_mappings[m.group(1)]).set(m.group(2))\",\n \"def read_pin(self, pin):\\n value = 0\\n pin = pin - 1\\n if pin < 8:\\n self.__port_a_value = self.__bus.read_byte_data(\\n self.__ioaddress, self.GPIOA)\\n value = self.__checkbit(self.__port_a_value, pin)\\n else:\\n pin = pin - 8\\n self.__port_b_value = self.__bus.read_byte_data(\\n self.__ioaddress, self.GPIOB)\\n value = self.__checkbit(self.__port_b_value, pin)\\n return value\",\n \"def setup(self):\\n GPIO.setmode(GPIO.BCM)\\n for rowp in self.rows:\\n GPIO.setup(rowp, GPIO.OUT)\\n for colp in self.cols:\\n GPIO.setup(colp, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)\",\n \"def read_port(self, port):\\n value = 0\\n if port == 1:\\n self.__port_b_value = self.__bus.read_byte_data(\\n self.__ioaddress, self.GPIOB)\\n value = self.__port_b_value\\n else:\\n self.__port_a_value = self.__bus.read_byte_data(\\n self.__ioaddress, self.GPIOA)\\n value = self.__port_a_value\\n return value\",\n \"def ext_pins(self, toggle=None, low=None, high=None):\\n\\n if toggle != None:\\n val = 0\\n for pin in toggle.split(\\\",\\\"):\\n if not pin in EXT_PINS_OUT:\\n raise ValueError(\\\"Invalid output extension pin '{:}'\\\".format(pin))\\n\\n val |= EXT_PINS_OUT[pin]\\n\\n self.write_block(REG_EXT_PINS, [val])\\n\\n if low != None:\\n res = self.read_block(REG_EXT_PINS, 1)\\n val = 0\\n for pin in low.split(\\\",\\\"):\\n if not pin in EXT_PINS_OUT:\\n raise ValueError(\\\"Invalid output extension pin '{:}'\\\".format(pin))\\n\\n # Only toggle if already high\\n if res[0] & EXT_PINS_OUT[pin] > 0:\\n val |= EXT_PINS_OUT[pin]\\n\\n if val > 0:\\n self.write_block(REG_EXT_PINS, [val])\\n\\n if high != None:\\n res = self.read_block(REG_EXT_PINS, 1)\\n val = 0\\n for pin in high.split(\\\",\\\"):\\n if not pin in EXT_PINS_OUT:\\n raise ValueError(\\\"Invalid output extension pin '{:}'\\\".format(pin))\\n\\n # Only toggle if already low\\n if res[0] & EXT_PINS_OUT[pin] == 0:\\n val |= EXT_PINS_OUT[pin]\\n\\n if val > 0:\\n self.write_block(REG_EXT_PINS, [val])\\n\\n res = self.read_block(REG_EXT_PINS, 1)\\n ret = {\\n \\\"input\\\": {k: bool(res[0] & v) for k, v in EXT_PINS_IN.iteritems()},\\n \\\"output\\\": {k: bool(res[0] & v) for k, v in EXT_PINS_OUT.iteritems()}\\n }\\n\\n return ret\",\n \"def testAllRead(self):\\n import time,copy\\n time.sleep(2)\\n to_config = self.config['vdevs']['slave']['icsifaces'][0]\\n from_config = self.config['vdevs']['master']['clientifaces'][0]\\n points = self.config['vdevs']['slave']['points']\\n client = ModbusRTU(to_config, points, from_config)\\n\\n\\n pts = copy.deepcopy(self.config['vdevs']['slave']['points'])\\n for i in xrange(50):\\n ptnames = [ pt['name'] for pt in pts ]\\n reply = client.readPoints(ptnames)\\n #print \\\"Reply: \\\", reply\\n for pt in ptnames:\\n value = filter(lambda x: x['name']==pt, pts)[0]['value']\\n #assert value == reply[ptnames.index(pt)]\\n received = reply[ptnames.index(pt)]\\n if not value == received: \\n print pt, ' was %s but should be %s'%(str(received),str(value))\",\n \"def read_bytes(self, ctrl_pin):\\n try:\\n '''\\n ctrl_pin1.value(0)\\n time.sleep_ms(2)\\n ctrl_pin1.value(1)\\n time.sleep_ms(220)\\n ctrl_pin1.value(0)\\n temp = hspi.read(2)\\n ctrl_pin1.value(1)\\n '''\\n pin_ = self.ctrl_pins[ctrl_pin]\\n pin_.value(0)\\n time.sleep_ms(2)\\n pin_.value(1)\\n time.sleep_ms(220)\\n pin_.value(0)\\n temp = self.hspi.read(2)\\n pin_.value(1)\\n except KeyError:\\n print('requested pin not defined')\\n temp = None\\n return temp\",\n \"def init_pins(self, h_p, m_p, s_p):\\r\\n for seconds_pin in s_p:\\r\\n self.second_leds.append(LED(seconds_pin))\\r\\n for minute_pin in m_p:\\r\\n self.minute_leds.append(LED(minute_pin))\\r\\n for hour_pin in h_p:\\r\\n self.hour_leds.append(LED(hour_pin))\\r\\n return\",\n \"def look_for_available_ports():\\n available_ports = glob.glob('/dev/ttyACM*')\\n print(\\\"Available porst: \\\")\\n print(available_ports)\\n\\n return available_ports\",\n \"def port_setup(robot_name, num_cameras):\\n\\tglobal local_in_port\\n\\tglobal local_out_port\\n\\tglobal local_GPS_port\\n\\tglobal local_Dest_port\\n\\n\\tglobal local_in_port_name\\n\\tglobal local_out_port_name\\n\\tglobal local_GPS_port_name\\n\\tglobal local_Dest_port_name\\n\\n\\tglobal local_Radio_in_port\\n\\tglobal local_Radio_out_port\\n\\n\\tglobal ors_in_port_name\\n\\tglobal ors_out_port_name\\n\\tglobal ors_GPS_port_name\\n\\tglobal ors_Dest_port_name\\n\\tglobal ors_Radio_in_port_name\\n\\tglobal ors_Radio_out_port_name\\n\\n\\t# Define the names for all the ports\\n\\tport_prefix = \\\"/ors/robots/\\\" + robot_name + \\\"/\\\"\\n\\tlocal_port_prefix = \\\"/atrv_client/\\\" + robot_name + \\\"/\\\"\\n\\tview_prefix = \\\"/img/\\\" + robot_name + \\\"/\\\"\\n\\n\\tors_in_port_name = port_prefix + \\\"in\\\"\\n\\tors_out_port_name = port_prefix + \\\"out\\\"\\n\\n\\tors_Dest_port_name = port_prefix + \\\"Motion_Controller/in\\\"\\n\\tors_GPS_port_name = port_prefix + \\\"GPS/out\\\"\\n\\n\\tors_Radio_out_port_name = port_prefix + \\\"Radio/out\\\"\\n\\tors_Radio_in_port_name = port_prefix + \\\"Radio/in\\\"\\n\\n\\tlocal_in_port_name = local_port_prefix + \\\"in/\\\"\\n\\tlocal_out_port_name = local_port_prefix + \\\"out/\\\"\\n\\n\\tlocal_GPS_port_name = local_port_prefix + \\\"GPS/in/\\\"\\n\\tlocal_Dest_port_name = local_port_prefix + \\\"Motion_Controller/out/\\\"\\n\\n\\tlocal_Radio_in_port_name = local_port_prefix + \\\"Radio/in\\\"\\n\\tlocal_Radio_out_port_name = local_port_prefix + \\\"Radio/out\\\"\\n\\n\\t# Start the yarp network connection\\n\\tyarp.Network.init()\\n\\n\\t# Open the client ports\\n\\tlocal_in_port = yarp.BufferedPortBottle()\\n\\tlocal_in_port.open(local_in_port_name)\\n\\tlocal_out_port = yarp.BufferedPortBottle()\\n\\tlocal_out_port.open(local_out_port_name)\\n\\n\\tlocal_GPS_port = yarp.BufferedPortBottle()\\n\\tlocal_GPS_port.open(local_GPS_port_name)\\n\\tlocal_Dest_port = yarp.BufferedPortBottle()\\n\\tlocal_Dest_port.open(local_Dest_port_name)\\n\\n\\tlocal_Radio_out_port = yarp.BufferedPortBottle()\\n\\tlocal_Radio_out_port.open(local_Radio_out_port_name)\\n\\tlocal_Radio_in_port = yarp.BufferedPortBottle()\\n\\tlocal_Radio_in_port.open(local_Radio_in_port_name)\\n\\n\\t# Connect the client ports to the simulator ports\\n\\tyarp.Network.connect (local_out_port_name, ors_in_port_name)\\n\\tyarp.Network.connect (ors_out_port_name, local_in_port_name)\\n\\n\\tyarp.Network.connect (ors_GPS_port_name, local_GPS_port_name)\\n\\tyarp.Network.connect (local_Dest_port_name, ors_Dest_port_name)\\n\\n\\tyarp.Network.connect (local_Radio_out_port_name, ors_Radio_in_port_name)\\n\\tyarp.Network.connect (ors_Radio_out_port_name, local_Radio_in_port_name)\\n\\n\\n\\t# Connect the cameras to yarpview windows\\n\\tprint (\\\" * Initializing yarpview windows.\\\")\\n\\tfor id in range(int(num_cameras)):\\n\\t\\t# Build the name of the camera\\n\\t\\tcamera_name = \\\"Camera{0}\\\".format(id+1)\\n\\n\\t\\t# Prepare the ports to be used\\n\\t\\timg_view_port = view_prefix + camera_name\\n\\t\\tatrv_camera_port = port_prefix + camera_name\\n\\n\\t\\tyarp.Network.connect (atrv_camera_port, img_view_port)\",\n \"def rr1_assign_ports():\\n print('******* Assigning ports')\\n for device in ci_addrs.switches_rr1_12:\\n print ('******* Connecting to ', device.get('ip'))\\n net_connect = ConnectHandler(**device)\\n output_vlan_cp = net_connect.send_config_set(cp_rr1_config_commands)\\n print (output_vlan_cp)\\n output_vlan_cloud = net_connect.send_config_set(cloud_rr1_config_commands)\\n print (output_vlan_cloud)\\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\\n print (output_vlan_f5)\\n net_connect.send_config_set('wr')\\n for device in ci_addrs.switches_rr2_12:\\n print ('******* Connecting to ', device.get('ip'))\\n net_connect = ConnectHandler(**device)\\n output_vlan_cp = net_connect.send_config_set(cp_rr1_config_commands)\\n print (output_vlan_cp)\\n output_vlan_cloud = net_connect.send_config_set(cloud_rr2_config_commands)\\n print (output_vlan_cloud)\\n output_vlan_f5 = net_connect.send_config_set(f5_config_commands)\\n print (output_vlan_f5)\\n net_connect.send_config_set('wr') \\n assign_ports_n5k34()\",\n \"def __init__(self, pads):\\n mfioCommon.__init__(self, pads)\\n\\n mfio_width = len(pads)\\n #\\n mfio_o = Signal(mfio_width)\\n mfio_oe = Signal(mfio_width)\\n mfio_i = Signal(mfio_width)\\n # create single pin tristate buffers\\n for b in range(mfio_width):\\n self.submodules += mfioSinglePin(pads, b, mfio_i[b], mfio_o[b], mfio_oe[b]) \\t\\n\\n # Wishbone \\n self.bus = bus = wishbone.Interface()\\n\\n #\\n sel = Signal(mfio_width)\\n inbit = Signal(1)\\n\\n # todo: dynamic address width calc to optimize the decode logic\\n addr_width = 12\\n # 1024 IO max\\n seladr = Signal(10)\\n\\n # 10 bits of address = 1024 pins max\\n self.comb += seladr.eq(self.bus.adr[:10]) \\n \\n # address decoder\\n for b in range(mfio_width):\\n self.comb += sel[b].eq(seladr == b)\\n\\n self.comb += inbit.eq( (mfio_i & sel) != 0 )\\n\\n # Read bit\\n rdbus = Signal(32)\\n self.comb += [\\n rdbus[0].eq(inbit),\\n bus.dat_r.eq(rdbus)\\n ]\\t\\n\\n # process output \\n outbit = Signal(1)\\n oebit = Signal(1)\\n wren = Signal(1)\\n\\n # PINAPI 1.0 compatible: 0 = drive 0, 1 drive 1, 3 = HiZ\\n self.comb += outbit.eq( bus.dat_w[0] )\\n self.comb += oebit.eq ( ~bus.dat_w[1] )\\n\\n # write enable\\n self.comb += wren.eq(self.bus.stb & self.bus.cyc & self.bus.we) \\n\\n for b in range(mfio_width):\\n self.sync += If(wren & sel[b], mfio_o[b].eq(outbit), mfio_oe[b].eq(oebit) )\\n\\n seq = [\\n (1, [bus.ack.eq(1)]), #\\n (1, [bus.ack.eq(0)]), #\\n (0, []),\\n ]\\n \\n t, tseq = 0, []\\n for dt, a in seq:\\n tseq.append((t, a))\\n t += dt\\n\\n self.sync += timeline(bus.cyc & bus.stb, tseq)\",\n \"def Port(self) -> int:\",\n \"def get_port_pullups(self, port):\\n if port == 1:\\n self.__port_b_pullup = self.__bus.read_byte_data(\\n self.__ioaddress, self.GPPUB)\\n return self.__port_b_pullup\\n else:\\n self.__port_a_pullup = self.__bus.read_byte_data(\\n self.__ioaddress, self.GPPUA)\\n return self.__port_a_pullup\\n return\",\n \"def testAllRead(self):\\n import time,copy\\n time.sleep(2)\\n client = ModbusTCP(self.config['vdevs']['slave']['icsifaces'][0],\\n self.config['vdevs']['slave']['points']) \\n\\n pts = copy.deepcopy(self.config['vdevs']['slave']['points'])\\n ptnames = [ pt['name'] for pt in pts ]\\n reply = client.readPoints(ptnames)\\n #print \\\"Reply: \\\", reply\\n for pt in ptnames:\\n value = filter(lambda x: x['name']==pt, pts)[0]['value']\\n #assert value == reply[ptnames.index(pt)]\\n received = reply[ptnames.index(pt)]\\n if not value == received: \\n print pt, ' was %s but should be %s'%(str(received),str(value))\",\n \"def raw_interfaces(self):\\n return self._ports\",\n \"def draw_pins():\\n\\n pass\",\n \"def _GetPorts(self):\\n ports = []\\n for start, end in self.term.destination_port:\\n if start == end:\\n ports.append(str(start))\\n else:\\n ports.append('%d-%d' % (start, end))\\n return ports\",\n \"async def assign_serial_port(self, serial_manager):\\n #logstring(\\\"you are now in assign_serial_port\\\")\\n if serial_manager is None:\\n return\\n\\n if serial_manager.CurrentPort is None:\\n return\\n\\n self._clear_stored_response_dictionaries()\\n\\n self.serial_manager = serial_manager\\n self.serial_port = serial_manager.CurrentPort\\n #to remove, only used for testing right now\\n self.serial_port_name = serial_manager.CurrentPort.com_port\\n\\n # set the read and write handles\\n self.read = self.serial_manager.CurrentPort.read\\n self.write = self.serial_manager.CurrentPort.write\\n\\n self._valid_target_exists = True\\n\\n\\n #keeps a direct reference to the pins\\n self._digital_pins_directly = []\\n self._analog_pins_directly = []\\n\\n #and ports\\n self._ports_directly = []\\n\\n # wait for arduino to go through a reset cycle if need be\\n logstring(\\\"Waiting for 2 seconds...\\\")\\n time.sleep(self.arduino_wait)\\n #logstring(\\\"time is up!\\\")\\n #await asyncio.sleep(self.arduino_wait)\\n\\n # register the get_command method with the event loop\\n self.loop = asyncio.get_event_loop()\\n\\n logstring(\\\"Setting up Firmata on port {}\\\".format(self.serial_port.com_port))\\n\\n # get arduino firmware version and print it\\n logstring(\\\"Checking Firmware version\\\")\\n firmware_version = await self.get_firmware_version()\\n logstring(\\\"Finished checking Firmware version\\\")\\n if not firmware_version:\\n logerr('*** Firmware Version retrieval timed out. ***')\\n logerr('Firmata not found')\\n try:\\n # attempt to autoload firmata here, if fails again, mark the port as error\\n self.disconnect_port_due_to_error()\\n return\\n except RuntimeError:\\n self.disconnect_port_due_to_error()\\n return\\n except TypeError:\\n self.disconnect_port_due_to_error()\\n return\\n logstring(\\\"\\\\nFirmware ID: \\\" + firmware_version)\\n logstring(\\\"On port {}\\\".format(self.serial_port_name))\\n # get an analog pin map\\n\\n # try to get an analog report. if it comes back as none - shutdown\\n # report = await self.get_analog_map()\\n logstring(\\\"Fetching analog mapping\\\")\\n analogreport = await self.get_analog_map()\\n #logstring(\\\"got analog map\\\")\\n if not analogreport:\\n logerr('*** Analog map retrieval timed out. ***')\\n logerr('Analog Pin Mapping not found')\\n try:\\n # attempt to autoload firmata here, if fails again, mark the port as error\\n self.disconnect_port_due_to_error()\\n return\\n except RuntimeError:\\n self.disconnect_port_due_to_error()\\n return\\n except TypeError:\\n self.disconnect_port_due_to_error()\\n return\\n\\n capabilityreport = await self.get_capability_report()\\n if not capabilityreport:\\n logerr('*** Capability Report retrieval timed out. ***')\\n logerr('Capability Report not found')\\n try:\\n # attempt to autoload firmata here, if fails again, mark the port as error\\n self.disconnect_port_due_to_error()\\n return\\n except RuntimeError:\\n self.disconnect_port_due_to_error()\\n return\\n except TypeError:\\n self.disconnect_port_due_to_error()\\n return\\n # custom assemble the pin lists\\n pininfo = iter(capabilityreport)\\n\\n\\n self._nested_objects = []\\n\\n\\n for i, analogpinmapping in enumerate(analogreport):\\n #set up the data structure that captures data that comes from Firmata\\n digital_data = PinData()\\n self.digital_pins.append(digital_data)\\n HasAnalog = False\\n analog_data = PinData()\\n self.analog_pins.append(analog_data)\\n if analogpinmapping != Constants.IGNORE:\\n self.analog_pins_analog_numbering.append(analog_data)\\n HasAnalog = True\\n #set up the data structure that captures data to be sent to Firmata\\n port_num = math.floor(i/8)\\n pin_num_within_port = i%8\\n HasInput = False\\n HasOutput = False\\n HasPullup = False\\n HasAnalog2 = False\\n AnalogResolution = 0\\n AnalogPinNum = 127\\n HasPWM = False\\n PWMResolution = 0\\n HasI2C = False\\n try:\\n nextbyte = next(pininfo)\\n while nextbyte != 127: #127 signals the end of the information for a pin\\n resolutionbyte = next(pininfo)\\n if nextbyte == Constants.INPUT:\\n HasInput = True\\n if nextbyte == Constants.OUTPUT:\\n HasOutput = True\\n if nextbyte == Constants.PULLUP:\\n HasPullup = True\\n if nextbyte == Constants.ANALOG:\\n HasAnalog2 = True\\n AnalogResolution = resolutionbyte\\n AnalogPinNum = analogpinmapping\\n if nextbyte == Constants.PWM:\\n HasPWM = True,\\n PWMResolution=14\\n if nextbyte == Constants.SERVO:\\n pass\\n #nothing to do. we treat it like an OUTPUT\\n #resolution is fixed...may do something with this\\n #in the future if there are issues with some platform?\\n if nextbyte == Constants.I2C:\\n HasI2C = True\\n nextbyte = next(pininfo)\\n except StopIteration:\\n pass\\n\\n if HasAnalog2 != HasAnalog:\\n #this really shouldn't happen, but might as well catch it anyway\\n raise Exception(\\\"The Analog Pin Map disagrees with the Capabilty Report as to whether pin {} is an analog pin\\\".format(i))\\n\\n #this sets the pin number 0-7 within each port\\n if pin_num_within_port == 0: #Yay, new port, create it:\\n current_port = Port(\\\"Port {}\\\".format(port_num),\\n port_num)\\n self._nested_objects.append(current_port)\\n self._ports_directly.append(current_port)\\n\\n newpin = Pin(ID = \\\"Pin {} of Port {} hasanalog = {}\\\".format(pin_num_within_port,\\n port_num, HasAnalog),\\n PinNum = i, HasInput=HasInput,\\n HasPullup=HasPullup, HasOutput=HasOutput,\\n HasAnalog=HasAnalog, AnalogPinNum=analogpinmapping,\\n AnalogResolution=AnalogResolution, HasPWM=HasPWM,\\n PWMResolution=PWMResolution, HasI2C=HasI2C)\\n current_port.pins.append(newpin)\\n self._digital_pins_directly.append(newpin)\\n logstring(\\\"Appending a new pin {} len {}\\\".format(newpin._ID, len(self._digital_pins_directly)))\\n if HasAnalog:\\n self._analog_pins_directly.append(newpin)\\n\\n\\n\\n logstring('Auto-discovery complete. Found ' + \\\\\\n str(len(self.digital_pins)) + ' Digital Pins and ' + \\\\\\n str(len(self.analog_pins_analog_numbering)) + ' Analog Pins')\\n\\n self._numpins = len(self.digital_pins)\\n self._numports = math.ceil(self._numpins/8)\\n\\n\\n self.KeepAlive = KeepAlive(\\\"Keep Alive\\\")\\n self._nested_objects.append(self.KeepAlive)\\n\\n self.Tone = Tone(\\\"Tone\\\", self._numpins)\\n self._nested_objects.append(self.Tone)\\n\\n #self.EncoderConfig = EncoderConfig(\\\"Encoder Config\\\", self._numpins)\\n #self._nested_objects.append(self.EncoderConfig)\",\n \"def main(self) :\\n\\n # Close the serial port in case the previous run didn't closed it properly\\n self.serialPortDWM1001_1.close()\\n self.serialPortDWM1001_2.close()\\n \\n # Sleep for one sec\\n time.sleep(1)\\n \\n # Open serial port\\n self.serialPortDWM1001_1.open()\\n self.serialPortDWM1001_2.open()\\n\\n # Check if the serial port is opened\\n if(self.serialPortDWM1001_1.isOpen()):\\n rospy.loginfo(\\\"Port `O` opened: {}\\\".format(self.serialPortDWM1001_1.name) )\\n else:\\n rospy.logerr(\\\"Can't open port `O`: {}\\\".format(self.serialPortDWM1001_1.name))\\n \\n if(self.serialPortDWM1001_2.isOpen()):\\n rospy.loginfo(\\\"Port `P` opened: {}\\\".format(self.serialPortDWM1001_2.name) )\\n else:\\n rospy.logerr(\\\"Can't open port `P`: {}\\\".format(self.serialPortDWM1001_2.name))\\n\\n try: \\n tags = ['A', 'B', 'C', 'D']\\n # Counting the msgs received and processed to check the system status\\n msg_portO_cnt = [0,0,0,0]\\n msg_portP_cnt = [0,0,0,0]\\n while not rospy.is_shutdown():\\n self.serialPortDWM1001_1.write(\\\"S\\\".encode())\\n # just read everything from serial port \\n for _ in range(4): \\n serialReadLine = self.serialPortDWM1001_1.read_until()\\n # print(serialReadLine)\\n if not serialReadLine:\\n rospy.logwarn(\\\"Port O: Read a empty line from Serial Port\\\")\\n continue\\n self.publishTagPositions('O',serialReadLine)\\n msg_portO_cnt[tags.index(serialReadLine[9])] += 1\\n self.rate.sleep()\\n\\n self.serialPortDWM1001_2.write(\\\"S\\\".encode()) \\n for _ in range(4): \\n serialReadLine = self.serialPortDWM1001_2.read_until()\\n #print(serialReadLine)\\n if not serialReadLine:\\n rospy.logwarn(\\\"Port P: Read a empty line from Serial Port\\\")\\n continue\\n self.publishTagPositions('P',serialReadLine) \\n msg_portP_cnt[tags.index(serialReadLine[9])] += 1 \\n self.rate.sleep()\\n\\n if sum(msg_portO_cnt) > 100 and self.verbose :\\n rospy.loginfo(\\\"All OK. Done O-> {}, P-> {} times !\\\".format(msg_portO_cnt, msg_portP_cnt))\\n msg_portO_cnt = [0,0,0,0]\\n msg_portP_cnt = [0,0,0,0]\\n\\n finally:\\n rospy.loginfo(\\\"Quitting, and sending reset command to dev board\\\")\",\n \"def _init_io(self):\\n GPIO.setwarnings(False)\\n GPIO.setmode( GPIO.BCM )\\n pins = [ self._spi_dc ]\\n for pin in pins:\\n GPIO.setup( pin, GPIO.OUT )\",\n \"def list_ports():\\n non_working_ports = []\\n dev_port = 0\\n working_ports = []\\n available_ports = []\\n while len(non_working_ports) < 6: # if there are more than 5 non working ports stop the testing. \\n camera = cv2.VideoCapture(dev_port)\\n if not camera.isOpened():\\n non_working_ports.append(dev_port)\\n print(\\\"Port %s is not working.\\\" %dev_port)\\n else:\\n is_reading, img = camera.read()\\n w = camera.get(3)\\n h = camera.get(4)\\n if is_reading:\\n print(\\\"Port %s is working and reads images (%s x %s)\\\" %(dev_port,h,w))\\n working_ports.append(dev_port)\\n else:\\n print(\\\"Port %s for camera ( %s x %s) is present but does not reads.\\\" %(dev_port,h,w))\\n available_ports.append(dev_port)\\n dev_port +=1\\n return available_ports,working_ports,non_working_ports\",\n \"def presetRead():\\n\\n global preset_sw \\n \\n while True:\\n for i in range(6):\\n preset_sw[i][1] = GPIO.input(preset_sw[i][0])\\n sleep (1)\",\n \"def resolve(self):\\n # Find defines for all ports\\n for port_name, port in self.ports.items():\\n if not isinstance(port, ElemExportPort):\\n print('hha')\\n for k, p in port.items():\\n name, bit_range = k\\n if p:\\n continue\\n not_find = True\\n for io_list in self.all_io.values():\\n if name in io_list:\\n port[k] = io_list[name]\\n not_find = False\\n break\\n if not_find:\\n raise VlogSyntaxError('A port defined in port list of module is NOT defined as input/output/inout')\",\n \"def write(self):\\n mask = 0\\n for pin in self.pins:\\n if pin.mode == OUTPUT:\\n if pin.value == 1:\\n pin_nr = pin.pin_number - self.port_number * 8\\n mask |= 1 << pin_nr\\n msg = chr(DIGITAL_MESSAGE + self.port_number)\\n msg += chr(mask % 128)\\n msg += chr(mask >> 7)\\n self.board.sp.write(msg)\",\n \"def xtest_find_port(self):\\n line, head = self._get_line()\\n p1, p2, p3, p4 = self.box1.ports()\\n\\n head.pos = 110, 50\\n port = self.tool.find_port(line, head, self.box1)\\n self.assertEquals(p1, port)\\n\\n head.pos = 140, 60\\n port = self.tool.find_port(line, head, self.box1)\\n self.assertEquals(p2, port)\\n\\n head.pos = 110, 95\\n port = self.tool.find_port(line, head, self.box1)\\n self.assertEquals(p3, port)\\n\\n head.pos = 100, 55\\n port = self.tool.find_port(line, head, self.box1)\\n self.assertEquals(p4, port)\",\n \"def _read(self, pin):\\n # Immediately return conversion register result if in CONTINUOUS mode\\n # and pin has not changed\\n if self.mode == Mode.CONTINUOUS and self._last_pin_read == pin:\\n raw_adc = self._read_register(_ADS1X15_POINTER_CONVERSION, True)\\n raw_adc = raw_adc.to_bytes(2, \\\"big\\\")\\n return struct.unpack(\\\">h\\\", raw_adc)[0] >> self._shift_fact\\n\\n # Assign last pin read if in SINGLE mode or first sample in CONTINUOUS\\n # mode on this pin\\n self._last_pin_read = pin\\n\\n # Configure ADC every time before a conversion in SINGLE mode\\n # or changing channels in CONTINUOUS mode\\n config = _ADS1X15_CONFIG_OS_SINGLE if self.mode == Mode.SINGLE else 0\\n config |= (pin & 0x07) << _ADS1X15_CONFIG_MUX_OFFSET\\n config |= _ADS1X15_CONFIG_GAIN[self.gain]\\n config |= self.mode\\n config |= self.rate_config[self.data_rate]\\n config |= _ADS1X15_CONFIG_COMP_QUE_DISABLE\\n self._write_register(_ADS1X15_POINTER_CONFIG, config)\\n\\n # Wait for conversion to complete\\n # ADS1x1x devices settle within a single conversion cycle\\n if self.mode == Mode.SINGLE:\\n # Continuously poll conversion complete status bit\\n #while not self._conversion_complete():\\n while not self._read_register(_ADS1X15_POINTER_CONFIG) & 0x8000:\\n pass\\n else:\\n # Can't poll registers in CONTINUOUS mode\\n # Wait expected time for two conversions to complete\\n time.sleep(2 /self.data_rate)\\n\\n raw_adc = self._read_register(_ADS1X15_POINTER_CONVERSION, False)\\n raw_adc = raw_adc.to_bytes(2, \\\"big\\\")\\n return struct.unpack(\\\">h\\\", raw_adc)[0] >> self._shift_fact\",\n \"def read_all_ram_ports(self):\\n return self.RAM_PORT\",\n \"def read_pin10(self):\\n return self.PIN_10_SIGNAL_TEST\",\n \"def run(outs, ins_filter='/dev/ttyUSB.*', newport=lambda conn: None, write_queue=None):\\r\\n data_queue = multiprocessing.Queue()\\r\\n\\r\\n multiprocessing.Process(\\r\\n target=writer,\\r\\n args=(data_queue, write_queue, outs)\\r\\n ).start()\\r\\n\\r\\n readers = {}\\r\\n\\r\\n while True:\\r\\n\\r\\n for (path, _, _) in serial.tools.list_ports.grep(ins_filter):\\r\\n\\r\\n if path not in readers.keys() or not readers[path].is_alive():\\r\\n\\r\\n readers[path] = multiprocessing.Process(\\r\\n target=reader, args=(data_queue, path, newport)\\r\\n )\\r\\n readers[path].start()\",\n \"def pins_to_address(A2,A1,A0):\\n if not all(pin in [0,1] for pin in [A2,A1,A0]): # Check pins are 1 or 0\\n raise I2CException(\\\"Pins should be specified as 1 or 0\\\")\\n return (0b1101000 | (A2 << 2) | (A1 << 1) | A0)\",\n \"def read_live_data(wearable_port):\\r\\n IMU1_num = []\\r\\n IMU2_num = []\\r\\n IMU3_num = []\\r\\n\\r\\n try:\\r\\n wearable = serial.Serial(wearable_port, baudrate=115200, timeout=5)\\r\\n #arduino = serial.Serial(arduino_port, timeout=1)\\r\\n # Delay for 2 seconds to wait for serial port to be ready.\\r\\n print(\\\"Waiting 2 seconds for serial to be ready.\\\")\\r\\n time.sleep(2)\\r\\n except Exception as e:\\r\\n print(e)\\r\\n print('Please check the port')\\r\\n return\\r\\n\\r\\n input(\\\"Press Enter to continue...\\\")\\r\\n str(wearable.write(bytes(33)))\\r\\n # Open file to store the data; filename includes date and time; format: data-YYYYMMDDHHmmss.csv\\r\\n filename = \\\"data-\\\" + str(dt.datetime.now().strftime(\\\"%Y%m%d%H%M%S\\\")) + \\\".csv\\\"\\r\\n filenamplot = \\\"plot-\\\" + str(dt.datetime.now().strftime(\\\"%Y%m%d%H%M%S\\\")) + \\\".png\\\"\\r\\n print(\\\"Opening %s\\\" % filename)\\r\\n f = open(filename, \\\"a+\\\")\\r\\n # f.write(\\\"power,rpm\\\\n\\\")\\r\\n count = 1000\\r\\n # Get data and continuously yield Power and RPM as integers\\r\\n\\r\\n while (count >0):\\r\\n count = count -1\\r\\n #if arduino.in_waiting > 0:\\r\\n wearable.flushInput()\\r\\n\\r\\n '''\\r\\n arduino_output = arduino.readline().decode(\\\"utf_8\\\", \\\"strict\\\")\\r\\n print(\\\"Distance: %s\\\" % arduino_output)\\r\\n f.writelines(\\\"%s\\\" % arduino_output)\\r\\n if arduino_output == \\\"Hard Stop\\\\r\\\\n\\\":\\r\\n break\\r\\n arduino_output = arduino_output.replace(\\\"\\\\r\\\\n\\\", \\\"\\\")\\r\\n Distance.append(int(float(arduino_output)))\\r\\n '''\\r\\n\\r\\n try:\\r\\n data = wearable.readline().decode(\\\"utf_8\\\", \\\"strict\\\")\\r\\n data = data.replace(\\\"\\\\r\\\\n\\\", \\\"\\\\n\\\").split()\\r\\n IMU1= data[2].replace(\\\"\\\\n\\\", \\\"\\\")\\r\\n IMU1_num.append(int(IMU1))\\r\\n IMU2 = data[3].replace(\\\"\\\\n\\\", \\\"\\\")\\r\\n IMU2_num.append(int(IMU2))\\r\\n IMU3 = data[4].replace(\\\"\\\\n\\\", \\\"\\\")\\r\\n IMU3_num.append(int(IMU3))\\r\\n print(\\\"IMU1: %s\\\\t IMU2: %s\\\\t IMU3: %s\\\\t\\\" % (IMU1, IMU2, IMU3))\\r\\n f.writelines(\\\"%s,%s,%s,%s\\\\n\\\" % (IMU1, IMU2, IMU3))\\r\\n yield int(IMU1), int(IMU2), int(IMU3)\\r\\n except Exception as e:\\r\\n print('error')\\r\\n f.writelines(\\\"Error\\\\n\\\")\\r\\n\\r\\n print('Program ended.')\\r\\n t = numpy.linspace(1, len(IMU1_num), len(IMU1_num))\\r\\n fig, (ax1) = plt.subplots(nrows=1, ncols=1, figsize=(16.0, 9.0)) # create figure & 1 axis\\r\\n ax1.plot(t, IMU1_num, t, IMU2_num,t, IMU3_num)\\r\\n ax1.set_title('IMU')\\r\\n ax1.legend(('IMU1', 'IMU2', 'IMU3'))\\r\\n # manager = plt.get_current_fig_manager()\\r\\n # manager.resize(*manager.window.maxsize())\\r\\n fig.savefig(filenamplot)\\r\\n plt.show()\\r\\n\\r\\n f.close()\\r\\n #arduino.close()\\r\\n wearable.close()\",\n \"def get_ports():\\r\\n ports = serial.tools.list_ports.comports()\\r\\n return ports\",\n \"def auto_discover_board(self, verbose):\\n # get current time\\n start_time = time.time()\\n\\n # wait for up to 30 seconds for a successful capability query to occur\\n\\n while len(self.analog_mapping_query_results) == 0:\\n if time.time() - start_time > 30:\\n return False\\n # keep sending out a capability query until there is a response\\n self.send_sysex(self.ANALOG_MAPPING_QUERY, None)\\n time.sleep(.1)\\n\\n if verbose:\\n print(\\\"Board initialized in %d seconds\\\" % (time.time() - start_time))\\n\\n for pin in self.analog_mapping_query_results:\\n self.total_pins_discovered += 1\\n # non analog pins will be marked as IGNORE\\n if pin != self.pymata.IGNORE:\\n self.number_of_analog_pins_discovered += 1\\n\\n if verbose:\\n print('Total Number of Pins Detected = %d' % self.total_pins_discovered)\\n print('Total Number of Analog Pins Detected = %d' % self.number_of_analog_pins_discovered)\\n\\n # response table initialization\\n # for each pin set the mode to input and the last read data value to zero\\n for pin in range(0, self.total_pins_discovered):\\n response_entry = [self.pymata.INPUT, 0, None]\\n self.digital_response_table.append(response_entry)\\n\\n for pin in range(0, self.number_of_analog_pins_discovered):\\n response_entry = [self.pymata.INPUT, 0, None]\\n self.analog_response_table.append(response_entry)\\n\\n # set up latching tables\\n for pin in range(0, self.total_pins_discovered):\\n digital_latch_table_entry = [0, 0, 0, 0, None]\\n self.digital_latch_table.append(digital_latch_table_entry)\\n\\n for pin in range(0, self.number_of_analog_pins_discovered):\\n analog_latch_table_entry = [0, 0, 0, 0, 0, None]\\n self.analog_latch_table.append(analog_latch_table_entry)\\n\\n return True\",\n \"def gpio_get(self, pins=None):\\n if pins is None:\\n pins = range(4)\\n\\n size = len(pins)\\n indices = (ctypes.c_uint8 * size)(*pins)\\n statuses = (ctypes.c_uint8 * size)()\\n result = self._dll.JLINK_EMU_GPIO_GetState(ctypes.byref(indices),\\n ctypes.byref(statuses),\\n size)\\n if result < 0:\\n raise errors.JLinkException(result)\\n\\n return list(statuses)\",\n \"def scan_serial(self,event):\\n if str(platform.system()) == 'Windows':\\n tempList = ['COM%s' % (i + 1) for i in range(256)]\\n elif str(platform.system()) == 'Linux':\\n tempList = glob.glob('/dev/tty[A-Za-z]*')\\n elif str(platform.system()) == 'Darwin':\\n tempList = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError(\\\"Unsupported platform\\\")\\n\\n results = []\\n for a_port in tempList:\\n try:\\n s = serial.Serial(a_port)\\n s.close()\\n results.append(a_port)\\n except serial.SerialException:\\n pass\\n return results\",\n \"def __init__(self, red_pin, green_pin, blue_pin):\\n #self.red = gpiozero.PWMLED(red_pin, frequency=80, initial_value=1)\\n #self.green = gpiozero.PWMLED(green_pin, frequency=80, initial_value=1)\\n #self.blue = gpiozero.PWMLED(blue_pin, frequency=80, initial_value=1)\\n self.red = gpiozero.LED(red_pin)\\n self.green = gpiozero.LED(green_pin)\\n self.blue = gpiozero.LED(blue_pin)\\n self.leds = [self.red, self.green, self.blue]\\n self.off()\",\n \"def serial_ports():\\n\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith(\\n 'cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def setup_gpio(self):\\n for row in self._rows:\\n GPIO.setup(row, GPIO.IN, pull_up_down=GPIO.PUD_UP)\\n for coll in self._colls:\\n GPIO.setup(coll, GPIO.OUT)\\n GPIO.output(coll, 1)\",\n \"def pin_read(self, pin, mode=gpio.INPUT):\\n port_num = self._convert_pin_port(pin)\\n if port_num:\\n gpio.setcfg(port_num, gpio.INTPUT)\\n value = gpio.input(port_num)\\n return value\",\n \"def read(self, pin, is_differential=False):\\n\\n self.cs.value(0) # select\\n self._out_buf[1] = ((not is_differential) << 7) | (pin << 4)\\n self._spi.write_readinto(self._out_buf, self._in_buf)\\n self.cs.value(1) # turn off\\n return ((self._in_buf[1] & 0x03) << 8) | self._in_buf[2]\",\n \"def __init__(self, pin1=24, pin2=28, pin3=25, pin4=33):\\n self.GP = GPIOProcessor()\\n self.pin1 = self.GP.getPin(pin1)\\n self.pin2 = self.GP.getPin(pin2)\\n self.pin3 = self.GP.getPin(pin3)\\n self.pin4 = self.GP.getPin(pin4)\\n self.pinl = [self.pin1, self.pin2, self.pin3, self.pin4]\\n\\n for k in range(4):\\n self.pinl[k].out()\\n\\n self.speed = 100.0\",\n \"def add_layout_pins(self):\\n en_offset = self.dc_inst.get_pin(\\\"in\\\").ll()\\n self.add_layout_pin(text=\\\"en\\\",\\n layer=\\\"metal1\\\",\\n offset=en_offset.scale(1,0),\\n width=self.m1_width,\\n height=en_offset.y)\\n\\n out_offset = self.rbl_inv_inst.get_pin(\\\"Z\\\").ll()\\n self.add_layout_pin(text=\\\"out\\\",\\n layer=\\\"metal1\\\",\\n offset=out_offset.scale(1,0),\\n width=self.m1_width,\\n height=out_offset.y)\",\n \"def read_dht11_dat():\\n GPIO.setup(DHTPIN, GPIO.OUT)\\n GPIO.output(DHTPIN, GPIO.HIGH)\\n time.sleep(0.05)\\n GPIO.output(DHTPIN, GPIO.LOW)\\n time.sleep(0.02)\\n GPIO.setup(DHTPIN, GPIO.IN, GPIO.PUD_UP)\\n\\n unchanged_count = 0\\n last = -1\\n data = []\\n while True:\\n current = GPIO.input(DHTPIN)\\n data.append(current)\\n if last != current:\\n unchanged_count = 0\\n last = current\\n else:\\n unchanged_count += 1\\n if unchanged_count > MAX_UNCHANGE_COUNT:\\n break\\n\\n state = STATE_INIT_PULL_DOWN\\n\\n lengths = []\\n current_length = 0\\n\\n for current in data:\\n current_length += 1\\n\\n if state == STATE_INIT_PULL_DOWN:\\n if current == GPIO.LOW:\\n state = STATE_INIT_PULL_UP\\n else:\\n continue\\n if state == STATE_INIT_PULL_UP:\\n if current == GPIO.HIGH:\\n state = STATE_DATA_FIRST_PULL_DOWN\\n else:\\n continue\\n if state == STATE_DATA_FIRST_PULL_DOWN:\\n if current == GPIO.LOW:\\n state = STATE_DATA_PULL_UP\\n else:\\n continue\\n if state == STATE_DATA_PULL_UP:\\n if current == GPIO.HIGH:\\n current_length = 0\\n state = STATE_DATA_PULL_DOWN\\n else:\\n continue\\n if state == STATE_DATA_PULL_DOWN:\\n if current == GPIO.LOW:\\n lengths.append(current_length)\\n state = STATE_DATA_PULL_UP\\n else:\\n continue\\n if len(lengths) != 40:\\n # print \\\"Data not good, skip\\\"\\n return False\\n\\n shortest_pull_up = min(lengths)\\n longest_pull_up = max(lengths)\\n halfway = (longest_pull_up + shortest_pull_up) / 2\\n bits = []\\n the_bytes = []\\n byte = 0\\n\\n for length in lengths:\\n bit = 0\\n if length > halfway:\\n bit = 1\\n bits.append(bit)\\n # print \\\"bits: %s, length: %d\\\" % (bits, len(bits))\\n for i in range(0, len(bits)):\\n byte = byte << 1\\n if (bits[i]):\\n byte = byte | 1\\n else:\\n byte = byte | 0\\n if ((i + 1) % 8 == 0):\\n the_bytes.append(byte)\\n byte = 0\\n # print the_bytes\\n checksum = (the_bytes[0] + the_bytes[1] + the_bytes[2] + the_bytes[3]) & 0xFF\\n if the_bytes[4] != checksum:\\n # print \\\"Data not good, skip\\\"\\n return False\\n\\n return the_bytes[0], the_bytes[2]\",\n \"def get_all_pins(self):\\n return self.allpins\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n result = []\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n result.append('COM' + str(i + 1))\\n except serial.SerialException:\\n pass\\n return result\\n\\n elif sys.platform.startswith('linux'):\\n return glob.glob('/dev/rf*')\\n\\n elif sys.platform.startswith('darwin'):\\n return glob.glob('/dev/tty.*')\",\n \"def analogRead(port):\\n spi.open(0, 0)\\n if (port > 7) or (port < 0):\\n print 'analogRead -- Port Error, Must use a port between 0 and 7'\\n return -1\\n r = spi.xfer2([1, (8 + port) << 4, 0])\\n value = ((r[1] & 3) << 8) + r[2]\\n spi.close()\\n return value\",\n \"def __init__(self, pinForward1, pinBackward1,pinForward2, pinBackward2):\\n\\n self.pinForward1 = pinForward1\\n self.pinBackward1 = pinBackward1\\n self.pinForward2 = pinForward2\\n self.pinBackward2 = pinBackward2\\n\\n GPIO.setup(self.pinForward1, GPIO.OUT)\\n GPIO.setup(self.pinBackward1, GPIO.OUT)\\n GPIO.setup(self.pinForward2, GPIO.OUT)\\n GPIO.setup(self.pinBackward2, GPIO.OUT)\\n\\n self.pwm_forward1 = GPIO.PWM(self.pinForward1, 100)\\n self.pwm_backward1 = GPIO.PWM(self.pinBackward1, 100)\\n self.pwm_forward2 = GPIO.PWM(self.pinForward2, 100)\\n self.pwm_backward2 = GPIO.PWM(self.pinBackward2, 100)\\n \\n self.pwm_forward1.start(0)\\n self.pwm_backward1.start(0)\\n self.pwm_forward2.start(0)\\n self.pwm_backward2.start(0)\",\n \"def setup():\\n GPIO.setmode(GPIO.BCM)\\n for pin in [CHURCH, CHURCH + 1, HALL, HALL + 1]:\\n GPIO.setup(pin, GPIO.OUT, initial=GPIO.HIGH)\",\n \"def compass_multi(size = (4, 2), ports = {'N':3,'S':4}, layer = 0):\\n D = Device(name = 'compass_multi')\\n r = D.add_ref(rectangle(size, layer = layer))\\n r.center = (0, 0)\\n\\n dx = size[0]/2\\n dy = size[1]/2\\n\\n if 'N' in ports:\\n num_ports = ports['N']\\n m = dx - dx/num_ports\\n p_list = np.linspace(-m, m, num_ports)\\n [D.add_port(name = ('N%s' % (n+1)), midpoint = [p, dy],\\n width = dx/num_ports * 2, orientation = 90)\\n for n, p in enumerate(p_list)]\\n if 'S' in ports:\\n num_ports = ports['S']\\n m = dx - dx/num_ports\\n p_list = np.linspace(-m, m, num_ports)\\n [D.add_port(name = ('S%s' % (n+1)), midpoint = [p, -dy],\\n width = dx/num_ports * 2, orientation = -90)\\n for n, p in enumerate(p_list)]\\n if 'E' in ports:\\n num_ports = ports['E']\\n m = dy - dy/num_ports\\n p_list = np.linspace(-m, m, num_ports)\\n [D.add_port(name = ('E%s' % (n+1)), midpoint = [dx, p],\\n width = dy/num_ports * 2, orientation = 0)\\n for n, p in enumerate(p_list)]\\n if 'W' in ports:\\n num_ports = ports['W']\\n m = dy - dy/num_ports\\n p_list = np.linspace(-m, m, num_ports)\\n [D.add_port(name = ('W%s' % (n+1)), midpoint = [-dx, p],\\n width = dy/num_ports * 2, orientation = 180)\\n for n, p in enumerate(p_list)]\\n\\n return D\",\n \"def GPIOsetup():\\n GPIO.setmode(GPIO.BOARD)\\n for led in (RED,YELLOW,GREEN):\\n GPIO.setup(LED[led],GPIO.OUT)\",\n \"def serial_ports():\\r\\n\\tif sys.platform.startswith('win'):\\r\\n\\t\\tports = ['COM%s' % (i + 1) for i in range(256)]\\r\\n\\telif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\r\\n\\t\\t# this excludes your current terminal \\\"/dev/tty\\\"\\r\\n\\t\\tports = glob.glob('/dev/tty[A-Za-z]*')\\r\\n\\telif sys.platform.startswith('darwin'):\\r\\n\\t\\tports = glob.glob('/dev/cu.usb*')\\r\\n\\telse:\\r\\n\\t\\traise EnvironmentError('Unsupported platform')\\r\\n\\r\\n\\tresult = []\\r\\n\\tfor port in ports:\\r\\n\\t\\t#print(port)\\r\\n\\t\\ttry:\\r\\n\\t\\t\\ts = serial.Serial(port)\\r\\n\\t\\t\\ts.close()\\r\\n\\t\\t\\tresult.append(port)\\r\\n\\t\\texcept (OSError, serial.SerialException):\\r\\n\\t\\t\\tpass\\r\\n\\treturn result\",\n \"def hh_assign_ports():\\n print('******* Assigning ports')\\n for device in ci_addrs.switches_hh1:\\n print ('******* Connecting to ', device.get('ip'))\\n net_connect = ConnectHandler(**device)\\n output_vlan_cp = net_connect.send_config_set(cp_hh1_config_commands)\\n print (output_vlan_cp)\\n output_vlan_cloud = net_connect.send_config_set(cloud_hh1_config_commands)\\n print (output_vlan_cloud)\\n output_vlan_f5 = net_connect.send_config_set(f5_hh_config_commands)\\n print (output_vlan_f5)\\n net_connect.send_config_set('wr')\\n\\n for device in ci_addrs.switches_hh2:\\n print ('******* Connecting to ', device.get('ip'))\\n net_connect = ConnectHandler(**device)\\n output_vlan_cp = net_connect.send_config_set(cp_hh2_config_commands)\\n print (output_vlan_cp)\\n output_vlan_cloud = net_connect.send_config_set(cloud_hh2_config_commands)\\n print (output_vlan_cloud)\\n output_vlan_f5 = net_connect.send_config_set(f5_hh_config_commands)\\n print (output_vlan_f5)\\n net_connect.send_config_set('wr')\",\n \"def _update(self, mask):\\n if self.reporting:\\n for pin in self.pins:\\n if pin.mode is INPUT:\\n pin_nr = pin.pin_number - self.port_number * 8\\n pin.value = (mask & (1 << pin_nr)) > 0\",\n \"def __init__(__self__, *,\\n from_port: pulumi.Input[int],\\n to_port: pulumi.Input[int]):\\n pulumi.set(__self__, \\\"from_port\\\", from_port)\\n pulumi.set(__self__, \\\"to_port\\\", to_port)\",\n \"def _convert_pin_port(self, pin):\\n if pin in dir(port):\\n port_num = getattr(port, pin)\\n elif pin in dir(connector):\\n port_num = getattr(connector, pin)\\n else:\\n errmsg = \\\"Unknown pin {}\\\".format(pin)\\n self._logger.error(errmsg)\\n return 0\\n return port_num\",\n \"def s_read(self, timeout = 1):\\n if self.s.is_open:\\n data = [] \\n b = bytearray()\\n try:\\n self.s.timeout = 3\\n data = self.s.read(1)\\n \\n if not len(data):\\n return b\\n\\n self.s.timeout = .04\\n data += self.s.read(500)\\n except Exception as e:\\n print(\\\"Could not read from port\\\" + str(e))\\n\\n start = data.find(b'\\\\x7e')\\n end = data.find(b'\\\\x7f')\\n\\n txt_start = b''\\n txt_end = b''\\n if start < 0:\\n txt_start = data\\n elif end < 0:\\n txt_start = data\\n else:\\n txt_start = data[0:start]\\n txt_end = data[end+1:]\\n\\n txt = txt_start + txt_end\\n if len(txt):\\n if self.log_ascii:\\n self.logfile.write(txt)\\n\\n # End logging \\n if Connection.START_UP_STRING in data:\\n raise Reset_Exception('ChipSHOUTER unit has reset - wait 5 seconds then reinitialize.') \\n\\n if start < 0 or end < 0 or end < start:\\n b = bytearray()\\n return b\\n if self.log_input:\\n self.logfile.write('\\\\nIN :' + str(len(data)) + '[' + hexlify(data) + ']' + '\\\\n')\\n b.extend(data[start:end])\\n return b\\n else:\\n raise IOError('Comport is not open, use ctl_connect()')\",\n \"def connect_ports(self, port1_name: str, ip1_name: str,\\n port2_name: str, ip2_name: str):\\n if (ip1_name not in self._ips.keys() or\\n ip2_name not in self._ips.keys()):\\n raise ValueError(\\n f'No such IP in this module: {ip1_name}, {ip2_name}.'\\n ' Use add_ip method to add the IPs first')\\n # get the 'WrapperPort's\\n port1 = self._ips[ip1_name].get_port_by_name(port1_name)\\n port2 = self._ips[ip2_name].get_port_by_name(port2_name)\\n\\n if len(port1) != len(port2):\\n warning(f'ports: {ip1_name}:{port1.name}({len(port1)}), '\\n f'{ip2_name}:{port2.name}({len(port2)})'\\n ' have different widths!')\\n\\n inst1_args = getattr(self, ip1_name)\\n inst2_args = getattr(self, ip2_name)\\n\\n full_name1 = port_direction_to_prefix(port1.direction) + port1.name\\n full_name2 = port_direction_to_prefix(port2.direction) + port2.name\\n\\n # If a port was connected previoulsy,\\n # take the previoulsy created signal, instead of creating a new one\\n if full_name1 in inst1_args.keys():\\n sig = inst1_args[full_name1]\\n elif full_name2 in inst2_args.keys():\\n sig = inst2_args[full_name2]\\n else:\\n # neither of the ports was connected previously\\n # create a new signal for the connection\\n combined_name = port1.name + '_' + port2.name\\n self._signals_between_ips.append(combined_name)\\n sig = Signal(len(port1), name=combined_name)\\n setattr(self, combined_name, sig)\\n\\n inst1_args[full_name1] = sig\\n inst2_args[full_name2] = sig\",\n \"async def _digital_message(self, data):\\n port = data[0]\\n port_data = (data[PrivateConstants.MSB] << 7) + \\\\\\n data[PrivateConstants.LSB]\\n pin = port * 8\\n for pin in range(pin, min(pin + 8, len(self.digital_pins))):\\n # get pin value\\n value = port_data & 0x01\\n\\n # set the current value in the pin structure\\n self.digital_pins[pin].current_value = value\\n\\n # append pin number, pin value, and pin type to return value and return as a list\\n message = [pin, value, Constants.INPUT]\\n\\n if self.digital_pins[pin].cb:\\n if self.digital_pins[pin].cb_type:\\n await self.digital_pins[pin].cb(message)\\n else:\\n # self.digital_pins[pin].cb(data)\\n loop = self.loop\\n loop.call_soon(self.digital_pins[pin].cb, message)\\n\\n # is there a latch entry for this pin?\\n key = 'D' + str(pin)\\n if key in self.latch_map:\\n await self._check_latch_data(key, port_data & 0x01)\\n port_data >>= 1\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def read(pin):\\n return _read_value(\\\"{0}/gpio{1}/value\\\".format(_path_prefix, pin))\",\n \"def serial_ports():\\r\\n if sys.platform.startswith('win'):\\r\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\r\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\r\\n # this excludes your current terminal \\\"/dev/tty\\\"\\r\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\r\\n elif sys.platform.startswith('darwin'):\\r\\n ports = glob.glob('/dev/tty.*')\\r\\n else:\\r\\n raise EnvironmentError('Unsupported platform')\\r\\n\\r\\n result = []\\r\\n for port in ports:\\r\\n try:\\r\\n s = serial.Serial(port)\\r\\n s.close()\\r\\n result.append(port)\\r\\n except (OSError, serial.SerialException):\\r\\n pass\\r\\n return result\",\n \"def serial_ports():\\r\\n if sys.platform.startswith('win'):\\r\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\r\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\r\\n # this excludes your current terminal \\\"/dev/tty\\\"\\r\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\r\\n elif sys.platform.startswith('darwin'):\\r\\n ports = glob.glob('/dev/tty.*')\\r\\n else:\\r\\n raise EnvironmentError('Unsupported platform')\\r\\n\\r\\n result = []\\r\\n for port in ports:\\r\\n try:\\r\\n s = serial.Serial(port)\\r\\n s.close()\\r\\n result.append(port)\\r\\n except (OSError, serial.SerialException):\\r\\n pass\\r\\n return result\",\n \"def cmd(self,bits,char_mode=False):\\n\\n if( rpi_device ):\\n sleep(0.0012)\\n bits = bin(bits)[2:].zfill(8)\\n GPIO.output(self.pin_rs,char_mode)\\n\\n for pin in self.pins_db:\\n GPIO.output(pin,False)\\n\\n for i in range(4):\\n if bits[i] == \\\"1\\\":\\n GPIO.output(self.pins_db[::-1][i],True)\\n \\n GPIO.output(self.pin_e,True)\\n GPIO.output(self.pin_e,False)\\n\\n for pin in self.pins_db:\\n GPIO.output(pin,False)\\n \\n for i in range(4,8):\\n if bits[i] == \\\"1\\\":\\n GPIO.output(self.pins_db[::-1][i-4],True)\\n\\n GPIO.output(self.pin_e,True)\\n GPIO.output(self.pin_e,False)\",\n \"def update(self):\\r\\n self._state = self.iobus.read_pin(self.targetpin)\",\n \"def sequential_connect(self):\\r\\n\\r\\n # Connect to rendezvous server.\\r\\n try:\\r\\n mappings = sequential_bind(self.mapping_no + 1, self.interface)\\r\\n con = self.server_connect(mappings[0][\\\"sock\\\"])\\r\\n except Exception as e:\\r\\n log.debug(e)\\r\\n log.debug(\\\"this err\\\")\\r\\n return None\\r\\n\\r\\n # First mapping is used to talk to server.\\r\\n mappings.remove(mappings[0])\\r\\n\\r\\n # Receive port mapping.\\r\\n msg = \\\"SOURCE TCP %s\\\" % (str(mappings[0][\\\"source\\\"]))\\r\\n con.send_line(msg)\\r\\n reply = con.recv_line(timeout=2)\\r\\n remote_port = self.parse_remote_port(reply)\\r\\n if not remote_port:\\r\\n return None\\r\\n\\r\\n # Generate port predictions.\\r\\n predictions = \\\"\\\"\\r\\n if self.nat_type != \\\"random\\\":\\r\\n mappings = self.predict_mappings(mappings)\\r\\n for mapping in mappings:\\r\\n predictions += str(mapping[\\\"remote\\\"]) + \\\" \\\"\\r\\n predictions = predictions.rstrip()\\r\\n else:\\r\\n predictions = \\\"1337\\\"\\r\\n\\r\\n return [con, mappings, predictions]\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(32)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/ttyUSB*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def add_layout_pins(self):\\n\\n # All wordlines\\n # Main array wl and bl/br\\n for pin_name in self.all_wordline_names:\\n pin_list = self.bitcell_array_inst.get_pins(pin_name)\\n for pin in pin_list:\\n self.add_layout_pin(text=pin_name,\\n layer=pin.layer,\\n offset=pin.ll().scale(0, 1),\\n width=self.width,\\n height=pin.height())\\n\\n # Replica wordlines (go by the row instead of replica column because we may have to add a pin\\n # even though the column is in another local bitcell array)\\n for (names, inst) in zip(self.rbl_wordline_names, self.dummy_row_replica_insts):\\n for (wl_name, pin_name) in zip(names, self.dummy_row.get_wordline_names()):\\n if wl_name in self.gnd_wordline_names:\\n continue\\n pin = inst.get_pin(pin_name)\\n self.add_layout_pin(text=wl_name,\\n layer=pin.layer,\\n offset=pin.ll().scale(0, 1),\\n width=self.width,\\n height=pin.height())\\n\\n for pin_name in self.all_bitline_names:\\n pin_list = self.bitcell_array_inst.get_pins(pin_name)\\n for pin in pin_list:\\n self.add_layout_pin(text=pin_name,\\n layer=pin.layer,\\n offset=pin.ll().scale(1, 0),\\n width=pin.width(),\\n height=self.height)\\n\\n # Replica bitlines\\n if len(self.rbls) > 0:\\n for (names, inst) in zip(self.rbl_bitline_names, self.replica_col_insts):\\n pin_names = self.replica_columns[self.rbls[0]].all_bitline_names\\n for (bl_name, pin_name) in zip(names, pin_names):\\n pin = inst.get_pin(pin_name)\\n self.add_layout_pin(text=bl_name,\\n layer=pin.layer,\\n offset=pin.ll().scale(1, 0),\\n width=pin.width(),\\n height=self.height)\",\n \"def get_outputs(self):\\n return [x[1] for x in self.io_mapping]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6417422","0.5873375","0.58421856","0.57833403","0.5708977","0.557878","0.55762327","0.5553285","0.55478317","0.5508428","0.5486689","0.54373777","0.543672","0.5429543","0.5376903","0.5359111","0.5347628","0.5344464","0.5342017","0.53398526","0.53340036","0.53059995","0.5295274","0.5278213","0.5268682","0.5256193","0.5248344","0.52304214","0.5220901","0.51933223","0.51876044","0.5162032","0.5152302","0.51454365","0.51441574","0.5139869","0.51346064","0.5131433","0.51188236","0.5113852","0.50992787","0.50908643","0.5086269","0.5083333","0.50668544","0.5064758","0.5055474","0.50444686","0.5036006","0.501687","0.5015898","0.5015081","0.4997506","0.49892738","0.49873993","0.49848258","0.49819317","0.49759027","0.49652746","0.4961288","0.495823","0.49536857","0.4949281","0.49398983","0.4934808","0.493157","0.4931118","0.49255344","0.49226472","0.4907377","0.49045","0.49022555","0.48956645","0.489017","0.4887491","0.4885738","0.48829702","0.48701066","0.48697597","0.48694256","0.48668596","0.48628515","0.48607212","0.48596695","0.48497394","0.4847872","0.4845774","0.48438838","0.48433387","0.48433387","0.48433387","0.48433387","0.4831029","0.4826007","0.4826007","0.48253372","0.4817935","0.48137242","0.4810484","0.4798838","0.47895986"],"string":"[\n \"0.6417422\",\n \"0.5873375\",\n \"0.58421856\",\n \"0.57833403\",\n \"0.5708977\",\n \"0.557878\",\n \"0.55762327\",\n \"0.5553285\",\n \"0.55478317\",\n \"0.5508428\",\n \"0.5486689\",\n \"0.54373777\",\n \"0.543672\",\n \"0.5429543\",\n \"0.5376903\",\n \"0.5359111\",\n \"0.5347628\",\n \"0.5344464\",\n \"0.5342017\",\n \"0.53398526\",\n \"0.53340036\",\n \"0.53059995\",\n \"0.5295274\",\n \"0.5278213\",\n \"0.5268682\",\n \"0.5256193\",\n \"0.5248344\",\n \"0.52304214\",\n \"0.5220901\",\n \"0.51933223\",\n \"0.51876044\",\n \"0.5162032\",\n \"0.5152302\",\n \"0.51454365\",\n \"0.51441574\",\n \"0.5139869\",\n \"0.51346064\",\n \"0.5131433\",\n \"0.51188236\",\n \"0.5113852\",\n \"0.50992787\",\n \"0.50908643\",\n \"0.5086269\",\n \"0.5083333\",\n \"0.50668544\",\n \"0.5064758\",\n \"0.5055474\",\n \"0.50444686\",\n \"0.5036006\",\n \"0.501687\",\n \"0.5015898\",\n \"0.5015081\",\n \"0.4997506\",\n \"0.49892738\",\n \"0.49873993\",\n \"0.49848258\",\n \"0.49819317\",\n \"0.49759027\",\n \"0.49652746\",\n \"0.4961288\",\n \"0.495823\",\n \"0.49536857\",\n \"0.4949281\",\n \"0.49398983\",\n \"0.4934808\",\n \"0.493157\",\n \"0.4931118\",\n \"0.49255344\",\n \"0.49226472\",\n \"0.4907377\",\n \"0.49045\",\n \"0.49022555\",\n \"0.48956645\",\n \"0.489017\",\n \"0.4887491\",\n \"0.4885738\",\n \"0.48829702\",\n \"0.48701066\",\n \"0.48697597\",\n \"0.48694256\",\n \"0.48668596\",\n \"0.48628515\",\n \"0.48607212\",\n \"0.48596695\",\n \"0.48497394\",\n \"0.4847872\",\n \"0.4845774\",\n \"0.48438838\",\n \"0.48433387\",\n \"0.48433387\",\n \"0.48433387\",\n \"0.48433387\",\n \"0.4831029\",\n \"0.4826007\",\n \"0.4826007\",\n \"0.48253372\",\n \"0.4817935\",\n \"0.48137242\",\n \"0.4810484\",\n \"0.4798838\",\n \"0.47895986\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":860,"numItemsPerPage":100,"numTotalItems":95772,"offset":86000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTk1MDAyNywianRpIjoiODY4MzczZWYtODJkMS00YzM4LWFmODktMTZkODU4NmI5Njc2Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU5NTM2MjcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.a3azHwKyLZ0RZ9RsmryCqnAb65XyXWvUrH3AEClSFm2OLC5V-4ieM9JuRaWAACOJRbB-O0lCz3h_1lw9KK7yDA","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 |
|---|---|---|---|---|---|---|
Returns the mgm and lfn that the user most likely intended to | def _safe_split_mgm(self, path, mgm=None):
if path.startswith('root://'):
_mgm, lfn = split_mgm(path)
if not(mgm is None) and not _mgm == mgm:
raise ValueError(
'Conflicting mgms determined from path and passed argument: '
'From pat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first_name_and_gender():\n fn=''\n mn=''\n g = 'M' if random.randint(0,1) == 0 else 'F'\n if g=='M':\n fn = fake.first_name_male()\n mn = fake.first_name_male()\n else:\n fn = fake.first_name_female()\n mn = fake.first_name_female()\n\n return fn,mn",
"def extrac... | [
"0.5902391",
"0.58704615",
"0.5793951",
"0.552161",
"0.55187815",
"0.5314315",
"0.5185743",
"0.5127224",
"0.5122406",
"0.51154524",
"0.5075057",
"0.50512254",
"0.5047442",
"0.50456214",
"0.5017562",
"0.5007443",
"0.4966871",
"0.49581426",
"0.49524567",
"0.49454257",
"0.493799... | 0.5127529 | 7 |
Joins mgm and lfn, ensures correct formatting | def _join_mgm_lfn(self, mgm, lfn):
if not mgm.endswith('/'): mgm += '/'
return mgm + lfn | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def result_to_pretty_string(f, g, rs, ss, ts):\n\n return '\\n'.join(map(lambda (r, s, t): '{r} = ({s}) * ({f}) + ({t}) * ({g})'.format(r=r, s=s, t=t, f=f, g=g),\n zip(rs, ss, ts)))",
"def get_M_as_string(self):\n return '\\n'.join(['M({})={}'.format(p.name, p.M) for p in self.P... | [
"0.51409286",
"0.50731665",
"0.50231826",
"0.49108234",
"0.48673972",
"0.4861895",
"0.48246044",
"0.48213902",
"0.4819359",
"0.4811084",
"0.47524574",
"0.47146547",
"0.4714585",
"0.4713504",
"0.47094056",
"0.46955222",
"0.4657899",
"0.46380806",
"0.46370494",
"0.46309257",
"0... | 0.7829792 | 0 |
Creates a directory on the SE Does not check if directory already exists | def create_directory(self, directory):
mgm, directory = self._safe_split_mgm(directory)
logger.warning('Creating directory on SE: {0}'.format(self._join_mgm_lfn(mgm, directory)))
cmd = [ 'xrdfs', mgm, 'mkdir', '-p', directory ]
svj.core.utils.run_command(cmd) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_dir(self):\n if not os.path.exists(self.d):\n try:\n os.mkdir(self.d)\n except OSError, e:\n if e.errno != 17:\n raise\n pass",
"def create_dir(dir_path):\n if not os.path.exists(dir_path):\n ... | [
"0.83424073",
"0.8160656",
"0.8106043",
"0.80585885",
"0.80585885",
"0.80445415",
"0.8038276",
"0.8032155",
"0.80254644",
"0.8020224",
"0.80045015",
"0.8000421",
"0.79927254",
"0.793986",
"0.79367894",
"0.79226726",
"0.79205954",
"0.78914696",
"0.7890425",
"0.78721476",
"0.78... | 0.7743014 | 40 |
Returns a boolean indicating whether the directory exists | def is_directory(self, directory):
mgm, directory = self._safe_split_mgm(directory)
cmd = [ 'xrdfs', mgm, 'stat', '-q', 'IsDir', directory ]
status = (subprocess.check_output(cmd) == 0)
if not status:
logger.info('Directory {0} does not exist'.format(self._join_mgm_lfn(mgm, d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dir_exists(dir: str) -> bool:\n return os.path.isdir(dir)",
"def check_dir_exist():\n if os.path.isdir(path_structure):\n return True\n else:\n return False",
"def directory_exists(self, directory: str = None) -> bool:\n return os.access(directory if directory else self.get_di... | [
"0.85646",
"0.84998095",
"0.84274375",
"0.8296807",
"0.82139444",
"0.82082856",
"0.809449",
"0.80681866",
"0.8031138",
"0.79924685",
"0.7937865",
"0.7918179",
"0.7815453",
"0.7649746",
"0.76208276",
"0.7597657",
"0.7462627",
"0.7451004",
"0.7436449",
"0.74356145",
"0.7376903"... | 0.76564944 | 13 |
Copies a file `src` to the storage element | def copy_to_se(self, src, dst, create_parent_directory=True):
mgm, dst = self._safe_split_mgm(dst)
dst = self._join_mgm_lfn(mgm, dst)
if create_parent_directory:
parent_directory = osp.dirname(dst)
self.create_directory(parent_directory)
logger.warning('Copying {0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def src(self, src):\n\n self._src = src",
"def copy_source(self, filename, new_filename, **kw):\n\n file_path = os.path.join(self.storage_path, filename)\n new_file_path = os.path.join(self.storage_path, new_filename)\n shutil.copyfile(file_path, new_file_path)",
"def _copy_to_media... | [
"0.6695303",
"0.6277998",
"0.61272883",
"0.6095858",
"0.6080218",
"0.5903634",
"0.5829626",
"0.5754406",
"0.57520276",
"0.5700519",
"0.55948555",
"0.557057",
"0.5544569",
"0.5529829",
"0.55181485",
"0.550103",
"0.54890895",
"0.54736984",
"0.5438495",
"0.5427721",
"0.5403259",... | 0.0 | -1 |
Returns the proper sizing | def _getsizing(self, comminfo, cash, data, isbuy):
if isbuy: # Buying
target = self.broker.getvalue() * self.params.prop # Ideal total value of the position
price = data.close[0]
shares_ideal = target / price # How many shares are needed to get target
b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_size(self):\r\n pass",
"def get_image_size(self):",
"def size(self):\n return (self.width)",
"def calc_size(self):\r\n self.height = HEIGHT_STATUS",
"def size(self):\n return self.width",
"def size(self):\n return self.width",
"def size(self):\n return... | [
"0.79809976",
"0.7545345",
"0.74031615",
"0.73629415",
"0.73331845",
"0.73331845",
"0.73331845",
"0.73331845",
"0.73331845",
"0.73331845",
"0.73331845",
"0.7309496",
"0.728393",
"0.7250864",
"0.72462463",
"0.7211166",
"0.7156204",
"0.71235317",
"0.71235317",
"0.7122899",
"0.7... | 0.0 | -1 |
Check str of Submission model. | async def test_str(
submission_fixture: Submission,
) -> None:
AssertThat(str(submission_fixture)).IsInstanceOf(str)
AssertThat(str(submission_fixture)).IsEqualTo(submission_fixture.url) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_submission_model_str(self):\n cattle = mommy.make(\n 'main.Task',\n name='Cattle Price')\n submission = mommy.make(\n 'main.Submission',\n task=cattle,\n _fill_optional=['user', 'comment', 'submission_time'])\n expected = \"Cattle... | [
"0.7059866",
"0.62975836",
"0.6151616",
"0.61028385",
"0.6042036",
"0.6003411",
"0.5991225",
"0.59581923",
"0.5912117",
"0.5893448",
"0.5867347",
"0.5861611",
"0.58457726",
"0.58284163",
"0.5810691",
"0.5804451",
"0.5799303",
"0.5771318",
"0.57530624",
"0.5749821",
"0.574816"... | 0.67675114 | 1 |
Generate name for test project. | def project_name() -> str:
fake = Faker()
raw_name: str = (
fake.name_female().lower().replace(" ", "_").replace("-", "_").replace(".", "_")
)
return re.sub("_+", "_", raw_name).strip("_") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getProjectName():",
"def generate_name(self):\n name = self._generate_test_name()\n while self.exists(name):\n name = self._generate_test_name()\n return name",
"def testName(self):\n project = self.session.create_project()\n\n self.util.stringTypeTest(self, pr... | [
"0.7983957",
"0.77939415",
"0.7772358",
"0.77490586",
"0.7741682",
"0.75450486",
"0.7491648",
"0.7360723",
"0.7253296",
"0.72480696",
"0.71617275",
"0.7105816",
"0.7038073",
"0.6992555",
"0.69569904",
"0.6916934",
"0.6876165",
"0.6875566",
"0.6869538",
"0.6838565",
"0.6822547... | 0.77850544 | 2 |
Generate directory to work into | def generator_start_dir() -> str:
old_cwd = os.getcwd()
newpath = tempfile.mkdtemp()
os.chdir(newpath)
try:
yield newpath
finally:
os.chdir(old_cwd)
shutil.rmtree(newpath, ignore_errors=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_output_directory(self):\n fs = self._filesystem\n output_filename = fs.join(self._root_output_dir, self._test_name)\n fs.maybe_make_directory(fs.dirname(output_filename))",
"def make_source_dir():\n\n os.makedirs(files['source_dir'].rel)",
"def _make_output_dir(self):\n ... | [
"0.7443446",
"0.7413898",
"0.7176719",
"0.7132227",
"0.7052426",
"0.7027971",
"0.69864786",
"0.6921163",
"0.6908912",
"0.68657094",
"0.68656844",
"0.6845449",
"0.6840432",
"0.6839763",
"0.6807036",
"0.6770787",
"0.6740235",
"0.67180556",
"0.6714957",
"0.66977865",
"0.6696159"... | 0.6814439 | 14 |
Default builder context without features. | def default_context(project_name: str) -> None:
return BuilderContext(
project_name=project_name,
kube_name=project_name.replace("_", "-"),
project_description="Generated by pytest.",
ci_type=CIType.none,
db=DatabaseType.none,
db_info=DB_INFO[DatabaseType.none],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getBuilder():",
"def build(self) -> cern.lsa.domain.settings.ContextSettings:\n ...",
"def get_dummy_context():\n context = util.DotDict()\n context.elasticSearchHostname = \"\"\n context.elasticSearchPort = 9200\n context.platforms = (\n {\n \"id\": \"windows\",\n ... | [
"0.66999394",
"0.6211641",
"0.62057453",
"0.6149984",
"0.59577477",
"0.591246",
"0.591246",
"0.5912228",
"0.58951634",
"0.58951634",
"0.58951634",
"0.58951634",
"0.58951634",
"0.58951634",
"0.5883314",
"0.5875144",
"0.58420306",
"0.582237",
"0.5786626",
"0.575766",
"0.5714654... | 0.71017975 | 0 |
Change directory to generator_start_dir. | def default_dir(generator_start_dir: str) -> None:
yield
cwd = os.getcwd()
if cwd != generator_start_dir:
os.chdir(generator_start_dir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generator_start_dir() -> str:\n old_cwd = os.getcwd()\n newpath = tempfile.mkdtemp()\n os.chdir(newpath)\n try:\n yield newpath\n finally:\n os.chdir(old_cwd)\n shutil.rmtree(newpath, ignore_errors=True)",
"def setup(self, newdir=None):\n if not os.path.exists(self.... | [
"0.7866557",
"0.62242794",
"0.61990684",
"0.617797",
"0.6177548",
"0.6098702",
"0.60680014",
"0.60668284",
"0.5981352",
"0.5979372",
"0.5947241",
"0.5925714",
"0.5915247",
"0.5878447",
"0.5877666",
"0.58542806",
"0.583494",
"0.58293223",
"0.5808327",
"0.5800286",
"0.5794496",... | 0.7948314 | 0 |
Cleans up docker context. | def docker_module_shutdown(generator_start_dir: str, project_name: str) -> None:
yield
cwd = os.getcwd()
project_dir = Path(generator_start_dir) / project_name
if not project_dir.exists():
return
os.chdir(project_dir)
Path("poetry.lock").unlink(missing_ok=True)
run_docker_compose_com... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cleanup(self):\n with hide(\"output\", \"warnings\", \"running\"):\n self.stop_all()\n self._execute_standard(\"rm -rf {model_repo}\".format(model_repo=MODEL_REPO))\n self._execute_root(\"docker rmi --force $(docker images -q)\", warn_only=True)\n self._execut... | [
"0.7146161",
"0.7115365",
"0.701015",
"0.6967293",
"0.6847206",
"0.6737693",
"0.67033553",
"0.6644785",
"0.6614517",
"0.65589184",
"0.65430343",
"0.6533365",
"0.6469086",
"0.6405354",
"0.6397906",
"0.63866544",
"0.6380686",
"0.6300325",
"0.6300325",
"0.6300325",
"0.6300325",
... | 0.0 | -1 |
Load energy_plant_radiation_class class from file energy_plant_radiation_class. | def classFactory(iface): # pylint: disable=invalid-name
#
from .nuclear_energy_plant_radiation_module import energy_plant_radiation_class
return energy_plant_radiation_class(iface) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_resource():\n resource_file = 'curves/' + self.combo_box[\"class\"].get() + '.json'\n self.classes[\"fractal\"].curve.load_from_resource(\n resource_file)\n self.classes[\"fractal\"].curve.set_parent_parameters()\n self.classes[\"parameters\"].rul... | [
"0.5642803",
"0.5179759",
"0.5126858",
"0.51085144",
"0.5100658",
"0.5096265",
"0.5077245",
"0.50566846",
"0.49435663",
"0.48717636",
"0.48648682",
"0.485874",
"0.48466516",
"0.48069355",
"0.48024842",
"0.47911623",
"0.47862443",
"0.4783866",
"0.4778332",
"0.47674206",
"0.476... | 0.51236886 | 3 |
Generate sample vessel system. J. Kunes | def generate_sample_data(m=1, noise_level=0.005, gauss_sigma=0.1):
from imtools import thresholding_functions
data3d = np.zeros((100 * m, 100 * m, 100 * m), dtype=np.int)
# size 8
data3d_new = np.ones((100 * m, 100 * m, 100 * m), dtype=np.bool)
data3d_new[0:30 * m, 20 * m, 20 * m] = 0
data3d_n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_vessel_components(self) -> list:\n\n # Blanket computed from plasma\n blanket = paramak.BlanketFP(\n plasma=self.plasma,\n thickness=4.06e2 - 3.52e2,\n start_angle=-70,\n stop_angle=230,\n rotation_angle=self.rotation_angle,\n ... | [
"0.6104725",
"0.58946806",
"0.58238125",
"0.57697004",
"0.5739443",
"0.57187384",
"0.5605193",
"0.56051666",
"0.5605048",
"0.55891824",
"0.5569418",
"0.55644405",
"0.55613863",
"0.55606264",
"0.55549943",
"0.55420285",
"0.5541645",
"0.5530176",
"0.55171233",
"0.55052173",
"0.... | 0.0 | -1 |
Processing data without gui. There is a sister of this function in histology_analyser_gui module | def processData(args):
inputfile=args.inputfile
threshold=args.threshold
mask_file=args.maskfile
crop=args.crop
voxelsize=args.voxelsize
binaryClosing=args.binaryclosing
binaryOpening=args.binaryopening
vtfile=args.vtfile
vt2esofspy=args.vt2esofspy
output_report_csv_file=args.out... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def analyze(data):\n ## Do welch periodogram here\n pass",
"def _process(self, data: np.ndarray) -> np.ndarray:",
"def _process(self, data: np.ndarray) -> np.ndarray:",
"def analyse(self, data=None):\n pass",
"def main():\n df_data = import_clean_process()\n plot_data_matplotlib(... | [
"0.67493516",
"0.62960464",
"0.62960464",
"0.6286892",
"0.6212195",
"0.61093634",
"0.60937744",
"0.60866874",
"0.6036327",
"0.5978911",
"0.5975806",
"0.59499186",
"0.59346336",
"0.59103394",
"0.5823865",
"0.5798523",
"0.57932895",
"0.5774382",
"0.5751546",
"0.5751546",
"0.575... | 0.5766699 | 18 |
returns the first word in a given text. | def first_word(text: str) -> str:
import string
# it's deleting first not letter strings
start = 0
for element in text:
if element in (" ", ",", ".", "'"):
start += 1
elif element in (string.ascii_uppercase + string.ascii_lowercase):
break
text = text[start:l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def first_word(text: str) -> str:\n # answer = []\n # answer=text.split(\" \", maxsplit=1)\n # import re\n # re.sub(r'a', 'b', 'banana')\n\n answer_wrk = re.search(r\"[a-zA-z\\']+\", text)\n answer = answer_wrk.group(0)\n\n return answer",
"def first_word(text):\n # your code here\n sp... | [
"0.8146144",
"0.8141208",
"0.7967539",
"0.7401317",
"0.7396188",
"0.7192831",
"0.714187",
"0.66818404",
"0.66556394",
"0.65835834",
"0.65610653",
"0.6507425",
"0.6431512",
"0.6374773",
"0.6374773",
"0.63654155",
"0.6336063",
"0.6329843",
"0.6294769",
"0.6290436",
"0.625327",
... | 0.83027816 | 0 |
Uses underlying C api to create a module | def __init__(self, idargs):
if type(idargs) != idargparse.TxpArgumentParser:
raise ValueError("idargs must be a TxpArgumentParser")
self._mod = pyIdlak_txp.PyIdlakModule_new(self._modidx, idargs.idlakopts) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_module(cls, *args, **kwargs): # real signature unknown\n pass",
"def create_module(cls, *args, **kwargs): # real signature unknown\n pass",
"def _create_module(name):\n module = new.module(name)\n sys.modules[name] = module\n return module",
"def _createModuleObj(self):\n ... | [
"0.75084627",
"0.75084627",
"0.7268729",
"0.71196806",
"0.69312716",
"0.6830948",
"0.6711122",
"0.6680741",
"0.656734",
"0.6560675",
"0.6482013",
"0.64257735",
"0.6414944",
"0.6380871",
"0.63747823",
"0.6368041",
"0.6287453",
"0.6278774",
"0.6261905",
"0.6261905",
"0.6243278"... | 0.0 | -1 |
process the document in place | def process(self, doc):
if not type(doc) is xmldoc.XMLDoc:
raise ValueError("doc must be a XMLDoc")
pyIdlak_txp.PyIdlakModule_process(self._mod, doc.idlak_doc) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _transform(self, document):\n pass",
"def process(self, doc):\n self.doc = doc\n if self.replace_words is True:\n self.replace_words_fun()\n if self.remove_html_tags is True:\n self.remove_html_tags_fun()\n if self.remove_stopwords is True:\n ... | [
"0.7462148",
"0.7406086",
"0.6852314",
"0.67837477",
"0.66898626",
"0.63546854",
"0.633135",
"0.632514",
"0.63043433",
"0.62745553",
"0.62177104",
"0.61018103",
"0.60946083",
"0.60878795",
"0.6036372",
"0.6034082",
"0.6027082",
"0.60214764",
"0.5997861",
"0.5982215",
"0.59393... | 0.5574814 | 52 |
Gets the name of the module | def name(self):
return self._modname | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def module_name(self):\n return self.lib.get_module_name()",
"def module_name(self):\n return self.name()",
"def module_name(self):\n return self.name",
"def get_module_name(self):\n return self.module_name",
"def name(cls):\n return MODULE_NAME",
"def module_name(self)... | [
"0.9114128",
"0.9060202",
"0.89279187",
"0.89060533",
"0.8833184",
"0.8701048",
"0.85008574",
"0.8235956",
"0.81398195",
"0.8051865",
"0.7917739",
"0.7917739",
"0.79172605",
"0.78984195",
"0.7841873",
"0.77399725",
"0.773858",
"0.76504517",
"0.7642898",
"0.76253045",
"0.75270... | 0.8397406 | 7 |
Create a new AtramhasisProvider | def __init__(self, metadata, **kwargs):
if 'subject' not in metadata:
metadata['subject'] = []
if 'uri' not in metadata:
log.warning(
"AtramhasisProvider: 'uri' is not present in the metadata. "
"This will result in a http call to fetch the concept... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_attestation(attestation: Attestation):\n pass",
"def alpaca_create(self, keyname = \"ALPACA_API_KEY\", secret = \"ALPACA_SECRET_KEY\"):\n aak = os.getenv(keyname)\n ask = os.getenv(secret)\n if type(aak) is not str | type(aak) is not str:\n raise Exception(\"Could no... | [
"0.52555776",
"0.5254564",
"0.52526224",
"0.5233139",
"0.50061494",
"0.49999845",
"0.4925371",
"0.48999807",
"0.4887252",
"0.4868984",
"0.48582995",
"0.48151788",
"0.48077402",
"0.47774965",
"0.47251567",
"0.47028697",
"0.46956468",
"0.46650037",
"0.46495956",
"0.46471313",
"... | 0.60222864 | 0 |
Usado para emitir notificacoes no inicio e fim de uma acao | def logging(
action, prefix_action="* ", sufix_action="...", success="OK ", error="ERROR"
):
print("{}{}{}".format(prefix_action, action, sufix_action), end=" ")
def finish(text):
"""
Usado para emitir uma mensagem de fim customizada,
se nao for invocada e exibida a mensagem padrao ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enchere(self):\n\n i = 0\n while i < 5 and self.annonce < 4:\n paroleJ = self.joueurs[i].parler(self.annonce)\n if paroleJ != 0:\n self.annonce = paroleJ\n self.indiceJoueurQuiPrend = i\n i += 1\n\n print(\"joueur qui prend : \... | [
"0.5825989",
"0.5716464",
"0.57003754",
"0.5677707",
"0.5641369",
"0.5552748",
"0.54724026",
"0.5452283",
"0.54361415",
"0.54250216",
"0.5415447",
"0.54134053",
"0.53304255",
"0.52359575",
"0.52322567",
"0.5201554",
"0.51994395",
"0.51853836",
"0.51836836",
"0.5165727",
"0.51... | 0.0 | -1 |
Usado para emitir uma mensagem de fim customizada, se nao for invocada e exibida a mensagem padrao de sucesso | def finish(text):
finish.has_been_called = True
print("{}{}".format(success, text)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sendErrorMessage(msg): #@NoSelf",
"def flash_msg(self, params):\n if params.has_key('receiver'): name = params['receiver']\n else: \n if self.participant: \n group = self.service.groupOfParticipant(self.participant)\n if group: \n mem... | [
"0.6033863",
"0.58943576",
"0.58772117",
"0.5869448",
"0.5865626",
"0.5859008",
"0.5838634",
"0.58163446",
"0.58033967",
"0.579107",
"0.576767",
"0.5746271",
"0.5722057",
"0.56849825",
"0.56139547",
"0.5588774",
"0.5582261",
"0.55735016",
"0.55451274",
"0.553899",
"0.5537516"... | 0.0 | -1 |
Recupera todas as contas em aberto das igrejas | def pegar_contas_igrejas():
erros = []
contas = []
cpfl = CPFL()
for igreja, instalacao in INSTALACOES.items():
try:
with logging(igreja) as finish:
novas_contas = cpfl.recuperar_contas_abertas(CNPJ, instalacao)
for conta in novas_contas:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def countering():\r\n return []",
"def encontrar_mejor_sitio(ubicaciones):\n\ttorretas_adicionales = ubicaciones.count(\"t\") # obtengo cuantas t (torretas adicionales) hay en ubicaciones\n\tif torretas_adicionales == 0:\n\t\tprint \"Posicion: 5\"\n\tif torretas_adicionales == 4:\n\t\tprint \"Posicion: \",\n\... | [
"0.6024232",
"0.5778898",
"0.5772468",
"0.56903213",
"0.56899667",
"0.5653988",
"0.5653988",
"0.55774236",
"0.5563019",
"0.55446196",
"0.55063593",
"0.54217356",
"0.5399272",
"0.5393137",
"0.53357404",
"0.5330091",
"0.53291875",
"0.53227985",
"0.52933735",
"0.5261711",
"0.524... | 0.63868624 | 0 |
Converts grib files to netcdf using HRRR forecast data and the variables required by the SMRF. Uses the wgrib2 command to identify variable names and uses that to filter the output from the commandline. | def grib2nc(f_hrrr, output=None, external_logger=None):
start = time.time()
if external_logger == None:
fmt = "%(levelname)s: %(msg)s"
log = logging.getLogger(__name__)
coloredlogs.install(logger=log, fmt=fmt)
msg = "GRIB2NC Converter Utility"
log.info(msg)
log.info("=" * len(msg))
# criteria dictionary ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hourly_grib2_to_netcdf(grib_file, grib_source, nc_file, nc_var_name,\n grib_var_name, grib_level, cache_size=100,\n initial_year=1979, overwrite_nc_units=None,\n include_analysis=True,\n nc_format='NETCDF4')... | [
"0.6853723",
"0.6487569",
"0.6329581",
"0.6090967",
"0.56164694",
"0.5534598",
"0.5456288",
"0.53535604",
"0.52977234",
"0.5225581",
"0.5223431",
"0.519277",
"0.5141454",
"0.51206857",
"0.5117262",
"0.50898886",
"0.508972",
"0.5078878",
"0.5070577",
"0.50090307",
"0.49965036"... | 0.7377985 | 0 |
Firstly, the image is rotated, and then the image is preprocessed | def __getitem__(self, index):
img, _ = self.dataset.__getitem__(index)
# Convert to numpy.ndarray
if isinstance(img, Image.Image):
img = np.array(img)
elif isinstance(img, torch.Tensor):
img = img.numpy()
else:
pass
# Convert grayscal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(self, image):\n if self.rotate == 0:\n return image\n\n angle = self.rotate * -90\n return image.rotate(angle, expand=True).crop((0, 0, self._w, self._h))",
"def transform(self, previousimage):",
"def apply_rotation(image):\n\n\t# Load the image into a new BytesIO... | [
"0.7815346",
"0.692002",
"0.6816925",
"0.6709122",
"0.66407454",
"0.6565173",
"0.64606667",
"0.64606667",
"0.64087397",
"0.6385571",
"0.63738203",
"0.63497627",
"0.6326754",
"0.6312972",
"0.6279072",
"0.6265637",
"0.62516814",
"0.62358415",
"0.6215376",
"0.620934",
"0.6188507... | 0.0 | -1 |
Replace contractions in string of text | def replace_contractions(text):
return contractions.fix(text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_contractions(text):\r\n return contractions.fix(text)",
"def _replace_contractions(text):\n return contractions.fix(text)",
"def replaceContractions(self, text):\n\t\treturn contractions.fix(text)",
"def replace_contractions(self):\n self.text = contractions.fix(self.text)\n r... | [
"0.8687263",
"0.8606106",
"0.8100211",
"0.75796664",
"0.7554637",
"0.73812336",
"0.72393143",
"0.71252644",
"0.6733126",
"0.6524883",
"0.6449502",
"0.6409592",
"0.64059746",
"0.6365393",
"0.6314563",
"0.6309385",
"0.6151162",
"0.61502606",
"0.61313903",
"0.61110896",
"0.61059... | 0.8611583 | 1 |
Remove nonASCII characters from list of tokenized words | def remove_non_ascii(words):
new_words = []
for word in words:
new_word = unicodedata.normalize('NFKD', word).encode('ascii', 'ignore').decode('utf-8', 'ignore')
new_words.append(new_word)
return new_words | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_non_word_chars(tokens):\n toks = []\n for token in tokens:\n t = re.sub(r'\\W', \"\", token)\n if len(t) > 1:\n toks.append(t)\n\n return toks",
"def _remove_non_ascii(words):\n new_words = []\n for word in words:\n new_word = unicodedata.normalize('NFKD', word).encode('ascii... | [
"0.811785",
"0.7990454",
"0.7987333",
"0.79803234",
"0.79065156",
"0.7874596",
"0.7569082",
"0.75249046",
"0.7517662",
"0.73463523",
"0.73408365",
"0.7230869",
"0.71905714",
"0.7190189",
"0.71839136",
"0.71484107",
"0.7140565",
"0.7088968",
"0.70817244",
"0.7076244",
"0.70608... | 0.79627377 | 8 |
Convert all characters to lowercase from list of tokenized words | def to_lowercase(words):
new_words = []
for word in words:
new_word = word.lower()
new_words.append(new_word)
return new_words | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lowercase(tokens):\n if not lowercase_activated:\n return tokens\n output = [token.lower() for token in tokens]\n return output",
"def preprocess(tokens):\n result = []\n for token in tokens:\n result.append(token.lower())\n return result",
"def lowercase(tokens):\n return [token.lower(... | [
"0.825361",
"0.81953853",
"0.79781765",
"0.781734",
"0.7800716",
"0.7751302",
"0.7673937",
"0.76445544",
"0.75346315",
"0.7522023",
"0.74568486",
"0.7307557",
"0.71714586",
"0.7123188",
"0.69849426",
"0.6983551",
"0.68570787",
"0.6821391",
"0.6815797",
"0.6752138",
"0.6731911... | 0.76206166 | 13 |
Remove punctuation from list of tokenized words | def remove_punctuation(words):
new_words = []
for word in words:
new_word = re.sub(r'[^\w\s]', '', word)
if new_word != '':
new_words.append(new_word)
return new_words | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_punctuations(tokenized_word_list):\n puncuations = set(string.punctuation)\n\n double_quote = '\\'\\''\n double_sign = '``'\n\n puncuations.add(double_quote)\n puncuations.add(double_sign)\n\n filtered_tokens = [word for word in tokenized_word_list if word not in puncuations]\n retu... | [
"0.8442782",
"0.8359967",
"0.8351824",
"0.8328873",
"0.8253663",
"0.825076",
"0.8141438",
"0.811486",
"0.8062248",
"0.79808956",
"0.79785806",
"0.79171425",
"0.78637815",
"0.7798064",
"0.7791937",
"0.7775272",
"0.77740026",
"0.77291363",
"0.7681821",
"0.7561502",
"0.749725",
... | 0.8288225 | 8 |
Replace all interger occurrences in list of tokenized words with textual representation | def replace_numbers(words):
p = inflect.engine()
new_words = []
for word in words:
if word.isdigit():
new_word = p.number_to_words(word)
new_words.append(new_word)
else:
new_words.append(word)
return new_words | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_nums2words(tokens):\n e = inflect.engine()\n words = []\n for word in tokens:\n if word.isdigit():\n words.append(e.number_to_words(word).replace(',', ''))\n else:\n words.append(word)\n return words",
"def replace_numbers(words):\n p = inflect.engin... | [
"0.7128246",
"0.6678444",
"0.6678444",
"0.6665406",
"0.6647252",
"0.65828025",
"0.6537516",
"0.65074503",
"0.6504618",
"0.645171",
"0.64318156",
"0.630259",
"0.6287732",
"0.62486833",
"0.6144012",
"0.6124199",
"0.60891247",
"0.60028815",
"0.59723675",
"0.5952372",
"0.59475845... | 0.6507276 | 13 |
Remove stop words from list of tokenized words | def remove_stopwords(words):
new_words = []
for word in words:
if word not in stopwords.words('english'):
new_words.append(word)
return new_words | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_stop_words(stop_list, tokens):\n return [t for t in tokens if len(t) > 2 and not t in stop_list]",
"def remove_stopwords(tokens):\n stop_words = set(stopwords.words('english'))\n\n tokens = [w for w in tokens if w not in stop_words]\n\n return tokens",
"def remove_stop_words(tokenized_wo... | [
"0.86630034",
"0.86183923",
"0.85973936",
"0.8596811",
"0.8580546",
"0.8363658",
"0.8350171",
"0.8328014",
"0.8318595",
"0.8263289",
"0.82468146",
"0.820217",
"0.81783086",
"0.81630206",
"0.8158307",
"0.8138284",
"0.81271654",
"0.8113883",
"0.8099041",
"0.8048383",
"0.8027641... | 0.8002353 | 25 |
Stem words in list of tokenized words | def stem_words(words):
stemmer = LancasterStemmer()
stems = []
for word in words:
stem = stemmer.stem(word)
stems.append(stem)
return stems | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stemWords(self, words):\n\t\tif stemmer == \"lancaster\":\n\t\t\tstemmer = LancasterStemmer()\n\t\telif stemmer == \"snowbal\":\n\t\t\tstemmer = SnowballStemmer()\n\t\telif stemmer == \"porter\":\n\t\t\tstemmer = PorterStemmer()\n\t\tstems = [stemmer.stem(word) for word in words]\n\t\treturn stems",
"def ste... | [
"0.75900483",
"0.75858396",
"0.7580691",
"0.7545852",
"0.75312364",
"0.75184566",
"0.74880385",
"0.7459504",
"0.7455224",
"0.7444837",
"0.7443147",
"0.742159",
"0.73581856",
"0.7346131",
"0.73340863",
"0.7282425",
"0.7278071",
"0.7240274",
"0.7219631",
"0.7127321",
"0.709653"... | 0.74077874 | 16 |
Lemmatize verbs in list of tokenized words | def lemmatize_verbs(words):
lemmatizer = WordNetLemmatizer()
lemmas = []
for word in words:
lemma = lemmatizer.lemmatize(word, pos='v')
lemmas.append(lemma)
return lemmas | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lemmatization(tokenized_word_list):\n porter=nltk.stem.PorterStemmer()\n filtered_tokens = [porter.stem(word) for word in tokenized_word_list]\n return filtered_tokens",
"def lemmatize_verbs(self):\n lemmas = []\n # lemmas = \"\"\n for word in self.words:\n lemma = wn.lemmatize(word, p... | [
"0.80288726",
"0.7971245",
"0.79286313",
"0.7890332",
"0.7825369",
"0.77554196",
"0.77338827",
"0.7710709",
"0.7703906",
"0.7699137",
"0.7638337",
"0.7630645",
"0.75690055",
"0.7545449",
"0.75376844",
"0.75229007",
"0.74909216",
"0.7470532",
"0.7464851",
"0.7436286",
"0.73693... | 0.77416253 | 11 |
Rename uploaded files with the object's slug. | def logo_upload_to(instance, filename):
_, extension = splitext(filename)
filename = f"programs/{instance.slug}_logo{extension}"
return filename | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def auto_rename(file_path, new_name):\n \n # Return if no file given\n if not file_path:\n return ''\n else:\n file_path = file_path\n \n # Get the new name\n new_path = change_basename(file_path, new_name)\n \n \n # Changed?\n if new_path != file_path:\n # Try... | [
"0.6704687",
"0.6586624",
"0.6303177",
"0.6205136",
"0.618939",
"0.610291",
"0.6092216",
"0.60845494",
"0.60668653",
"0.60320705",
"0.6015525",
"0.59766597",
"0.5961521",
"0.59444106",
"0.592686",
"0.5900543",
"0.58116543",
"0.5760065",
"0.5760043",
"0.5758437",
"0.57485795",... | 0.54537857 | 55 |
Only return programs with aids. | def has_aids(self):
return self.exclude(aids=None) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def program(cls, program):\n search_str = ArtePlus7.PROGRAMS[program]\n all_programs = cls.search(search_str)\n programs = [p for p in all_programs if p.name == program]\n return programs",
"def extract_programs():\n if settings.XPRO_CATALOG_API_URL:\n return requests.get(se... | [
"0.62694216",
"0.5741981",
"0.56935924",
"0.5627908",
"0.56089944",
"0.5581919",
"0.5562044",
"0.5484791",
"0.54173875",
"0.53707904",
"0.53661776",
"0.53409916",
"0.53327256",
"0.5318837",
"0.5258225",
"0.5221538",
"0.5221057",
"0.52003723",
"0.5185413",
"0.51680654",
"0.514... | 0.59520566 | 1 |
Only return programs with a logo. | def has_logo(self):
return self.exclude(models.Q(logo="") | models.Q(logo=None)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logo(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"logo\")",
"def logo(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"logo\")",
"def _orgWithLogoQuery(model, program):\n q = model.all()\n q.filter('scope', program)\n q.filter('status', 'active')\n ... | [
"0.57749265",
"0.57749265",
"0.56826365",
"0.56404835",
"0.56404835",
"0.56404835",
"0.56404835",
"0.5542502",
"0.5531564",
"0.5531564",
"0.5531564",
"0.5393385",
"0.5332547",
"0.5254092",
"0.5242228",
"0.5217577",
"0.5214733",
"0.51957464",
"0.5155629",
"0.5128401",
"0.50329... | 0.59098417 | 0 |
Only return spotlighted programs with a logo. | def can_be_displayed_on_homepage(self):
return self.filter(is_spotlighted=True).has_logo() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _orgWithLogoQuery(model, program):\n q = model.all()\n q.filter('scope', program)\n q.filter('status', 'active')\n q.filter('logo_url >=', '')\n\n return q",
"def logo(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"logo\")",
"def logo(self) -> pulumi.Output[Optional[str]]:\n... | [
"0.58757883",
"0.559757",
"0.559757",
"0.5495591",
"0.54465705",
"0.54465705",
"0.54465705",
"0.54465705",
"0.5373558",
"0.5335026",
"0.52914727",
"0.52914727",
"0.52914727",
"0.5289588",
"0.5156099",
"0.51511264",
"0.5124702",
"0.5042212",
"0.49926183",
"0.49869227",
"0.4982... | 0.5512798 | 3 |
Set the object's slug if it is missing. | def set_slug(self):
if not self.slug:
self.slug = slugify(self.name)[:50] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_slug(self, slug):\n if self.slug is None:\n self.slug = slug",
"def save(self, *args, **kwargs):\n if not self.slug:\n self.slug = self.generate_slug()\n super().save(*args, **kwargs)",
"def save(self, *args, **kwargs):\n if not self.slug:\n ... | [
"0.82838136",
"0.7608521",
"0.7608521",
"0.75689924",
"0.7556534",
"0.74918675",
"0.73224854",
"0.7266315",
"0.7145025",
"0.7014389",
"0.6966631",
"0.68139696",
"0.6707514",
"0.6704849",
"0.6695652",
"0.6694695",
"0.66387",
"0.6633332",
"0.6626626",
"0.6613412",
"0.6583327",
... | 0.79101604 | 1 |
Error Mail Checker and Handler return True if mail was processed, owtherwise False | def process_error_mail(recipient, sender, journal_id):
if recipient in ['', None]:
#: Simpley Error Mail!
#: TODO: error marking...
return True
try:
param = return_path_from_address(recipient)
assert param['message_id'] != ""
assert param['domain'] != ""
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_mail_when_failed(self, body):\r\n pass",
"def postprocess():\n if ERRORS:\n address = 'tamakoshihiroki@gmail.com'\n body = '\\n\\n'.join( ERRORS )\n msg = create_message( body, address )\n send_mail( msg, address )",
"def verify_mail(self):\n raise N... | [
"0.71684676",
"0.69915545",
"0.6529014",
"0.62857515",
"0.6200424",
"0.6169863",
"0.61431986",
"0.6050912",
"0.6026715",
"0.6016107",
"0.59999835",
"0.59469104",
"0.58907336",
"0.57553744",
"0.57525676",
"0.5709628",
"0.57048935",
"0.5676118",
"0.5647386",
"0.5646338",
"0.559... | 0.7448859 | 0 |
call task by name | def call_task_by_name(mod_name, task_name, *args, **kwargs):
m = __import__(mod_name, globals(), locals(), ["*"])
return getattr(m, task_name).delay(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calltask(self, name, **vars):\n if name in self._tasks:\n for entry in self._tasks[name]:\n entry.execute(vars)\n else:\n raise Error(\"No such task: {0}\".format(name))",
"def task(self, name):\n pass",
"def process_task(params):\n params['task'... | [
"0.8585335",
"0.7789529",
"0.72249997",
"0.71038425",
"0.69543546",
"0.69214267",
"0.69214267",
"0.69186956",
"0.68981737",
"0.6868687",
"0.6745845",
"0.6649044",
"0.6632027",
"0.659691",
"0.65874046",
"0.65842366",
"0.6553517",
"0.64654744",
"0.6460285",
"0.6419106",
"0.6415... | 0.77990216 | 1 |
Loads 300x1 word vecs from Google (Mikolov) word2vec | def load_bin_vec(word2vec, vocab):
word_vecs = {}
with open(word2vec, "rb") as f:
header = f.readline()
vocab_size, layer1_size = map(int, header.split())
binary_len = np.dtype('float32').itemsize * layer1_size
for line in xrange(vocab_size):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_word2vec_model():\n logging.basicConfig(\n format='%(asctime)s : %(levelname)s : %(message)s', \n level=logging.INFO)\n model_path = '/playpen/home/tongn/GoogleNews-vectors-negative300.bin'\n model = KeyedVectors.load_word2vec_format(fname=model_path, binary=True)\n return model"... | [
"0.76019704",
"0.742075",
"0.7389909",
"0.734901",
"0.7344073",
"0.71604186",
"0.7155626",
"0.70614433",
"0.7006758",
"0.6975921",
"0.6915394",
"0.6902017",
"0.69003725",
"0.6872555",
"0.6856889",
"0.6849271",
"0.6808106",
"0.6806605",
"0.6799634",
"0.6782137",
"0.6776794",
... | 0.65175366 | 39 |
You can set label property. | def __repr__(self) -> str:
class_name = self.__class__.__name__
pk = self.id # type: ignore
label = getattr(self, "label", "")
return f'<{class_name}({pk}:{label!r})>' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setLabel(self, label):\r\n\t\tself.label = label",
"def setLabel(self, label):\r\n\t\tself.label = label",
"def setLabel(self, label):\r\n\t\tself.label = label",
"def SetLabel(self, label):\r\n\r\n self.label = label",
"def label(self, label):\n\n self._label = label",
"def label(self,... | [
"0.9090345",
"0.9090345",
"0.9090345",
"0.87645483",
"0.86649144",
"0.86649144",
"0.86649144",
"0.86649144",
"0.86649144",
"0.86649144",
"0.86649144",
"0.86649144",
"0.86649144",
"0.86649144",
"0.86649144",
"0.8575247",
"0.8406376",
"0.84045035",
"0.8354132",
"0.83295137",
"0... | 0.0 | -1 |
Column that adds primary key foreign key reference. | def reference_col(tablename: str, nullable: bool = False, pk_name: str = 'id',
onupdate: str = None, ondelete: str = None, **kwargs: Any) \
-> Column:
return Column(
ForeignKey('{0}.{1}'.format(tablename, pk_name),
onupdate=onupdate, ondelete=ondelete),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ReferenceCol(tablename, nullable=False, pk_name='id', **kwargs):\n return db.Column(\n db.ForeignKey(\"{0}.{1}\".format(tablename, pk_name)),\n nullable=nullable, **kwargs)",
"def reference_col(tablename, nullable=True, pk_name='id', **kwargs):\n return db.Column(\n db.ForeignKey('... | [
"0.7489892",
"0.73920554",
"0.70771027",
"0.64817816",
"0.6393585",
"0.62086946",
"0.61619574",
"0.60691184",
"0.58412683",
"0.5764522",
"0.5702417",
"0.56470424",
"0.5642272",
"0.5633937",
"0.5618169",
"0.5618169",
"0.5618169",
"0.5618169",
"0.56098497",
"0.55792147",
"0.553... | 0.7201066 | 2 |
The number of rows or columns in a patch extraction grid. | def _num_extracted_rows_and_columns(
image_size: int,
patch_size: int,
stride: int,
num_scales: int,
scale_factor: int,
) -> int:
largest_patch_size = int(patch_size * (scale_factor**(num_scales - 1)))
residual = image_size - largest_patch_size
return (residual // stride) + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plaquette_rows_cols(self):\n return len(self.minor_yvals()), len(self.minor_xvals())",
"def num_tiles(self):\n return self.num_row_tiles * self.num_col_tiles",
"def ncells(self):\n return self.izone.size",
"def getNumTiles(self):\n return self.w * self.h",
"def size(self):\n ... | [
"0.78464913",
"0.78142715",
"0.7716126",
"0.7626603",
"0.76048946",
"0.7598101",
"0.75613004",
"0.7550961",
"0.7520141",
"0.7501207",
"0.74937814",
"0.74850416",
"0.7461705",
"0.7411939",
"0.7409282",
"0.7402846",
"0.73934966",
"0.73903716",
"0.73784256",
"0.7349377",
"0.7322... | 0.6874424 | 51 |
Extract single scale patches from the given image. This op is implemented purely in Tensorflow and so may be more memory efficient when only singlescale patches are required. | def extract_patches_single_scale(
patch_size: int,
stride: int,
image_lt: lt.LabeledTensor,
name: str = None,
) -> Tuple[np.ndarray, lt.LabeledTensor]:
with tf.compat.v1.name_scope(name, "extract_patches_single_scale", [image_lt]) as scope:
image_lt = lt.transpose(image_lt, ["batch", "row", "colum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _extract_patches_and_positions_from_image(\n image, patch_size, patch_stride, hse_grid_size,\n n_crops, h, w,\n c, scale_id, max_seq_len):\n p = tf.image.extract_patches(\n image, [1, patch_size, patch_size, 1], [1, patch_stride, patch_stride, 1],\n [1, 1, 1, 1],\n padding='SAME')\n\n ... | [
"0.6790287",
"0.65466",
"0.6151751",
"0.6099914",
"0.59317386",
"0.5905685",
"0.57604104",
"0.5746815",
"0.573609",
"0.5610079",
"0.56077653",
"0.56040645",
"0.5576093",
"0.5573452",
"0.5562469",
"0.5551167",
"0.5530099",
"0.55173755",
"0.54859334",
"0.5467564",
"0.54598343",... | 0.7401282 | 0 |
Compute statistics of the given distributions. The statistics are computed assuming the first class has value 0.0 and the last class has value 1.0, with a linear progression in between. | def distribution_statistics(distribution_lt: lt.LabeledTensor,
name: str = None) -> lt.LabeledTensor:
# This is the number of statistics computed by distribution_statistics.
num_statistics = 6
with tf.compat.v1.name_scope(name, "distribution_statistics",
[distribut... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _class_distribution(y):\n unique, counts = np.unique(y, return_counts = True)\n\n percentages = counts / np.sum(counts)\n\n return unique, counts, percentages",
"def distribution_statistics(feat):\n \n return [np.median(feat),np.min(feat),np.max(feat),np.std(feat),\n np.std(feat)/ab... | [
"0.68734366",
"0.6468991",
"0.62134933",
"0.60060537",
"0.59643877",
"0.5949125",
"0.5901382",
"0.5898189",
"0.5834337",
"0.58121556",
"0.5723928",
"0.5710522",
"0.570123",
"0.56938374",
"0.568001",
"0.56670696",
"0.56273925",
"0.5580179",
"0.5553914",
"0.55065745",
"0.55061"... | 0.551426 | 19 |
Composite images into a larger image. | def patches_to_image(patch_centers: np.ndarray,
patch_lt: lt.LabeledTensor,
name: Optional[str] = None) -> lt.LabeledTensor:
with tf.compat.v1.name_scope(name, "patches_to_image", [patch_lt]) as scope:
patch_lt = lt.transpose(patch_lt, ["batch", "row", "column", "channel"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getComposite(images):\n composite = mapnik.Image(images[0].width(), images[0].height())\n for image in images:\n composite.blend(0, 0, image, 1.0)\n return composite",
"def composite(args):\n\n # load the input image\n logging.info('Loading input image %s' % (args.input))\n inputImag... | [
"0.74335957",
"0.72053564",
"0.70485693",
"0.70225734",
"0.6925989",
"0.6917122",
"0.68173444",
"0.6806442",
"0.6724852",
"0.6722042",
"0.67096394",
"0.6651694",
"0.6634226",
"0.66334665",
"0.65973663",
"0.65869004",
"0.6549259",
"0.64408803",
"0.6438038",
"0.64255583",
"0.64... | 0.0 | -1 |
You are given a binary tree in which each node contains a value Design an algorithm to print all paths which sum up to that value Note that it can be any path in the tree it does not have to start at the root | def find_sum(root, desired_sum, level=0, buffer_list=None, result=[]):
if not buffer_list:
buffer_list = []
if not root:
return result
buffer_list.append(root.key)
temp = desired_sum
for i in range(level, -1, -1):
temp -= buffer_list[i]
if temp == 0:
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum_tree(t):\n \"*** YOUR CODE HERE ***\"\n if is_leaf(t):\n return entry(t)\n total = entry(t)\n for subtree in subtrees(t):\n total += sum_tree(subtree)\n return total",
"def minimum_path_sum(self, root) -> int:\n\n def minimum_path_sum_aux(root, path=None):\n ... | [
"0.6511818",
"0.64953613",
"0.6275917",
"0.61998004",
"0.60497695",
"0.6035713",
"0.6006674",
"0.5971123",
"0.59583557",
"0.5931027",
"0.5919312",
"0.59181577",
"0.5897086",
"0.5884444",
"0.5843002",
"0.5836156",
"0.5834166",
"0.5827653",
"0.58110356",
"0.57977957",
"0.578840... | 0.54353625 | 53 |
PackageNote a model defined in Swagger | def __init__(self, package_id=None, feed_id=None, version=None, notes=None): # noqa: E501 # noqa: E501
self._package_id = None
self._feed_id = None
self._version = None
self._notes = None
self.discriminator = None
if package_id is not None:
self.package_id... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_model(self, ApiId: str, Name: str, Schema: str, ContentType: str = None, Description: str = None) -> Dict:\n pass",
"def __init__(self, **kwargs):\n self.swagger_types = {\n 'id': 'str',\n 'name': 'str',\n 'version': 'str',\n 'tagline': 'str',\... | [
"0.6364354",
"0.617273",
"0.6111821",
"0.6108606",
"0.6108181",
"0.6101461",
"0.6074732",
"0.60045713",
"0.59886175",
"0.5938213",
"0.59370977",
"0.59185207",
"0.5850837",
"0.5837559",
"0.5812189",
"0.5780374",
"0.57577115",
"0.57191867",
"0.5706632",
"0.56934375",
"0.5693437... | 0.0 | -1 |
Sets the package_id of this PackageNote. | def package_id(self, package_id):
self._package_id = package_id | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def package_id(self, package_id):\n if package_id is None:\n raise ValueError(\"Invalid value for `package_id`, must not be `None`\") # noqa: E501\n\n self._package_id = package_id",
"def package(self, package):\n\n self._package = package",
"def set_package(self, pkg): ... | [
"0.75330186",
"0.66790247",
"0.6289974",
"0.5844584",
"0.5844584",
"0.5831869",
"0.5829048",
"0.58280915",
"0.5799856",
"0.5799856",
"0.5799856",
"0.5799856",
"0.5799856",
"0.5799856",
"0.5775636",
"0.5762894",
"0.57389355",
"0.5732315",
"0.571768",
"0.57117283",
"0.5708129",... | 0.8552788 | 0 |
Sets the feed_id of this PackageNote. | def feed_id(self, feed_id):
self._feed_id = feed_id | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_feed(self, feed: None | Feed = None) -> None:\n self.current_feed = feed\n self.refresh()",
"def setID(self, idf):\n self.id = idf",
"def package_id(self, package_id):\n\n self._package_id = package_id",
"def set_id(self, id_):\n\n self.id_ = id_",
"def set_id(... | [
"0.625687",
"0.5923461",
"0.5919375",
"0.5891008",
"0.5732699",
"0.57217383",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0.55821204",
"0... | 0.8309776 | 0 |
Sets the version of this PackageNote. | def version(self, version):
self._version = version | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def version(self, version):\n \n self._version = version",
"def version(self, version):\n self._version = version",
"def version(self, version):\n self._version = version",
"def version(self, version: str):\n\n self._version = version",
"def version(self, version: str):\n... | [
"0.760427",
"0.7593128",
"0.7593128",
"0.754977",
"0.754977",
"0.7438496",
"0.7233368",
"0.7225656",
"0.70923275",
"0.7087204",
"0.7039731",
"0.69800216",
"0.6957732",
"0.6888694",
"0.6833704",
"0.68327606",
"0.6807293",
"0.6776633",
"0.67301774",
"0.6727152",
"0.6727152",
... | 0.7468903 | 24 |
Sets the notes of this PackageNote. | def notes(self, notes):
self._notes = notes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setNotes(self, *args):\n return _libsbml.SBase_setNotes(self, *args)",
"def notes(self, notes: str):\n self._notes = notes",
"def notes(self, notes):\n if notes is None:\n raise ValueError(\"Invalid value for `notes`, must not be `None`\") # noqa: E501\n\n self._note... | [
"0.8039335",
"0.80103546",
"0.79160607",
"0.6865212",
"0.6451192",
"0.6409795",
"0.62720746",
"0.6076015",
"0.60153705",
"0.60153705",
"0.5956476",
"0.5955603",
"0.59426844",
"0.594014",
"0.5938115",
"0.59310466",
"0.58872205",
"0.58405113",
"0.58312994",
"0.5830103",
"0.5770... | 0.8249744 | 2 |
Returns the model properties as a dict | def to_dict(self):
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n return self.properties",
"def to_dict(self):\n return self.properties",
"def get_properties(self):\n return self.properties",
"def asdict(self):\n return self._prop_dict",
"def json(self):\n rv = {\n prop: getattr(self, prop)\n f... | [
"0.7751324",
"0.7751324",
"0.7337662",
"0.73335254",
"0.72966903",
"0.72765553",
"0.7157653",
"0.71558887",
"0.7147938",
"0.7147938",
"0.7126862",
"0.71260864",
"0.7121746",
"0.71060866",
"0.7059236",
"0.704307",
"0.70337325",
"0.70245665",
"0.69634634",
"0.6960516",
"0.68999... | 0.0 | -1 |
Returns the string representation of the model | def to_str(self):
return pprint.pformat(self.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return super().__str__() + self.model.__str__()",
"def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n ... | [
"0.85856134",
"0.7814518",
"0.77898884",
"0.7751367",
"0.7751367",
"0.7712228",
"0.76981676",
"0.76700574",
"0.7651133",
"0.7597206",
"0.75800353",
"0.7568254",
"0.7538184",
"0.75228703",
"0.7515832",
"0.7498764",
"0.74850684",
"0.74850684",
"0.7467648",
"0.74488163",
"0.7442... | 0.0 | -1 |
For `print` and `pprint` | def __repr__(self):
return self.to_str() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pprint(*args, **kwargs):\n if PRINTING:\n print(*args, **kwargs)",
"def print_out():\n pass",
"def custom_print(*objects):\n print(*objects, sep=OFS, end=ORS)",
"def _print(self, *args):\n return _ida_hexrays.vd_printer_t__print(self, *args)",
"def _printable(self):\n ... | [
"0.75577617",
"0.73375154",
"0.6986672",
"0.698475",
"0.6944995",
"0.692333",
"0.6899106",
"0.6898902",
"0.68146646",
"0.6806209",
"0.6753795",
"0.67497987",
"0.6744008",
"0.6700308",
"0.6691256",
"0.6674591",
"0.6658083",
"0.66091245",
"0.6606931",
"0.6601862",
"0.6563738",
... | 0.0 | -1 |
Returns true if both objects are equal | def __eq__(self, other):
if not isinstance(other, PackageNote):
return False
return self.__dict__ == other.__dict__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False",
"def __eq__(self, other):\n if i... | [
"0.80885184",
"0.80885184",
"0.805514",
"0.7983044",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
"0.7966715",
... | 0.0 | -1 |
Returns true if both objects are not equal | def __ne__(self, other):
return not self == other | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.8457179",
"0.8393067",
"0.81457263",
"0.8140635",
"0.8133462",
"0.8094992",
"0.8093376",
"0.8093376",
"0.8093376",
"0.80863357",
"0.80863357",
"0.8077303",
"0.8077303",
"0.8066831"
] | 0.0 | -1 |
logfunction. will be removed for final version. | def LOG(s):
logfilejosi = open('/var/log/vamdc_josi.log','a')
s = str(s)
logfilejosi.write(s + '\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setLogFunction(function):\n None",
"def setLogFunction(function):\n _setLogFunction(function)",
"def log(a):",
"def log_method(f):\n return log(f, ignore_first=True)",
"def _info(self, func):\n self.logger.info(\"llamando a %s\" % func)",
"def _log(fn):\n @wraps(fn)\n def wr... | [
"0.79407287",
"0.7664612",
"0.7422398",
"0.7330617",
"0.72990507",
"0.7251669",
"0.7251345",
"0.7233205",
"0.7179204",
"0.70030415",
"0.6930351",
"0.6890592",
"0.6865771",
"0.68590295",
"0.6761506",
"0.67430514",
"0.6710775",
"0.6693021",
"0.66312206",
"0.6603988",
"0.6561712... | 0.0 | -1 |
This function is always called by the software. | def setupResults(sql, limit=1000):
# log the incoming query
LOG(sql)
#x_internal is the list for the iteration over one search result, x the overall list (which is deduplicated in the end)
molecules = []
molecules_internal = []
atoms = []
atoms_internal = []
sources = []
source... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self): \r\n return",
"def __call__(self):\n\t\treturn",
"def use(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def run(self):",
"def support(... | [
"0.6861618",
"0.6840663",
"0.68093973",
"0.6744555",
"0.6744555",
"0.6744555",
"0.6744555",
"0.6744555",
"0.6744555",
"0.6744555",
"0.6744555",
"0.6744555",
"0.6744555",
"0.66817826",
"0.6671694",
"0.6635426",
"0.66284263",
"0.6610892",
"0.65700054",
"0.65674466",
"0.6540517"... | 0.0 | -1 |
Return a logger instance. | def _logger(self) -> logging.Logger:
return logging.getLogger(
type(self).__name__
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_instance():\n if Logger._logger_instance is None:\n Logger()\n return Logger._logger_instance",
"def get_logger():\r\n global logger\r\n \r\n if logger:\r\n return logger\r\n else:\r\n return create_logger()",
"def logger(self) -> logging.Logger:\n ... | [
"0.83598185",
"0.8020046",
"0.7995714",
"0.79763085",
"0.79743767",
"0.78651994",
"0.7845615",
"0.78387433",
"0.7820369",
"0.7789571",
"0.775313",
"0.77197665",
"0.7691047",
"0.76821923",
"0.76750916",
"0.76057553",
"0.75533676",
"0.7547843",
"0.75393784",
"0.7525153",
"0.752... | 0.81544775 | 1 |
Return value of the entrez_gene_id attribute | def entrez_gene_id(gene: GeneInfo):
if (gene.identifiers is not None and gene.identifiers.entrez is not None):
if (gene.identifiers.entrez.startswith('NCBIGene:')):
return gene.identifiers.entrez[9:]
else:
return gene.identifiers.entrez
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entrez_gene_id(self) -> int:\n return self._entrez_gene_id",
"def id(self):\n return self.gene_id",
"def get_entrezid(gene):\n entrezurl = \"http://mygene.info/v3/query?q=\"\n entrezurl = entrezurl+gene\n\n res = requests.get(entrezurl)\n results = pandas.read_json(StringIO(res.te... | [
"0.8480993",
"0.81633437",
"0.76325184",
"0.7556689",
"0.73744255",
"0.73152524",
"0.7198804",
"0.7082559",
"0.70238787",
"0.69691044",
"0.6916383",
"0.66375375",
"0.65141195",
"0.6487426",
"0.6360097",
"0.633752",
"0.6311204",
"0.6283059",
"0.6261556",
"0.6259344",
"0.625212... | 0.81055087 | 2 |
consistent with R print correct_pvalues_for_multiple_testing([0.0, 0.01, 0.029, 0.03, 0.031, 0.05, 0.069, 0.07, 0.071, 0.09, 0.1]) | def correct_pvalues_for_multiple_testing(pvalues, correction_type = "Benjamini-Hochberg"):
pvalues = array(pvalues)
n = int(pvalues.shape[0])
new_pvalues = empty(n)
if correction_type == "Bonferroni":
new_pvalues = n * pvalues
elif correction_type == "Bonferroni-Holm":
values = [ (pv... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_correct_p_values(self):\r\n exp = [0.003, 0.006, 0.003]\r\n obs = self.mc._correct_p_values([0.001, 0.002, 0.001])\r\n assert_almost_equal(obs, exp)",
"def test_correct_p_values_no_change(self):\r\n exp = [None, 0.008]\r\n obs = self.mc._correct_p_values([None, 0.008])... | [
"0.783897",
"0.74392277",
"0.7198531",
"0.7181438",
"0.71745723",
"0.70671207",
"0.6688648",
"0.6676265",
"0.66302013",
"0.65230614",
"0.6508956",
"0.6374666",
"0.6314954",
"0.62354577",
"0.61699605",
"0.6153693",
"0.6120595",
"0.6110194",
"0.6095493",
"0.6084531",
"0.6079362... | 0.72098184 | 2 |
Test case with only valid requests. | def test_case1(self):
email = "test1@email.com"
password = "testtesttest"
first_name = "name1"
family_name = "name2"
gender = "Male"
city = "Testcity"
country = "Testcountry"
# test sign up
response = test_sign_up(email, password, first_name, fam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_request_invalid(self, nosleep, method):\n # Dummies for K8s API URL and `requests` session.\n url = 'http://localhost:12345/'\n client = k8s.requests.Session()\n\n urls = [\n \"localhost\", # missing schema like \"http://\"\n \"httpinvalid://localho... | [
"0.71860117",
"0.71185094",
"0.69164205",
"0.687908",
"0.6855383",
"0.68520737",
"0.6842052",
"0.6829176",
"0.67974967",
"0.6791964",
"0.67868394",
"0.67697984",
"0.674673",
"0.6720797",
"0.6718986",
"0.66736305",
"0.66663545",
"0.6637583",
"0.66289175",
"0.6617394",
"0.66114... | 0.0 | -1 |
Test cases for invalid sign up and sign in. | def test_case2(self):
valid_email = "test2@email.com"
valid_password = "asdasdasd"
valid_firstname = "name1"
valid_familyname = "name2"
valid_gender = "Female"
valid_city = "Testcity"
valid_country = "Testcountry"
# Valid sign up
response = test_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_5_sign_in_functionality_invalid_email_password(self):\n self.log.debug(\"Validate email and password fields are present\")\n self.page.validate_sign_in_window_elements()\n email = \"abc@gmail.com\" #Invalid email id\n password = \"123456\" #Invalid password\n self.log.de... | [
"0.7088148",
"0.6885961",
"0.6880667",
"0.67373586",
"0.6704038",
"0.6618481",
"0.6604394",
"0.65910316",
"0.6590093",
"0.6574882",
"0.65321714",
"0.6514206",
"0.65073717",
"0.6412174",
"0.63692397",
"0.6344882",
"0.6337391",
"0.63259315",
"0.63258",
"0.6323248",
"0.6315085",... | 0.69835126 | 1 |
Test cases for invalid options for remaining singleuser functions. | def test_case3(self):
email = "test3@email.com"
password = "huehuehuehue"
first_name = "name1"
family_name = "name2"
gender = "Male"
city = "Testcity"
country = "Testcountry"
bad_token = "bad token"
# Sign up with valid data
response = t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_invalid_options(self):\n\n wf._items = []\n\n sys.argv = ['drive.py', '> not here']\n main(None)\n self.assertEqual(len(wf._items), 1)\n self.assertEqual(wf._items[0].title, ERRORS['InvalidOption']['title'])\n self.assertFalse(wf._items[0].valid)\n self.ass... | [
"0.6921977",
"0.6483761",
"0.6326724",
"0.62633187",
"0.62252504",
"0.61532855",
"0.61503947",
"0.61236167",
"0.60741204",
"0.60654956",
"0.6053451",
"0.6017857",
"0.60027343",
"0.5996068",
"0.5989205",
"0.59843975",
"0.5980413",
"0.5966038",
"0.596315",
"0.59494287",
"0.5923... | 0.0 | -1 |
Test cases for functionality that requires multiple users. | def test_case4(self):
email1 = "test4@email.com"
password1 = "asdasdasd"
first_name1 = "name1"
family_name1 = "name2"
gender1 = "Male"
city1 = "Testcity"
country1 = "Testcountry"
email2 = "test5@email.com"
password2 = "asdasdasd"
first_na... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_users(self):\n pass",
"def test_user(self):\n return True",
"def test_multiple_success():\n test_usernames = [\"foo\", \"bar\", \"baz\"]\n\n for username in test_usernames:\n user = UserFactory.create(username=username, is_active=True)\n UserSocialAuthFactory.crea... | [
"0.7163188",
"0.7157695",
"0.69663084",
"0.69517297",
"0.69517297",
"0.69436216",
"0.6935643",
"0.69141805",
"0.6906897",
"0.68688667",
"0.68404806",
"0.6802677",
"0.6797317",
"0.67824656",
"0.6778907",
"0.6778907",
"0.67548573",
"0.67390066",
"0.6729447",
"0.6699855",
"0.667... | 0.0 | -1 |
This function is run once each time the robot enters autonomous mode. | def autonomousInit(self):
fieldState = self.driverStation.getGameSpecificMessage()
self.fieldState = fieldState
self.smartDashboard.putString("field state", fieldState)
fieldPosition = self.smartDashboard.getString("field position", "")
self.startingFieldPosition = self.parserobo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def autonomousInit(self):\n self.globalInit()\n self.autonomous.start()",
"def _on_autonomous_enable(self) -> None:\n\n # XXX: FRC Dashboard compatibility\n # -> if you set it here, you're stuck using it. The FRC Dashboard\n # doesn't seem to have a default (nor will it show... | [
"0.7591189",
"0.7282657",
"0.6770413",
"0.6743494",
"0.65831965",
"0.65689296",
"0.6427243",
"0.6401029",
"0.63937986",
"0.6374063",
"0.6336391",
"0.6330447",
"0.6317473",
"0.6311653",
"0.6310341",
"0.63009936",
"0.62906706",
"0.6163547",
"0.6159578",
"0.6144214",
"0.6138753"... | 0.6548382 | 6 |
Partial update an object | def patch(self, request, pk=None):
return Response({'message': 'patch'}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def partial_update(self, request, pk=None): #partial update a specific object\n return Response({'http_method': 'PATCH'})",
"def partial_update(self, request, *args, **kwargs):\n instance = self.get_object()\n serializer = self.get_serializer(instance, data=request.data, partial=True)\n ... | [
"0.7891486",
"0.7636699",
"0.7306302",
"0.7305018",
"0.72183466",
"0.72084665",
"0.72012454",
"0.7157133",
"0.68633926",
"0.6843239",
"0.6759846",
"0.66094255",
"0.65638405",
"0.65014493",
"0.64954484",
"0.64345",
"0.6399024",
"0.6390871",
"0.6384979",
"0.6374396",
"0.6374061... | 0.0 | -1 |
Helper function to normalize version Returns a comparable object | def normalize_version(v):
rv = []
for x in v.split("."):
try:
rv.append(int(x))
except ValueError:
for y in re.split("([0-9]+)", x):
try:
if y != '':
rv.append(int(y))
except ValueError:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __cmp__(self, other):\n\n from distutils.version import LooseVersion\n return cmp(self.version, LooseVersion(other))",
"def __lt__(self, compareto: Union[str, float, int, \"AwesomeVersion\"]) -> bool:\n if isinstance(compareto, (str, int)):\n compareto = AwesomeVersion(compareto)\n ... | [
"0.6619351",
"0.6102797",
"0.58966285",
"0.587306",
"0.58682376",
"0.5844353",
"0.58272856",
"0.5782349",
"0.5742186",
"0.570351",
"0.56979656",
"0.5681768",
"0.56780016",
"0.5670993",
"0.56692773",
"0.56069744",
"0.5596596",
"0.55778956",
"0.5548947",
"0.553731",
"0.553731",... | 0.0 | -1 |
Upgrade the package if there is a later version available. | def upgrade_if_needed(self, restart = True, dependencies = False):
if self.check():
print "Upgrading %s" % self.pkg
self.upgrade(dependencies)
if restart:
self.restart() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upgrade(self, old_version, new_version):\n pass",
"def upgrade(self):",
"def upgrade(self):",
"def downgrade():\n pass",
"def downgrade():\n pass",
"def downgrade():\n raise NotImplementedError(\"Downgrade is not supported\")",
"def downgrade():\n raise NotImplementedError(\"Downgrade is... | [
"0.723688",
"0.7112298",
"0.7112298",
"0.7022366",
"0.7022366",
"0.7015959",
"0.7015959",
"0.7015959",
"0.69837075",
"0.66312116",
"0.657686",
"0.65517104",
"0.6545114",
"0.6488389",
"0.64031035",
"0.63755894",
"0.63752556",
"0.6303454",
"0.6300192",
"0.62987626",
"0.62968373... | 0.7406573 | 0 |
Upgrade the package unconditionaly | def upgrade(self, dependencies = False):
pip_args = []
proxy = environ.get('http_proxy')
if proxy:
pip_args.append('--proxy')
pip_args.append(proxy)
pip_args.append('install')
pip_args.append(self.pkg)
if self.index is not None:
pip_arg... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upgrade(self):",
"def upgrade(self):",
"def upgrade_if_needed(self, restart = True, dependencies = False):\n if self.check():\n print \"Upgrading %s\" % self.pkg\n self.upgrade(dependencies)\n if restart:\n self.restart()",
"def downgrade():\n pass"... | [
"0.77651864",
"0.77651864",
"0.7289119",
"0.71871936",
"0.71871936",
"0.7091273",
"0.7091273",
"0.7091273",
"0.6949011",
"0.69193083",
"0.6769115",
"0.67193484",
"0.6690322",
"0.6638302",
"0.66124755",
"0.65871555",
"0.65205747",
"0.65131366",
"0.6512471",
"0.64781505",
"0.64... | 0.6239241 | 25 |
Restart application with same args as it was started. Does not return | def restart(self):
print "Restarting " + executable + " " + str(argv)
execl(executable, *([executable]+argv)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def restart(reason, *args, **kwargs):\n logging.info(\"Restarting: %s\" % reason)\n os.execv(sys.argv[0], sys.argv)",
"def RestartApp(argv_extra):\n\n p = psutil.Process(os.getpid())\n for handler in p.open_files() + p.connections():\n if handler.fd != -1:\n os.close(handler.fd)\n\n... | [
"0.7492682",
"0.7328665",
"0.7202149",
"0.7188887",
"0.7183816",
"0.71728677",
"0.7089019",
"0.70228314",
"0.70211715",
"0.7020362",
"0.69969636",
"0.69169647",
"0.68793124",
"0.68679875",
"0.6858443",
"0.6785412",
"0.67613715",
"0.67178905",
"0.67106485",
"0.66852856",
"0.66... | 0.7907249 | 0 |
Check if pkg has a later version Returns true if later version exists. | def check(self):
current = self._get_current()
# There is no version, so don't attempt to upgrade
if current[-1]:
return False
highest = self._get_highest_version()
return highest > current | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _checkUpdateNeeded(self):\n try:\n currentVersionLine = str(subprocess.run(['pacman', '-Q', '-i', self._name],\n stdout=subprocess.PIPE, stderr=subprocess.STDOUT, check=True).stdout)\n currentVersion = re.sub(r'.*Version\\s*: ([\\d|\\.]*)-.*'... | [
"0.7021907",
"0.6526294",
"0.6518159",
"0.6440555",
"0.6406439",
"0.6377378",
"0.6335543",
"0.6268659",
"0.62651664",
"0.62472224",
"0.61878824",
"0.61660576",
"0.6135595",
"0.61285186",
"0.61124414",
"0.61058915",
"0.60857654",
"0.6072164",
"0.60495275",
"0.6023318",
"0.5998... | 0.650313 | 3 |
Make sure arguments passed are defined as optional args. | def validate_optional_arg(non_required_arg, optional_type):
LOG.debug('non_required_arg: %s, optional_type: %s', non_required_arg, optional_type)
if isinstance(non_required_arg, dict):
for key, val in non_required_arg.items():
if type(key) in optional_type:
# Make sure given ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_optional_arguments(self, *args):\n self._add_sample_specific_arguments(False, *args)",
"def _check_args(self, args_):\n\n pass",
"def valid_args(args):\n return args is not None and len(args) > 0",
"def validate_args(self):\n\n parser = argparse.ArgumentParser()\n\n par... | [
"0.7520359",
"0.7495491",
"0.7475243",
"0.74102503",
"0.7395206",
"0.7393366",
"0.7276745",
"0.7087539",
"0.7069196",
"0.70623475",
"0.7059742",
"0.705419",
"0.7047886",
"0.7002783",
"0.69643813",
"0.69628036",
"0.6914736",
"0.6901701",
"0.68822724",
"0.6843955",
"0.6840575",... | 0.0 | -1 |
Make sure required arguments are present. | def validate_required_arg(new_arg, required_type):
LOG.debug('new_arg: %s, required_type: %s', new_arg, required_type)
if (isinstance(required_type, dict)
and len(required_type.keys()) == 1
and len(required_type.values()) == 1
and type(list(required_type.keys())[0]) == type):... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_required(self):\n for argument in self.arguments:\n if argument.required:\n raise ArgumentRequiredError(argument, self.tagname)\n else:\n self.kwargs[argument.name] = argument.get_default()",
"def check_required(self, required):\n for k ... | [
"0.8181676",
"0.78702474",
"0.7787294",
"0.774969",
"0.7489102",
"0.7430658",
"0.7272238",
"0.72162896",
"0.71618503",
"0.7148597",
"0.7102853",
"0.70787334",
"0.70622075",
"0.70550203",
"0.7045379",
"0.70346355",
"0.6999009",
"0.69819504",
"0.6967147",
"0.69366306",
"0.69362... | 0.0 | -1 |
initializes config paths based on json file | def load_configs(self, json_fname):
attr_dict = {key: value for key, value in self.__dict__.items() if
not key.startswith("__") and isinstance(value, str)}
with open(json_fname) as data_file:
jn = json.load(data_file)
for key, value in attr_dict.items():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_configs(self):\n\n # get current location\n self.script_dir = os.path.dirname(__file__)\n\n # load configuration file\n with open(os.path.join(self.script_dir, \"config.json\")) as f:\n self.configs = json.load(f)\n \n # load some configs as attributes\... | [
"0.7472599",
"0.7347027",
"0.7163628",
"0.7163628",
"0.71142066",
"0.6932154",
"0.6710952",
"0.6697616",
"0.6696893",
"0.66957915",
"0.66771334",
"0.66642076",
"0.6625074",
"0.65872264",
"0.65341294",
"0.6515458",
"0.6499426",
"0.6485855",
"0.6477584",
"0.64485854",
"0.638551... | 0.62096363 | 39 |
transforms data by cropping, contrast, brightness, color, sharpness, and more | def data_tf(img):
img = crop.process(img)
img = random_contrast.process(img)
img = random_brightness.process(img)
img = random_color.process(img)
img = random_sharpness.process(img)
if img.size[1] >= 32:
img = compress.process(img)
img = adjust_resolution.process(img)
img... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalise(image):",
"def pre_processing_image(img):\n\n #print(img.shape)\n # apply gamma correction and show the images\n #adjusted = adjust_gamma(img, gamma=0.65)\n\n adjusted = exposure.adjust_gamma(img, gamma=1.65)\n #print(adjusted.shape)\n\n # log transform of image\n\n logarithmic... | [
"0.6670794",
"0.63854635",
"0.63689613",
"0.630164",
"0.630164",
"0.62767696",
"0.61236227",
"0.6019168",
"0.59998864",
"0.5999592",
"0.5993214",
"0.59788734",
"0.59414375",
"0.59368694",
"0.58620316",
"0.58577394",
"0.5838846",
"0.5823632",
"0.582191",
"0.58008796",
"0.57998... | 0.56179476 | 50 |
read from fifo and parse into dictionary | def parse_trace(self):
current = '' # current basic block being parsed
previous = '0' # previous basic block beding parsed
edge_count = 0
uniq_count = 0
with open(self._fifo_name, 'r') as fifo:
for line in fifo:
if line[6] == '... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read(self):\n buffer = ''\n while True:\n buffer = buffer + self.io.read(self.io.inWaiting())\n if ' \\n' in buffer:\n lines = buffer.split(' \\n')\n if len(lines) > 2:\n last_full_line = lines[-2]\n header, values = last_full_line.split(\" \",1)\n float... | [
"0.6154674",
"0.58273804",
"0.57860047",
"0.5758259",
"0.5704924",
"0.552367",
"0.5465178",
"0.5464379",
"0.5400063",
"0.53869545",
"0.5373874",
"0.5286278",
"0.527438",
"0.5263859",
"0.52516687",
"0.5243127",
"0.52396643",
"0.52133816",
"0.52069277",
"0.5204815",
"0.51968765... | 0.48739865 | 85 |
analyze the dynamic translation block coverage with qemu | def analyze_dynamic(self, test_input):
# Execute binary with qemu user mode while taking care of libraries
# collect dynamic translation block execution information
# 1. create a named pipe for qemu to write to
self.mkfifo()
# 2. build command and launch QEMU
# cmd = se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_addr_coverage(self):\n logger.info('Generating translation block coverage information')\n\n tb_files = get_tb_files(self.project_path('s2e-last'))\n tb_coverage_files = aggregate_tb_files(tb_files)\n ret = {}\n\n # Get the number of times each address was executed by S2E... | [
"0.5733099",
"0.5684116",
"0.5423686",
"0.53903526",
"0.5295646",
"0.52860355",
"0.5246108",
"0.5194682",
"0.5191534",
"0.51719093",
"0.5146529",
"0.51181334",
"0.51031566",
"0.508765",
"0.50834346",
"0.505631",
"0.50281286",
"0.50224406",
"0.49979833",
"0.4987376",
"0.497487... | 0.6033092 | 0 |
If a hyperspy signal is given, it is transformed into a ModifiedSignal. In that case, additional args and kwargs are discarded. | def __init__(self, *args, **kwargs):
if len(args) > 0 and isinstance(args[0], BaseSignal):
# Pretend it is a hs signal, copy axes and metadata
sdict = args[0]._to_dictionary()
self.__class__.__init__(self, **sdict)
else:
BaseSignal.__init__(self, *args, **... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def signal(self, args):\n pass",
"def test_forwards_args(self):\n seen_kwargs = {}\n\n def callback(**kwargs):\n seen_kwargs.update(kwargs)\n\n SignalHook(self.test_extension, self.signal, callback)\n self.signal.send(sender=self, foo=1, bar=2)\n\n self.assert... | [
"0.58201706",
"0.5802816",
"0.5742859",
"0.5680142",
"0.5531176",
"0.5348851",
"0.5281184",
"0.52533114",
"0.5215119",
"0.5179791",
"0.51360905",
"0.5093725",
"0.50849617",
"0.50493014",
"0.50189066",
"0.5009883",
"0.50008637",
"0.49492764",
"0.493958",
"0.49378914",
"0.49291... | 0.59273946 | 0 |
If a hyperspy Signal2D is given, it is transformed into a ModifiedImage. In that case, additional args and kwargs are discarded. | def __init__(self, *args, **kwargs):
if len(args) > 0 and isinstance(args[0], Image):
# Pretend it is a hs signal, copy axes and metadata
sdict = args[0]._to_dictionary()
Image.__init__(self, **sdict)
else:
Image.__init__(self, *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n if len(args) > 0 and isinstance(args[0], (Image, CImage)):\n # Pretend it is a hs signal, copy axes and metadata\n sdict = args[0]._to_dictionary()\n CImage.__init__(self, **sdict)\n else:\n CImage.__init__(self, *args... | [
"0.6233259",
"0.5859255",
"0.58262306",
"0.5785775",
"0.5682472",
"0.56448776",
"0.561343",
"0.5559629",
"0.5498418",
"0.54961455",
"0.54533714",
"0.54435664",
"0.54435664",
"0.54297704",
"0.5408063",
"0.5403812",
"0.5402164",
"0.5400834",
"0.5393468",
"0.5388425",
"0.538773"... | 0.62607485 | 0 |
Deprecated! use set_pad instead. Pad a hyperspy Image of navigation dimension <= 1. This is a wrapper for numpy.pad function. Additionally, as the padding information is stored in metadata, it is possible to reverse the effect of this function with a call to the unset_padding method. | def set_padding(self, pad_width=None, *erps, **kw):
if pad_width is None:
# If padding == None:
# Same signal is returned, nothing else done
return self
# Store padded data and exit
s = self.deepcopy()
if self.axes_manager.navigation_dimension == 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_padding(im, pad):\n\n return np.pad(im, pad_width=((pad, pad), (pad, pad), (0, 0)), mode='symmetric')",
"def pad(self, *args, **kwargs):\n return _image.image_pad(self, *args, **kwargs)",
"def _pad_image(self, img: ndarray, pad_width: int = 10) -> ndarray:\n self.padded_img = np.zeros(... | [
"0.66617864",
"0.63132435",
"0.6255937",
"0.61713904",
"0.6079077",
"0.6016708",
"0.59918535",
"0.59772426",
"0.5958085",
"0.58424485",
"0.5815568",
"0.58081615",
"0.58037835",
"0.58019966",
"0.5799036",
"0.579806",
"0.57655376",
"0.57642895",
"0.5691326",
"0.56810474",
"0.56... | 0.6223679 | 3 |
This method returns an unpadded copy of a padded Image by reading the value from metadata. See the set_padding function for more information. Note the set_pad method and unset_padding are Deprecated in favor of set_pad. | def unset_padding(self):
if self.metadata.Signal.has_item('pad_tuple'):
Npy, Npx = self.metadata.Signal.pad_tuple
else:
# If no padding was done, return the same signal
return self
Nx, Ny = self.axes_manager.signal_shape
s=self.deepcopy()
del s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_padding(im, pad):\n\n return im[pad:-pad, pad:-pad]",
"def padding(image, padded_size):\n image_row, image_col = image.shape #asigna alto y ancho de la imagen \n\n padded_image = np.zeros((image_row + padded_size*2, image_col + padded_size*2)) #matriz de imagen con padding en zeros\n print... | [
"0.6686708",
"0.60340595",
"0.6015768",
"0.5856643",
"0.58009404",
"0.57768005",
"0.57617044",
"0.5709223",
"0.5699135",
"0.5642607",
"0.5624117",
"0.5597678",
"0.5559465",
"0.54506725",
"0.5443101",
"0.5443005",
"0.54270214",
"0.5399542",
"0.5328586",
"0.5314647",
"0.5288809... | 0.5474216 | 13 |
Returns the real space coordinate vectors for this image. | def get_real_space(self, shifted=True, shifts=None):
scales, offsets, coords = [], [], []
for axi in self.axes_manager.signal_axes:
scales += [axi.scale,]
offsets += [axi.offset,]
coords += [axi.axis.copy(),]
if shifted:
for io in range(2):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vec(self):\r\n\r\n xv = np.arange(self.dx / 2, self.lx, self.dx)\r\n yv = np.arange(-self.ly / 2 + self.dy / 2, self.ly / 2, self.dy)\r\n zv = np.arange(self.oz, self.lz + self.oz, self.dz)\r\n\r\n if self.ox != 0:\r\n xv = np.arange(self.ox, self.lx + self.ox, self.dx)\r... | [
"0.73288465",
"0.6918892",
"0.6731269",
"0.67148864",
"0.6648549",
"0.664336",
"0.6614607",
"0.6583926",
"0.65650994",
"0.6505811",
"0.65025306",
"0.64973223",
"0.6463893",
"0.64560205",
"0.6419003",
"0.6400466",
"0.63788056",
"0.6352214",
"0.6321161",
"0.6269683",
"0.6269301... | 0.56318724 | 86 |
Returns meshgrids for Fourier transforms of the image. Can be selected by choosing the parameter "retstr". Choosing from k2 = kx^2+ky^2, these vectors, or both. See below for more info. | def get_fourier_space(self, retstr='square'):
# Get scales
Nx, Ny = self.axes_manager.signal_shape
dx, dy = [axi.scale for axi in self.axes_manager.signal_axes]
# Calculate K-space
dky = 2.*np.pi / (Ny*dy)
dkx = 2.*np.pi / (Nx*dx)
ky1D = dky*(-np.floor(Ny/2.)+np.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getkGrid(self, scaled=True):\n if scaled:\n return np.meshgrid(fft.fftshift(self.k_axis_scaled),\n fft.fftshift(self.k_axis_scaled))\n else:\n return np.meshgrid(fft.fftshift(self.k_axis_unscaled),\n fft.fftshift(se... | [
"0.5996112",
"0.5166293",
"0.509505",
"0.50575054",
"0.50280195",
"0.49867755",
"0.49505532",
"0.49462128",
"0.49283844",
"0.48290855",
"0.4794119",
"0.47900182",
"0.47630283",
"0.47192663",
"0.46941283",
"0.46898642",
"0.46341336",
"0.46177945",
"0.4602217",
"0.45985743",
"0... | 0.61359316 | 0 |
Obtain the contrast transfer function (CTF) to model an imaging system. The CTF is given in Fourier representation. Imaging systems with high numerical aperture, NA > 1, are supported. It is possible to also obtain smooth apertures setting the fsmooth parameter. Such smoothing is performed up to fsmooth times the size ... | def get_contrast_transfer(self, defoci=None, angles=None, wlen=None,
nref=None, NA=None, fsmooth=None):
# Read defocus and angle values from input or set them from the axes
# Notice the method stops if defoci is not present
ax_count = 0
if defoci is None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ctf(ima):\n\tfrom EMAN2 import EMAN2Ctf\n\tctf_params = ima.get_attr(\"ctf\")\t\n\treturn ctf_params.defocus, ctf_params.cs, ctf_params.voltage, ctf_params.apix, ctf_params.bfactor, ctf_params.ampcont, ctf_params.dfdiff, ctf_params.dfang",
"def _excitonic_coft(self,SS,AG,n):\n \n # SystemBa... | [
"0.7002581",
"0.6209968",
"0.6088645",
"0.60796756",
"0.58631736",
"0.58065104",
"0.5677437",
"0.56587964",
"0.5646235",
"0.56107277",
"0.5602662",
"0.55997133",
"0.5555804",
"0.5444011",
"0.5426433",
"0.5417966",
"0.5346494",
"0.5341499",
"0.53395545",
"0.53183836",
"0.53132... | 0.5034486 | 36 |
If a hyperspy.signal is given, it is transformed into a ModifiedImage. In that case, additional args and kwargs are discarded. | def __init__(self, *args, **kwargs):
if len(args) > 0 and isinstance(args[0], (Image, CImage)):
# Pretend it is a hs signal, copy axes and metadata
sdict = args[0]._to_dictionary()
CImage.__init__(self, **sdict)
else:
CImage.__init__(self, *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n if len(args) > 0 and isinstance(args[0], Image):\n # Pretend it is a hs signal, copy axes and metadata\n sdict = args[0]._to_dictionary()\n Image.__init__(self, **sdict)\n else:\n Image.__init__(self, *args, **kwargs)"... | [
"0.66465324",
"0.5652755",
"0.5575546",
"0.54421556",
"0.54421556",
"0.54044956",
"0.5362523",
"0.5332503",
"0.53049153",
"0.525668",
"0.52531075",
"0.5228889",
"0.5194865",
"0.51814127",
"0.51791483",
"0.51512146",
"0.51426876",
"0.51414084",
"0.51294863",
"0.5111185",
"0.51... | 0.6489429 | 1 |
Helper method to instantiate a ModifiedImage class object from a numpy array The last 2 dimensions of the numpy array are identified as Image (Signal2D) dimensions. Any other dimensions are identified with navigation dimensions, following the hyperspy conventions. | def numpy2ModI(npdata, dsig=(1., 1.), osig=(0., 0.), dnav=(1., ), onav=(0., )):
img = ModifiedImage(npdata)
for io, axi in enumerate(img.axes_manager.signal_axes):
axi.offset = osig[io]
axi.scale = dsig[io]
if npdata.ndim > 2:
for io, axi in enumerate(img.axes_manager.navigation_axe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def newimagefromarray(self, *args, **kwargs):\n return _image.image_newimagefromarray(self, *args, **kwargs)",
"def fromarray(self, *args, **kwargs):\n return _image.image_fromarray(self, *args, **kwargs)",
"def create_from_array(cls, array: np.ndarray) -> \"TensorImage\":\n if array.dtype != ... | [
"0.7142961",
"0.66900367",
"0.63602257",
"0.625875",
"0.62094176",
"0.62019867",
"0.6056725",
"0.6047084",
"0.60209256",
"0.5842246",
"0.5758324",
"0.574834",
"0.57145417",
"0.5702823",
"0.56152433",
"0.55545264",
"0.55530345",
"0.5538081",
"0.5535631",
"0.55340606",
"0.55339... | 0.58416265 | 10 |
Simulation of focal series using nonlinear Optics. The named parameters are used to set the calculations using module CTFSim. Anonymous params (erps and kwerps) are used to calculate a contrast transfer function, through a call to the get_contrast_transfer method. | def simulate_CTF(wave, defoci, alpha=None, using_gpu=False, *erps, **kwerps):
ctsim = CTFSim(wave, zdef, alpha, using_gpu, *erps, **kwerps)
fs = ctsim()
return fs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_model_parameters(phi, T, nz, coord, SWVD, form=\"Calonne\"):\r\n D_eff = np.ones(nz)\r\n\r\n if form == \"Hansen\": # Hansen and Foslien (2015)\r\n D_eff = phi * (1 - phi) * D0 + D0\r\n elif form == \"Calonne\": # Calonne et al. (2014)\r\n x = 2 / 3 - phi\r\n b = np.heavi... | [
"0.5856837",
"0.5780712",
"0.57433075",
"0.5730712",
"0.57226616",
"0.55379325",
"0.5402803",
"0.5266863",
"0.52123934",
"0.51807517",
"0.5131692",
"0.5131424",
"0.51174015",
"0.5110087",
"0.5106631",
"0.5105571",
"0.51048374",
"0.50832444",
"0.507298",
"0.5072809",
"0.505827... | 0.0 | -1 |
Will retrieve the phase from a focal series in a deterministic fashion using the multifocus transport of intensity (MFTIE) method. The named parameters are passed to the __init__ method of module MFTIE. Anonymous parameters (erps and kwerps) are used to calculate the inverse Laplacian filters (more info in module MFTIE... | def multi_focus_TIE(fs, using_gpu=False, printing=False, *erps, **kwerps):
mftie = MFTIE(fs, using_gpu, *erps, **kwerps)
phase = mftie()
if printing:
mftie.print_k2_thres()
return phase | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gaussian_process_TIE(fs, *erps, **kwerps):\n gptie = GPTIE(fs, *erps, **kwerps)\n phase = gptie()\n return phase",
"def getPhase(phase):",
"def T(params, phi):\n\t# handle the base frame, eqn 3.9, p36\n\tt = np.array([\n\t\t[cos(phi), -sin(phi), 0.0, 0.0],\n\t\t[sin(phi), cos(phi), 0.0, 0.0],\n\t\... | [
"0.5387762",
"0.5230304",
"0.5211815",
"0.5198059",
"0.51977754",
"0.5130902",
"0.5115025",
"0.50400496",
"0.5024854",
"0.50156635",
"0.50012213",
"0.49933702",
"0.4982817",
"0.4942338",
"0.49365675",
"0.49344906",
"0.4928456",
"0.4909189",
"0.4909062",
"0.48921904",
"0.48724... | 0.5543668 | 0 |
Will retrieve the phase from a focal series in a deterministic fashion using the gaussianprocess transport of intensity (GPTIE) method. The anonymous parameters (erps and kwerps) are passed to the GPTIE module | def gaussian_process_TIE(fs, *erps, **kwerps):
gptie = GPTIE(fs, *erps, **kwerps)
phase = gptie()
return phase | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ETPA(omegap, E, edip, Te, g_idx=[0], e_idx=[], f_idx=[]):\n N = len(E)\n tdm = edip\n # gamma = np.zeros(nstates)\n # for j in range(1, N):\n # gamma[j] = sum(tdm[:j, j]**2) * 0.0005\n # gamma[1:] = 0.0001\n\n # print('lifetimes of polariton states = {} eV'.format(gamma * au2ev))\n\n ... | [
"0.5845086",
"0.5804024",
"0.5762294",
"0.57219493",
"0.5717423",
"0.5686649",
"0.56757325",
"0.5538305",
"0.5519094",
"0.55185133",
"0.5491932",
"0.5471413",
"0.54459774",
"0.5436331",
"0.542151",
"0.5375313",
"0.53742886",
"0.5355532",
"0.534618",
"0.52903897",
"0.5266585",... | 0.729517 | 0 |
Will refine a wave guess from a focal series in an iterative fashion using a version of the GerchbergSaxton (GS) loop. The named parameters are passed to the __init__ method of module GS. Anonymous parameters are optionally used to calculate a contrast transfer function, in the case this is not given, through fs.get_co... | def multi_focus_GS(fs, Niters=5, init_wave=None, ctf=None, alpha=None, using_gpu=False,
init_phase=None, *erps, **kwerps):
gsref = GS(fs, init_wave, ctf, alpha, using_gpu, *erps, **kwerps)
if init_phase is None:
wave = gsref(Niters)
return wave
if init_phase is not None:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_refine_step(self, sample, integral, integral_var, **kwargs):",
"def compute_scf(geoint, guess, nstep=20, threshold=1e-6):\n # Some essential integrals...\n coreham = geoint['ki'] - geoint['nai']\n olp = geoint['oi']\n \n # The initial guess\n dm_alpha = guess['dm_alpha']\n dm_bet... | [
"0.56499416",
"0.5638964",
"0.559936",
"0.55021787",
"0.54349416",
"0.53798175",
"0.5369566",
"0.53046954",
"0.52480394",
"0.52229273",
"0.5188865",
"0.51813334",
"0.51805145",
"0.5169596",
"0.513884",
"0.51108414",
"0.5085409",
"0.5055628",
"0.504844",
"0.5031253",
"0.503005... | 0.54431874 | 4 |
Perform a chi square test. Returns | def run_chi2(self, silent_run=False):
self.chi2 = (self.obs - self.exp)**2.
self.chi2.data /= self.exp.data**2.
if not silent_run:
return self.chi2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_chi_2(self):\n NN = 4\n w = 0.01\n kz = 1.0e-7\n kp = 3.0e-7\n wp = 2.0e3\n tz = 2.0e-18\n tp = 1.0e-18\n vthz = 1e5\n vthp = 1e5\n omega = 0.1\n vz = 100.\n\n chi = f_chi(NN, w, kz, kp, wp, tz, tp, vthz, vthp,\n ... | [
"0.69860387",
"0.6974439",
"0.692027",
"0.6900534",
"0.68230224",
"0.68178236",
"0.68107116",
"0.6658554",
"0.6568164",
"0.6543013",
"0.64838725",
"0.6453995",
"0.63928324",
"0.63667536",
"0.6342304",
"0.6342304",
"0.6321123",
"0.6321073",
"0.6294361",
"0.624833",
"0.6242034"... | 0.5677939 | 56 |
Perform a rvalue test. Only positive data (intensities). Returns | def run_rvalue(self, silent_run=False):
odata = np.sqrt(self.obs.data)
edata = np.sqrt(self.exp.data)
self.rvalue = np.sqrt((odata - edata)**2.).sum()
self.rvalue /= edata.sum()
if not silent_run:
return self.rvalue | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_of_with_args(self) -> None:\n assert Result.of(lambda x: bool(x > 0), 1).unwrap() is True",
"def test_pos():\n # Test for positive special method with scalar Rnode object\n x = Rnode(5)\n z = +x\n try:\n assert z.value == 1 * x.value\n except AssertionError as e:\n pr... | [
"0.56166077",
"0.52924556",
"0.49803373",
"0.49245155",
"0.49001187",
"0.48983425",
"0.48789844",
"0.48493248",
"0.48468444",
"0.48117045",
"0.4811189",
"0.48032174",
"0.480225",
"0.47236064",
"0.4706626",
"0.47004962",
"0.46803305",
"0.46701148",
"0.4667749",
"0.46482965",
"... | 0.4604436 | 23 |
Measure RMSE^2 in real and reciprocal space. Returns | def run_rmse_check(self):
# Shift the intensities to compare
obs = self.obs.data - self.obs.data.mean()
exp = self.exp.data - self.exp.data.mean()
# Experimental RMSE2 in real space
rmse_real = (obs - exp)
rmse_real = rmse_real**2
# Experimental RMSE2 in recipr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_RMSE(e):\n \"\"\"Corresponds to sqrt(2*MSE)\"\"\"\n \n return np.sqrt(2*compute_MSE(e))",
"def rrse(self) -> float:\n return float(np.sqrt(self.rse()))",
"def measure_rmse(self):\n try:\n assert self.residuals_forecast is not None\n except AssertionError:\n ... | [
"0.7872834",
"0.75949156",
"0.75894135",
"0.75683",
"0.7567819",
"0.75499594",
"0.75355643",
"0.7495896",
"0.7354617",
"0.72762173",
"0.72546834",
"0.72449005",
"0.72449005",
"0.72137094",
"0.7211572",
"0.72056526",
"0.71871936",
"0.71746224",
"0.7170366",
"0.7159166",
"0.715... | 0.7639022 | 1 |
Perform Fourier ring correlation (FRC) test. At the time, only the FRC for 2D images has been implemented. Because this algorithm uses FFT to compare images, it is important to enforce periodic boundary conditions, e.g. by the use of padding. | def run_fourier_ring_correlation(self, bin_size=None):
# This is done in the fourier plane
exp_ft = self.exp.fft(True)
obs_ft = self.obs.fft(True)
# Get correlations
axdict = obs_ft.axes_manager.as_dictionary()
axdict = [axdict[keys] for keys in axdict.keys()]
ex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def corrf(u, v, nf):\n V = np.conj(np.fft.fft(v, n=nf))\n U = np.fft.fft(u, n=nf)\n X = U*V\n x = np.real(np.fft.ifft(X, n=nf))\n return x",
"def frc(im1, im2, annulus_width=1, edgetaper=5, edgeloc=8 / 20.0, loc=(0, 0), smooth=None, working_mask=None, x=None,\n y=None, rmax=None, taper=None... | [
"0.638313",
"0.630608",
"0.6283942",
"0.62651575",
"0.62496763",
"0.6248945",
"0.6202985",
"0.6131658",
"0.6022188",
"0.5948053",
"0.58898234",
"0.5878836",
"0.585236",
"0.584517",
"0.5792167",
"0.57854164",
"0.5775085",
"0.57525617",
"0.57479095",
"0.57201385",
"0.5718814",
... | 0.6200045 | 7 |
port with all pins inverted | def inverted( self ):
return self._modifier(
self,
lambda x: invert_bits( x, self.nr_of_pins )
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, pin_obj: Pin, invert: bool = False):",
"def invert_port(self, port, polarity):\n\n if port == 1:\n self.__bus.write_byte_data(self.__ioaddress, self.IPOLB, polarity)\n self.__port_b_polarity = polarity\n else:\n self.__bus.write_byte_data(self.__i... | [
"0.63888365",
"0.6374163",
"0.6296547",
"0.5969197",
"0.59159297",
"0.58010113",
"0.57998306",
"0.57990515",
"0.56984675",
"0.5620566",
"0.56079745",
"0.5602531",
"0.5586794",
"0.5572789",
"0.55686104",
"0.55678266",
"0.55626017",
"0.5534482",
"0.5527071",
"0.5523599",
"0.552... | 0.6363903 | 2 |
port with the pins mirrored (pin order reversed) | def mirrored( self ):
return self._modifier(
self,
lambda x: mirror_bits( x, self.nr_of_pins )
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def op_mirror():\n mir = np.array([[1, 0, 0, 0],\n [0, 1, 0, 0],\n [0, 0, -1, 0],\n [0, 0, 0, -1]])\n return mir",
"def as_pin_out( self ):\n return _pin_out_from_port_out( self.as_port_out() )",
"def rotate(self):\n\n self.pins = sel... | [
"0.63303953",
"0.62193274",
"0.6186834",
"0.6178602",
"0.6171273",
"0.6046138",
"0.6041167",
"0.59468573",
"0.59202063",
"0.591281",
"0.5760961",
"0.57570535",
"0.57289064",
"0.57234144",
"0.5697887",
"0.5635463",
"0.5608617",
"0.55651623",
"0.55323",
"0.55020136",
"0.5475424... | 0.6741525 | 0 |
read and combine the pins that make up the port | def read( self ) -> int:
if self._slave is not None:
return self._filter( self._slave.read() )
else:
result = 0
for pin in self._pins[ :: -1 ]:
result = result << 1
if pin.read():
result |= 0b1
return r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_pins(self):\n\n for bit in range(self.addr_size):\n self.add_pin(\"addr_{0}\".format(bit),\"INPUT\")\n \n self.add_pin(\"wl_en\", \"INPUT\")\n\n for bit in range(self.num_rows):\n self.add_pin(\"wl_{0}\".format(bit),\"OUTPUT\")\n \n self.add_p... | [
"0.6417422",
"0.5873375",
"0.58421856",
"0.57833403",
"0.5708977",
"0.557878",
"0.55762327",
"0.5553285",
"0.55478317",
"0.5508428",
"0.5486689",
"0.54373777",
"0.543672",
"0.5429543",
"0.5376903",
"0.5359111",
"0.5347628",
"0.5344464",
"0.5342017",
"0.53398526",
"0.53340036"... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.