def set_transmission_coefficient(rayon): # change le coefficient de transmission des points de transmissions du rayon points_transmissions = rayon.get_points_transmission() for pt_trans in points_transmissions: mur = pt_trans.mur alpha = mur.alpha beta = mur.beta gamma = complex(alpha, beta) if (pt_trans.direction != None): direction = abs(pt_trans.direction) else: direction = None theta_i = get_theta_i(direction, pt_trans) theta_t = get_theta_t(theta_i, mur.epsilon) s = get_s(theta_t, mur.epaisseur) Z1 = sqrt(UO / EPS_0) Z2 = sqrt(UO / mur.epsilon) r = get_reflexion_perpendiculaire(Z1, Z2, theta_i, theta_t) num = (1 - pow(r, 2)) * cexp(-gamma * s) den = 1 - (pow(r, 2) * cexp((-2 * gamma * s) + (gamma * 2 * s * sin(theta_t) * sin(theta_i)))) coeff_abs = polar(num / den)[0] #module pt_trans.set_coefficient_value(coeff_abs)
def set_reflexion_coefficient(rayon): #effectue le calcul des coefficients de reflexion points_reflexion = rayon.get_points_reflexions() for pt_reflexion in points_reflexion: mur = pt_reflexion.mur alpha = mur.alpha beta = mur.beta gamma = complex(alpha,beta) if(pt_reflexion.direction != None): direction = abs(pt_reflexion.direction) else: direction = None theta_i = get_theta_i(direction,pt_reflexion) theta_t = get_theta_t(theta_i,mur.epsilon) s = get_s(theta_t,mur.epaisseur) Z1 = sqrt(UO/EPS_0) Z2 = sqrt(UO/mur.epsilon) r = get_reflexion_perpendiculaire(Z1,Z2,theta_i,theta_t) num = (1-pow(r,2))* r *cexp(-2*gamma*s)*cexp(2*gamma*s*sin(theta_t)*sin(theta_i)) den = 1-(pow(r,2)*cexp((-2*gamma*s)+(gamma*2*s*sin(theta_t)*sin(theta_i)))) coeff_abs = polar(r + num/den)[0] #module pt_reflexion.set_coefficient_value(coeff_abs)
def integrant(t, delG, lamT, delr, expn, etal): npol = len(expn) gt = (1.J*(delG+lamT)+delr)*t \ + sum(etal[k]/expn[k] for k in xrange(npol))*t \ - sum(etal[k]/expn[k]**2*(1-cexp(-expn[k]*t)) for k in xrange(npol)) result = cexp(-gt).real return result
def _get_coordonnees(self): k = self.__rapport a = self.__angle.radian zA = self.__point1.z zB = self.__point2.z zE = k*cexp(1j*a)*(zB - zA) + zA print "HHeLiBeBCNOFNe", k*cexp(1j*a), (zB - zA), zA, zE return zE.real, zE.imag
def _get_coordonnees(self): k = self.__rapport a = self.__angle.radian zA = self.__point1.z zB = self.__point2.z zE = k * cexp(1j * a) * (zB - zA) + zA print "HHeLiBeBCNOFNe", k * cexp(1j * a), (zB - zA), zA, zE return zE.real, zE.imag
def pyget_su2(): phi = asin(sqrt(random())) psi = random() * 2 * pi chi = random() * 2 * pi return np.matrix( [[cexp(1j * psi) * cos(phi), cexp(1j * chi) * sin(phi)], [-1 * cexp(-1j * chi) * sin(phi), cexp(-1j * psi) * cos(phi)]], dtype=np.complex_)
def transmission(self, energy): k = np.sqrt(2 * self.m * (energy - self.v)) / self.hbar * self.dx matrix = np.identity(2, dtype=np.complex) for n in range(0, len(self.v) - 1): if k[n] == 0: continue t = np.zeros((2, 2), dtype=np.complex) t[0, 0] = (k[n] + k[n + 1]) / 2 / k[n] * cexp(-1j * k[n]) t[0, 1] = (k[n] - k[n + 1]) / 2 / k[n] * cexp(-1j * k[n]) t[1, 0] = (k[n] - k[n + 1]) / 2 / k[n] * cexp(1j * k[n]) t[1, 1] = (k[n] + k[n + 1]) / 2 / k[n] * cexp(1j * k[n]) matrix = np.dot(matrix, t) return matrix[0][0].__abs__()**-2
def blit(frequency, sharpness=1.0, shift=0.0, phase=0.0, srate=None): srate = get_srate(srate) nyquist = 0.5 * srate l = len(frequency) sharpness = to_sequence(sharpness, l) frequency_shift = to_sequence(shift, l) fs = (s * f for s, f in zip(frequency_shift, frequency)) phase_shift = to_iterable(phase) phase = integrate_gen(frequency, srate=srate) frequency_shift_phase = integrate_gen(fs, srate=srate) zs = (s * cexp(two_pi_j * p) for p, s in zip(phase, sharpness)) ms = (cexp(two_pi_j * (p + theta)) for p, theta in zip(frequency_shift_phase, phase_shift)) return [(m * z * constant_series_n_mu(z, nyquist / f - 1 - fs)).real / s for z, m, f, s, fs in zip(zs, ms, frequency, sharpness, frequency_shift)]
def Z(beta): n = 30 q = 2 J1 = -2 J2 = -1 v1 = cexp(J1*beta)-1 v2 = cexp(J2*beta)-1 f = v2+q Z1 = q*v1 + q**2 Z2 = q**2*v1**2 + q**2*v2**2 + q*v1**2*v2**2 + 2*q*v1*v2**2 + 2*q*v2*v1**2 + 4*v1*v2*q**2 + 2*v1*q**3 + 2*v2*q**3 + q**4 zx = (-3*v1**2*v2**2*f**2*Z1-3*v1**3*v2**3*f*Z1-v1**3*v2**3*Z1-3*v1**3*v2**4*Z1+v1**2*v2**2*Z2-3*v1**4*v2**4*Z1+f**4*Z2-f**6*Z1-3*v1**3*v2**4*f**2*Z1-3*v1**2*v2**3*f**2*Z1-4*v1**3*v2**3*f**3*Z1+2*v1**2*v2**3*Z2+2*v1**3*v2**3*Z2-3*v1**3*v2**5*Z1-6*v1**4*v2**5*Z1-3*v1**5*v2**5*Z1+v1**2*v2**4*Z2+2*v1**3*v2**4*Z2-v1**3*v2**6*Z1-3*v1**4*v2**6*Z1-3*v1**5*v2**6*Z1+v1**4*v2**4*Z2-v1**6*v2**6*Z1-3*v1**4*v2**4*f**2*Z1+v1**2*v2**2*f**2*Z2-6*v1**3*v2**3*f**2*Z1-3*v1**2*v2**2*f**4*Z1+2*v1*v2*Z2*f**2+2*v1**2*v2**2*Z2*f-6*v1**3*v2**4*Z1*f-6*v1**4*v2**4*Z1*f+2*v1**2*v2**3*Z2*f-3*v1**3*v2**5*Z1*f-6*v1**4*v2**5*Z1*f+2*v1**3*v2**3*Z2*f-3*v1**5*v2**5*Z1*f-3*f**4*v1*v2*Z1-6*f**3*v1**2*v2**2*Z1-3*f**5*v1*v2*Z1-3*f**3*v1**2*v2**3*Z1+2*v1*v2*f**3*Z2-2*v1**2*v2**3*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**3*v2**3*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-v1**4*v2**4*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**2*v2**2*f**2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+v1*v2**2*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-v1*v2**2*f**2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*f**2*v1*v2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-v1**2*v2**2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+v1*v2*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-v1**2*v2**4*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**3*v2**4*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-f**4*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**2*v2**3*f*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**3*v2**3*f*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*f**3*v1*v2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+v1**2*v2**2*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**2*v2**2*f*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+v1*v2*f*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+f**2*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4))*(-(2*v1*v2**2*f**2+2*v1**2*v2**2*f**2)/(-v1*v2*f-v1*v2**2-f**2-v1*v2-v1**2*v2**2-sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)))**n/(sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)*v1*v2**2*f**2*(1+v1)*(-v1*v2*f-v1*v2**2-f**2-v1*v2-v1**2*v2**2-sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)))+(3*v1**2*v2**2*f**2*Z1+3*v1**3*v2**3*f*Z1+v1**3*v2**3*Z1+3*v1**3*v2**4*Z1-v1**2*v2**2*Z2+3*v1**4*v2**4*Z1-f**4*Z2+f**6*Z1+3*v1**3*v2**4*f**2*Z1+3*v1**2*v2**3*f**2*Z1+4*v1**3*v2**3*f**3*Z1-2*v1**2*v2**3*Z2-2*v1**3*v2**3*Z2+3*v1**3*v2**5*Z1+6*v1**4*v2**5*Z1+3*v1**5*v2**5*Z1-v1**2*v2**4*Z2-2*v1**3*v2**4*Z2+v1**3*v2**6*Z1+3*v1**4*v2**6*Z1+3*v1**5*v2**6*Z1-v1**4*v2**4*Z2+v1**6*v2**6*Z1+3*v1**4*v2**4*f**2*Z1-v1**2*v2**2*f**2*Z2+6*v1**3*v2**3*f**2*Z1+3*v1**2*v2**2*f**4*Z1-2*v1*v2*Z2*f**2-2*v1**2*v2**2*Z2*f+6*v1**3*v2**4*Z1*f+6*v1**4*v2**4*Z1*f-2*v1**2*v2**3*Z2*f+3*v1**3*v2**5*Z1*f+6*v1**4*v2**5*Z1*f-2*v1**3*v2**3*Z2*f+3*v1**5*v2**5*Z1*f+3*f**4*v1*v2*Z1+6*f**3*v1**2*v2**2*Z1+3*f**5*v1*v2*Z1+3*f**3*v1**2*v2**3*Z1-2*v1*v2*f**3*Z2-2*v1**2*v2**3*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**3*v2**3*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-v1**4*v2**4*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**2*v2**2*f**2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+v1*v2**2*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-v1*v2**2*f**2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*f**2*v1*v2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-v1**2*v2**2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+v1*v2*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-v1**2*v2**4*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**3*v2**4*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-f**4*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**2*v2**3*f*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**3*v2**3*f*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*f**3*v1*v2*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+v1**2*v2**2*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)-2*v1**2*v2**2*f*Z1*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+v1*v2*f*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)+f**2*Z2*sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4))*(-(2*v1*v2**2*f**2+2*v1**2*v2**2*f**2)/(-f**2-v1*v2-v1*v2*f-v1*v2**2-v1**2*v2**2+sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)))**n/(sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4)*v1*v2**2*f**2*(1+v1)*(-f**2-v1*v2-v1*v2*f-v1*v2**2-v1**2*v2**2+sqrt(2*f**2*v1*v2+2*f**3*v1*v2+2*v1**2*v2**2*f+2*v1**2*v2**3*f+2*v1**3*v2**3*f-2*v1*v2**2*f**2-v1**2*v2**2*f**2+v1**2*v2**2+f**4+2*v1**2*v2**3+2*v1**3*v2**3+v1**2*v2**4+v1**4*v2**4+2*v1**3*v2**4))) return zx
def Z(beta): n = 200 q = 2 J1 = -1 v1 = cexp(J1*beta)-1 zx = q*(v1+q)**(n-1) return zx
def build_state_vector(populated, ns): """ Return a 1D np.array of complex of length 2 * ns, which represents a ket of a normalised state, with the `populated` motional levels populated in equal amounts. For example, build_state_vector([0, (2, 'e', 0.5), 3], 5) will produce array([0, 0, i/sqrt(3), 0, 0, 1/sqrt(3), 0, 0, 1/sqrt(3), 0]). |-------excited-------|------------ground------------| Arguments: populated: 1D list of state_specifier -- The states to be populated in equal amounts in the output state. ns: unsigned int -- The number of motional levels which are being considered. The output vector will have length `2 * ns`. """ assert len(populated) > 0,\ "There must be at least one populated motional state." out = np.zeros(2 * ns, dtype=np.complex128) n = 1.0 / sqrt(len(populated)) for ss in populated: out[state.idx(ss, ns)] = cexp(1.0j * pi * state.phase(ss)) * n return out
def _get_coordonnees(self): k = self.__rapport a = self.__angle.radian zA = self.__point1.z zB = self.__point2.z zE = k*cexp(1j*a)*(zB - zA) + zA return zE.real, zE.imag
def random_image(kernel, xmi, xma, ymi, yma, log_scale_min, log_scale_max, log_lambda_min, log_lambda_max, log_julia_min, log_julia_max): scale = 10**rnd.uniform(log_scale_min, log_scale_max) xc = rnd.uniform(xmi, xma) yc = rnd.uniform(ymi, yma) xmin = xc - scale / 2 ymax = yc + scale / 2 nx = 1000 ny = 1000 xstride = scale / nx ystride = scale / ny topleft = nb.complex128(xmin + 1j * ymax) rot = rnd.uniform(0, 360) max_iter = 1000 lambd = 10**rnd.uniform(log_lambda_min, log_lambda_max) julia = lambd * 10 * rnd.uniform(log_julia_min, log_julia_max) * cexp( 1j * rnd.uniform(0, 360)) image_array = np.zeros((ny, nx), dtype=np.uint16) run_kernel(kernel, image_array, topleft, xstride, ystride, max_iter, lambd, julia, rot) print(xc, yc, scale, lambd, abs(julia)) return image_array
def Z(beta): n = 200 q = 2 J1 = -1 v1 = cexp(J1 * beta) - 1 zx = q * (v1 + q)**(n - 1) return zx
def build_state_vector(populated, ns): """ Return a 1D np.array of complex of length 2 * ns, which represents a ket of a normalised state, with the `populated` motional levels populated in equal amounts. For example, build_state_vector([0, (2, 'e', 0.5), 3], 5) will produce array([0, 0, i/sqrt(3), 0, 0, 1/sqrt(3), 0, 0, 1/sqrt(3), 0]). |-------excited-------|------------ground------------| Arguments: populated: 1D list of state_specifier -- The states to be populated in equal amounts in the output state. ns: unsigned int -- The number of motional levels which are being considered. The output vector will have length `2 * ns`. """ assert len(populated) > 0,\ "There must be at least one populated motional state." out = np.zeros(2 * ns, dtype = np.complex128) n = 1.0 / sqrt(len(populated)) for ss in populated: out[state.idx(ss, ns)] = cexp(1.0j * pi * state.phase(ss)) * n return out
def fBose (x,pole,resi,rn,tn,sign=0): if sign == 0: return 1/x+0.5+rn*x+tn*x**3+sum(2.0*resi[i]*x/(x**2+pole[i]**2) for i in xrange(len(pole))) else: if isinstance(x,complex): return 1.0/(1-cexp(-x)) else: return 1.0/(1-exp(-x))
def sphHar(l, m, cosTheta, phi): m1 = abs(m) c = sqrt( (2 * l + 1) * gamma(l - m1 + 1.) / (4 * pi * gamma(l + m1 + 1.))) c *= legendre(l, m1, cosTheta) y = cexp(m * phi * 1j) if fmod(m, 2) == -1.: y *= -1 return y * c + 0j
def __update_distance_phase_derivatives(self): pref = 2.0 / math.sqrt(len(self.target)) u_start = np.dot(self.__u, self.start) for i, pre_phase in enumerate(self.__phases): phase = cexp(1.0j * math.pi * (0.5 - pre_phase)) # we can calculate the inner product <g n_j|U|start> by # precalculating U|start>, then indexing to the relevant element. idx = state.idx(self.target[i + 1], self.ns) self.__d_dist_phases[i] =\ pref * (phase * u_start[idx] * np.conj(self.__tus)).real
def _get_coordonnees(self): a = self.__angle.radian zA = self.__sommet_principal.z zB = self.__point2.z if contexte['exact'] and issympy(a, zA, zB): zC = (zB - zA)*sexp(1j*a) + zA return zC.expand(complex=True).as_real_imag() else: zC = (zB - zA)*cexp(1j*a) + zA return zC.real, zC.imag
def _get_coordonnees(self): a = self.__angle.radian zA = self.__sommet_principal.z zB = self.__point2.z if contexte['exact'] and issympy(a, zA, zB): zC = (zB - zA) * sexp(1j * a) + zA return zC.expand(complex=True).as_real_imag() else: zC = (zB - zA) * cexp(1j * a) + zA return zC.real, zC.imag
def _get_coordonnees(self): a = self.__angle.radian zA = self.__point1.z zB = self.__point2.z zI = (zA + zB)/2 if contexte['exact'] and issympy(a, zI): zC = (zB - zI)*sexp(I*2*a) + zI return zC.expand(complex=True).as_real_imag() else: zC = (zB - zI)*cexp(1j*2*a) + zI return zC.real, zC.imag
def _get_coordonnees(self): a = self.__angle.radian zA = self.__point1.z zB = self.__point2.z zI = (zA + zB) / 2 if contexte['exact'] and issympy(a, zI): zC = (zB - zI) * sexp(I * 2 * a) + zI return zC.expand(complex=True).as_real_imag() else: zC = (zB - zI) * cexp(1j * 2 * a) + zI return zC.real, zC.imag
def GammaComplex(z): z = complex(z) if z.real < 0.5: return pi / (csin(pi*z)*GammaComplex(1-z)) else: z -= 1 x = lanczos_coef[0] + \ sum(lanczos_coef[i]/(z+i) for i in range(1, g+2)) t = z + g + 0.5 return csqrt(2*pi) * t**(z+0.5) * cexp(-t) * x
def set_value(self, value): """Set Dial needle to point at the given value.""" if value is None: value = self.min # only perform an update if the value has changed # ----------------------------------------------- if self.value != value: self.value = value angle = (value - self.min) * (self.end - self.start) / (self.max - self.min) + self.start # if dial is bound, check if value is out of bounds # ------------------------------------------------- self.outofbounds = False if self.bound: if self.min < self.max: # scale is increasing (1,2,3,...) if value < self.min: angle = self.start self.outofbounds = True elif value > self.max: angle = self.end self.outofbounds = True else: # scale is decreasing (3,2,1,...) if value > self.min: angle = self.start self.outofbounds = True elif value < self.max: angle = self.end self.outofbounds = True # rotate needle (via complex numbers) # for more info on algorithm see: # http://www.effbot.org/zone/tkinter-complex-canvas.htm # ----------------------------------------------------- newxy = [] offset = complex(self.xm, self.ym) for x, y in self.needlecoords: v = cexp(math.radians(-angle) * 1j) * (complex(x, y) - offset) + offset newxy.append(v.real) newxy.append(v.imag) self.coords(self.needle, *newxy) # update the readout display (if enabled) # --------------------------------------- if self.display: if self.displayroundto > 0: displayvalue = round(value, self.displayroundto) else: displayvalue = int(round(value)) displaycolor = self.displaycolor[self.outofbounds] self.itemconfig(self.display, text=displayvalue, fill=displaycolor)
def rfft(x): N = len(x) if N <= 1: return x if N & (N - 1) != 0: raise ValueError("Only power of two lengths supported.") even = fft(x[0::2]) odd = fft(x[1::2]) if N in _twiddle_factors: twiddle = _twiddle_factors[N] else: twiddle = [cexp(-2j * pi * k / N) for k in range(N // 2)] _twiddle_factors[N] = twiddle return [even[k] + twiddle[k] * odd[k] for k in range(N // 2)] + [even[0] - odd[0]]
def Lastovka_Shaw_Indefinite_Integral_Over_T(T, MW, similarity_variable, term): a = similarity_variable a2 = a * a B11 = 0.73917383 B12 = 8.88308889 C11 = 1188.28051 C12 = 1813.04613 B21 = 0.0483019 B22 = 4.35656721 C21 = 2897.01927 C22 = 5987.80407 S = (term * clog(T) + (-B11 - B12 * a) * clog(cexp((-C11 - C12 * a) / T) - 1.) + (-B11 * C11 - B11 * C12 * a - B12 * C11 * a - B12 * C12 * a2) / (T * cexp((-C11 - C12 * a) / T) - T) - (B11 * C11 + B11 * C12 * a + B12 * C11 * a + B12 * C12 * a2) / T) S += ((-B21 - B22 * a) * clog(cexp((-C21 - C22 * a) / T) - 1.) + (-B21 * C21 - B21 * C22 * a - B22 * C21 * a - B22 * C22 * a2) / (T * cexp((-C21 - C22 * a) / T) - T) - (B21 * C21 + B21 * C22 * a + B22 * C21 * a + B22 * C22 * a**2) / T) # There is a non-real component, but it is only a function of similariy # variable and so will always cancel out. return MW * S.real
def theta_formant(phase, ratio, width): """Formant waveform with energy concentrated on the fractional harmonic specified by ratio.""" if width < epsilon: width = epsilon if width < 7: x = two_pi * phase q = exp(-pi_squared / width) q2 = q * q q4 = q2 * q2 q8 = q4 * q4 q9 = q8 * q q16 = q8 * q8 q25 = q16 * q9 norm = 1 + 2 * (q + q4 + q9 + q25) floor_ratio = floor(ratio) ratio -= floor_ratio cn = cos(x * (floor_ratio - 5)) cn1 = cos(x * (floor_ratio - 4)) c = cos(x) s = cn1 * q ** (4 + ratio) ** 2 for n in range(-3, 5): cn1, cn = 2 * c * cn1 - cn, cn1 s += cn1 * q ** (n - ratio) ** 2 return s / norm elif width < 100: x = phase - floor(phase + 0.5) ratio *= two_pi z = from_polar(1, ratio * (x + 2)) m = cexp(2 * width * x - 1j * ratio) b = exp(-width) b4 = b ** 4 z0 = z.real z *= m z1 = z.real z *= m s = z.real z *= m s += (z.real + z1) * b z *= m s += (z.real + z0) * b4 return exp(-width * x * (x + 4)) * s / (1 + 2 * (b + b4)) else: x = phase - floor(phase + 0.5) return exp(-width * x * x) * cos(two_pi * x * ratio)
import multiprocessing import numpy as np from bitarray import bitarray from cmath import exp as cexp #Differentiate from real-valued exp from copy import deepcopy from math import acos, cos, exp, sin, sqrt from math import pow as fpow #Differentiate from stdlib pow from random import randrange, random from qutip import basis, sigmaz, tensor from Utils import do_anneal, format_for_output, write_string BETA = acos(1/sqrt(3)) /2 PI = acos(0.)*2 H = (cos(PI/8)*basis(2,0) + sin(PI/8)*basis(2,1)).unit() F = (cos(BETA)*basis(2,0) + cexp(1j*PI/4)*sin(BETA)*basis(2,1)).unit() PLUS = (basis(2,0)+basis(2,1)).unit() S = sigmaz().sqrtm() Tmat = S.sqrtm() T = Tmat * PLUS RT = Tmat.sqrtm() * PLUS RRT = Tmat.sqrtm().sqrtm() * PLUS STATES = {'T':T, 'RT':RT, 'RRT':RRT, 'F':F, 'H':H} def run_analysis(state, n, chi): job = {'ostring': write_string,
def oddtwiddles(self): # return a generator for odd-indexed twiddles freq = self.freq return (cexp(freq * n) for n in xrange(1, len(self.twiddles) * 2, 2))
def calc(point_a, point_b, tangent_a, tangent_b, p, planar_tolerance=1e-6): xx = point_b - point_a xx /= np.linalg.norm(xx) tangent_normal = np.cross(tangent_a, tangent_b) volume = np.dot(xx, tangent_normal) if abs(volume) > planar_tolerance: raise Exception( f"Provided tangents are not coplanar, volume={volume}") zz_a = np.cross(tangent_a, xx) zz_b = np.cross(tangent_b, xx) zz = (zz_a + zz_b) zz /= np.linalg.norm(zz) yy = np.cross(zz, xx) c = np.linalg.norm(point_b - point_a) * 0.5 tangent_a /= np.linalg.norm(tangent_a) tangent_b /= np.linalg.norm(tangent_b) to_center_a = np.cross(zz, tangent_a) to_center_b = -np.cross(zz, tangent_b) matrix_inv = np.stack((xx, yy, zz)) matrix = np.linalg.inv(matrix_inv) # TODO: sin(arccos(...)) = ... alpha = acos(np.dot(tangent_a, xx)) beta = acos(np.dot(tangent_b, xx)) if np.dot(tangent_a, yy) > 0: alpha = -alpha if np.dot(tangent_b, yy) > 0: beta = -beta #print("A", alpha, "B", beta) omega = (alpha + beta) * 0.5 r1 = c / (sin(alpha) + sin(omega) / p) r2 = c / (sin(beta) + p * sin(omega)) #print("R1", r1, "R2", r2) theta1 = 2 * arg(cexp(-1j * alpha) + cexp(-1j * omega) / p) theta2 = 2 * arg(cexp(1j * beta) + p * cexp(1j * omega)) #print("T1", theta1, "T2", theta2) vectorx_a = r1 * to_center_a center1 = point_a + vectorx_a center2 = point_b + r2 * to_center_b arc1 = SvCircle( #radius = r1, center=center1, normal=-zz, vectorx=point_a - center1) if theta1 > 0: arc1.u_bounds = (0.0, theta1) else: theta1 = -theta1 arc1.u_bounds = (0.0, theta1) arc1.set_normal(-arc1.normal) junction = arc1.evaluate(theta1) #print("J", junction) arc2 = SvCircle( #radius = r2, center=center2, normal=-zz, vectorx=junction - center2) if theta2 > 0: arc2.u_bounds = (0.0, theta2) else: theta2 = -theta2 arc2.u_bounds = (0.0, theta2) arc2.set_normal(-arc2.normal) curve = SvBiArc(arc1, arc2) curve.p = p curve.junction = junction return curve
def simple_electric_piano(note): time_ = time(note.duration + 1) zs = [cexp(2j * pi * f * t) for t, f in zip(time_, note.get_frequency_gen())] zs = [(0.1 * z * cexp(0.9 * exp(-t * 2) * z) + 0.025 * z ** 5 * constant_series(0.8 * exp(-t * 10) * z ** 2)) * (1 + tanh((note.duration - t) * 20)) * tanh(t * 200) for t, z in zip(time_, zs)] return [z.real for z in zs]
def reference_splitradix_fft(x): """ A very simple refernce implementation of the decimate in time FFT algorithm for the DFT. The length of the (possibly complex) array must be a power of two. >>> def scale_it(array): return tuple(int(round(abs(item) * 1000)) for item in array) >>> reference_splitradix_fft([]) () >>> reference_splitradix_fft([1]) (1,) >>> scale_it(reference_splitradix_fft([1] * 2)) (2000, 0) >>> scale_it(reference_splitradix_fft([1] * 2 + [0] * 2)) (2000, 1414, 0, 1414) >>> scale_it(reference_splitradix_fft([1] * 2 + [complex(0,1)] * 2 + [0] * (32 - 4))) (2828, 3310, 3625, 3754, 3696, 3460, 3073, 2571, 2000, 1410, 850, 368, 0, 227, 299, 218, 0, 326, 721, 1139, 1531, 1849, 2053, 2110, 2000, 1718, 1273, 688, 0, 747, 1501, 2212) >>> scale_it(reference_splitradix_fft([1] * 1 + [0] * (16 - 1))) (1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000) >>> scale_it(reference_splitradix_fft([1] * 8 + [0] * (32 - 8))) (8000, 7214, 5126, 2436, 0, 1500, 1800, 1115, 0, 915, 1203, 802, 0, 739, 1020, 711, 0, 711, 1020, 739, 0, 802, 1203, 915, 0, 1115, 1800, 1500, 0, 2436, 5126, 7214) >>> scale_it(reference_splitradix_fft(sin(2 * PI * n * 3 / 32) for n in xrange(32))) (0, 0, 0, 16000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16000, 0, 0) >>> scale_it(reference_splitradix_fft([1] * 2 + [complex(0,1)] * 2 + [0] * (16 - 4))) (2828, 3625, 3696, 3073, 2000, 850, 0, 299, 0, 721, 1531, 2053, 2000, 1273, 0, 1501) >>> tuple(complex(int(round(x.real)), int(round(x.imag))) for x in fft([-1000] * 2 + [-1000j] * 2 + [0] * (16 - 4))) ((-2000-2000j), (-3555-707j), (-3414+1414j), (-1707+2555j), 2000j, (472+707j), 0j, (-293+58j), 0j, (141-707j), (-586-1414j), (-1707-1141j), (-2000+0j), (-1058+707j), 0j, (-293-1472j)) >>> for i in xrange(8): ... scale_it(reference_splitradix_fft(range(1 << i))) (0,) (1000, 1000) (6000, 2828, 2000, 2828) (28000, 10453, 5657, 4330, 4000, 4330, 5657, 10453) (120000, 41007, 20905, 14400, 11314, 9622, 8659, 8157, 8000, 8157, 8659, 9622, 11314, 14400, 20905, 41007) (496000, 163237, 82013, 55118, 41810, 33942, 28799, 25221, 22627, 20698, 19243, 18142, 17318, 16720, 16313, 16077, 16000, 16077, 16313, 16720, 17318, 18142, 19243, 20698, 22627, 25221, 28799, 33942, 41810, 55118, 82013, 163237) (2016000, 652161, 326474, 218087, 164027, 131698, 110237, 94987, 83620, 74844, 67883, 62244, 57598, 53718, 50442, 47650, 45255, 43188, 41397, 39840, 38486, 37308, 36284, 35399, 34637, 33987, 33440, 32989, 32627, 32350, 32155, 32039, 32000, 32039, 32155, 32350, 32627, 32989, 33440, 33987, 34637, 35399, 36284, 37308, 38486, 39840, 41397, 43188, 45255, 47650, 50442, 53718, 57598, 62244, 67883, 74844, 83620, 94987, 110237, 131698, 164027, 218087, 326474, 652161) (8128000, 2607856, 1304321, 869984, 652947, 522830, 436174, 374352, 328053, 292102, 263396, 239959, 220473, 204028, 189973, 177830, 167240, 157931, 149688, 142345, 135767, 129844, 124489, 119627, 115197, 111148, 107437, 104026, 100884, 97983, 95301, 92815, 90510, 88368, 86375, 84521, 82793, 81183, 79681, 78279, 76972, 75753, 74616, 73556, 72569, 71651, 70797, 70006, 69273, 68596, 67973, 67402, 66880, 66405, 65977, 65594, 65254, 64956, 64700, 64485, 64310, 64174, 64077, 64019, 64000, 64019, 64077, 64174, 64310, 64485, 64700, 64956, 65254, 65594, 65977, 66405, 66880, 67402, 67973, 68596, 69273, 70006, 70797, 71651, 72569, 73556, 74616, 75753, 76972, 78279, 79681, 81183, 82793, 84521, 86375, 88368, 90510, 92815, 95301, 97983, 100884, 104026, 107437, 111148, 115197, 119627, 124489, 129844, 135767, 142345, 149688, 157931, 167240, 177830, 189973, 204028, 220473, 239959, 263396, 292102, 328053, 374352, 436174, 522830, 652947, 869984, 1304321, 2607856) """ x = tuple(x) if len(x) < 2: return x negtwopireciplength = -2j * PI / len(x) twiddles = tuple(cexp(n * negtwopireciplength) for n in xrange(3 * len(x) // 4)) # twiddles = tuple(cexp(n * negtwopireciplength) for n in xrange(len(x))) twiddler = partial(islice, twiddles, 0, None) def fft_recursive(xx, twiddle_stride): if len(xx) == 1: return xx evens = fft_recursive(xx[::2], twiddle_stride * 2) if len(evens) >= 4: # we can do the split radix work odds1 = fft_recursive(xx[1::4], 4 * twiddle_stride) odds3 = fft_recursive(xx[3::4], 4 * twiddle_stride) if len(odds1) != len(odds3): raise ValueError("expected a power of two, got len(x) %d" % (len(x),)) twodds1 = tuple(twiddle * odd1 for twiddle, odd1 in izip(twiddler(twiddle_stride), odds1)) twodds3 = tuple(twiddle * odd3 for twiddle, odd3 in izip(twiddler(3 * twiddle_stride), odds3)) assert len(twodds1) == len(twodds3) twoddsums = tuple(twodd1 + twodd3 for twodd1, twodd3 in izip(twodds1, twodds3)) jtwodddiffs = tuple(1j * (twodd1 - twodd3) for twodd1, twodd3 in izip(twodds1, twodds3)) return tuple(chain((even + twoddsum for even, twoddsum in izip(evens, twoddsums)), (even - jtwodddiff for even, jtwodddiff in izip(islice(evens, len(evens)//2, None), jtwodddiffs)), (even - twoddsum for even, twoddsum in izip(evens, twoddsums)), (even + jtwodddiff for even, jtwodddiff in izip(islice(evens, len(evens)//2, None), jtwodddiffs)))) odds = fft_recursive(xx[1::2], twiddle_stride * 2) if len(evens) != len(odds): raise ValueError("expected a power of two, got len(x) %d" % (len(x),)) twodds = tuple(twiddle * odd for twiddle, odd in izip(twiddler(twiddle_stride), odds)) return tuple(chain((even + twodd for even, twodd in izip(evens, twodds)), (even - twodd for even, twodd in izip(evens, twodds)))) return fft_recursive(x, 1)
def u_wawe(z): return ((((e / m) * beta * gamma0**-3 * 0.5 * Eii * (-i * w + delta_w - i * kii * uii)) / ((-i * w + delta_w + kii * uii)**2 + Omega**2)) * 2 * cexp(i * kii * z)).real * 2
def extrapAndImaging(ns, nvel, nz, nextrap, nt, nw, nx, \ dz, w, kx, vel_model, pulse_forw_fs, pulse_back_fs, \ path_to_output): image = np.zeros(shape=(ns, nz, nx), dtype=np.float32) # proagating wavefields for all reference velocities, shots, and pulses ref_channel_forw = np.zeros(shape=(ns, nvel, nw, nx), dtype=np.complex64) ref_channel_back = np.zeros(shape=(ns, nvel, nw, nx), dtype=np.complex64) for l in range(nextrap): vmin = np.min(vel_model[l, :]) vmax = np.max(vel_model[l, :]) dvel = (vmax - vmin) / (nvel - 1) refVel = np.array([vmin + i * dvel for i in range(nvel)]) # savefigures for more in-depth analysis and/or debug depth = round((l + 1) * dz, 1) print(" - depth:", depth, "refvel:", refVel) if l == 0 or l % 10 == 0: sIdx = 2 # just a hard-coded choice (index) filenameForw = path_to_output + "/forw_s" + str( sIdx) + "_depth" + str(depth) + "_.png" filenameBack = path_to_output + "/back_s" + str( sIdx) + "_depth" + str(depth) + "_.png" filenameImage = path_to_output + "/image_s" + str( sIdx) + "_depth" + str(depth) + "_.png" plotWavefield(pulse_forw_fs[sIdx, :, :], filenameForw) plotWavefield(pulse_back_fs[sIdx, :, :], filenameBack) plotImage(image[sIdx, :, :], filenameImage) # Phase-shift in f-x domain for j in range(nw): for i in range(nx): u = vel_model[l, i] k = w[j] / u Q1 = cexp(-1j * k * dz) Q2 = cexp(+1j * k * dz) for s in range(ns): pulse_forw_fs[s, j, i] *= Q1 pulse_back_fs[s, j, i] *= Q2 # FFT -> f-kx domain for s in range(ns): pulse_forw_fs[s, :, :] = spfft.fft(pulse_forw_fs[s, :, :], axis=1) pulse_back_fs[s, :, :] = spfft.fft(pulse_back_fs[s, :, :], axis=1) # Propagate with all reference velocities in f-kx domain for j in range(nw): for i in range(nx): for n in range(nvel): k = w[j] / refVel[n] if np.abs(k) > np.abs(kx[i]): kz = +np.sqrt(k**2 - kx[i]**2) Q1 = cexp(-1j * (kz - k) * dz) Q2 = cexp(+1j * (kz - k) * dz) for s in range(ns): ref_channel_forw[s, n, j, i] = pulse_forw_fs[s, j, i] * Q1 ref_channel_back[s, n, j, i] = pulse_back_fs[s, j, i] * Q2 # IFFT -> f-x domain for s in range(ns): for n in range(nvel): ref_channel_forw[s, n, :, :] = spfft.ifft( ref_channel_forw[s, n, :, :], axis=1) ref_channel_back[s, n, :, :] = spfft.ifft( ref_channel_back[s, n, :, :], axis=1) # Find coefficients for interpolation and then normalize them coeff = find_coeff(vel_model[l, :], refVel) coeff = norm_coefficients(coeff) # Interpolation pulse_forw_fs[:, :, :] = 0 pulse_back_fs[:, :, :] = 0 for s in range(ns): for i in range(nx): for n in range(nvel): pulse_forw_fs[s, :, i] += coeff[i, n] * ref_channel_forw[s, n, :, i] pulse_back_fs[s, :, i] += coeff[i, n] * ref_channel_back[s, n, :, i] # Imaging condition (cross-correlation) for s in range(ns): image[s,l,:] = np.add.reduce( (pulse_forw_fs[s,:,:] * \ np.conj(pulse_back_fs[s,:,:]) ).real, axis=0) return image
"""Module to hold useful matrices""" from cmath import exp as cexp from math import pi, sqrt from .haar_random import get_so2, get_su2 from .py_haar_random import pyget_su2 import numpy as np __all__ = ['qeye', 'X', 'Y', 'Z', 'S', 'H', 'T'] def qeye(n): return np.eye(n, dtype=np.complex_) X = np.matrix([[0, 1], [1, 0]], dtype=np.complex_) Y = np.matrix([[0, -1j], [1j, 0]], dtype=np.complex_) Z = np.matrix([[1, 0], [0, -1]], dtype=np.complex_) H = (1 / sqrt(2.)) * np.matrix([[1, 1], [1, -1]], dtype=np.complex_) S = np.matrix([[1, 0], [0, 1j]], dtype=np.complex_) T = np.matrix([[1, 0], [0, cexp(1j * pi / 4)]], dtype=np.complex_)
return np.eye(n, dtype=np.complex_) Id = np.eye(2, dtype=np.complex_) X = np.matrix([[0, 1], [1, 0]], dtype=np.complex_) Y = np.matrix([[0, -1j], [1j, 0]], dtype=np.complex_) Z = np.matrix([[1, 0], [0, -1]], dtype=np.complex_) H = (1 / sqrt(2.)) * np.matrix([[1, 1], [1, -1]], dtype=np.complex_) S = np.matrix([[1, 0], [0, 1j]], dtype=np.complex_) T = np.matrix([[1, 0], [0, cexp(1j * pi / 4)]], dtype=np.complex_) ROOT_T = np.matrix([[1, 0], [0, cexp(1j * pi / 8)]], dtype=np.complex_) ROOT_ROOT_T = np.matrix([[1, 0], [0, cexp(1j * pi / 16)]], dtype=np.complex_) CS = np.matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1j]], dtype=np.complex_) CCZ = np.matrix([[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, -1]], dtype=np.complex_)
import numpy as np import qutip as qt from cmath import exp as cexp from itertools import product, combinations from math import acos, cos, sin, sqrt from Utils import SL0, n_stab ## Magic state definitions pi = 2*acos(0.) beta = acos(1/sqrt(3)) / 2 I, X, Y, Z = qt.qeye(2), qt.sigmax(), qt.sigmay(), qt.sigmaz() H = (cos(pi/8)*qt.basis(2,0)+sin(pi/8)*qt.basis(2,1)).unit() F = (cos(beta)*qt.basis(2,0) + cexp(1j*pi/4)*sin(beta)*qt.basis(2,1)).unit() plus = (qt.basis(2,0)+qt.basis(2,1)).unit() S = Z.sqrtm() T = S.sqrtm() magic_states = [H, S*H, Z*H, S.dag()*H, X*H, S*X*H, Z*X*H, S.dag()*X*H, T*plus, S*T*plus, S.dag()*T.dag()*plus,T.dag()*plus] face_states = [F]# S*F, Z*F, S.dag()*F, X*F, S*X*F, S*Z*F, S.dag()*X*F] ## ## Helpful funcitons def commutator(A,B): return A*B - B*A def test_equality(g1,g2): return all([any([np.allclose(_g1, _g2) for _g2 in g2]) for _g1 in g1]) def projector(group):
def init(inidic): try: exbe = inidic['exbe'] except: exbe = 0 npsd = inidic['npsd'] pade = inidic['pade'] temp = inidic['temp'] jomg = inidic['jomg'] nmod = len(jomg) nind = 0 mode = [] for m in xrange(nmod): try: ndru = len(jomg[m]['jdru']) except: ndru = 0 try: nsdr = len(jomg[m]['jsdr']) except: nsdr = 0 nper = ndru + 2 * nsdr + npsd nind += nper mode.extend([m for i in xrange(nper)]) mode = np.array(mode) delr = np.zeros(nmod, dtype=float) expn = np.zeros(nind, dtype=complex) etal = np.zeros(nind, dtype=complex) etar = np.zeros(nind, dtype=complex) etaa = np.zeros(nind, dtype=float) pole, resi, rn, tn = PSD(npsd, BoseFermi=1, pade=pade) iind = 0 for m in xrange(nmod): try: jdru = jomg[m]['jdru'] except: jdru = [] try: jsdr = jomg[m]['jsdr'] except: jsdr = [] ndru = len(jdru) nsdr = len(jsdr) for idru in xrange(ndru): if len(jdru[idru]) != 2: raise ValueError('Invalid drude input') lamd, gamd = jdru[idru][0], jdru[idru][1] expn[iind] = gamd etal[iind] = -2.J * lamd * gamd * fBose(-1.J * gamd / temp, pole, resi, rn, tn, exbe) etar[iind] = etal[iind].conj() etaa[iind] = abs(etal[iind]) delr[m] += 2. * lamd * gamd / temp * rn iind += 1 for isdr in xrange(nsdr): if len(jsdr[isdr]) != 3: raise ValueError('Invalid BO input') lams, omgs, gams = jsdr[isdr][0], jsdr[isdr][1], jsdr[isdr][2] jind = iind + 1 etaBO = 2. * lams * omgs * omgs * gams Delta = omgs * omgs - gams * gams / 4.0 delr[m] += etaBO * tn / (temp**3) if Delta > 0: OmgB = sqrt(Delta) expn[iind] = 0.5 * gams + 1.J * OmgB expn[jind] = 0.5 * gams - 1.J * OmgB elif Delta < 0: OmgB = sqrt(-Delta) expn[iind] = 0.5 * gams + OmgB expn[jind] = 0.5 * gams - OmgB else: raise ValueError("Not prepared for Delta=0") z1, z2 = -1.J * expn[iind], -1.J * expn[jind] etal[iind] = -2.J * etaBO * z1 / ( 2. * z1 * (z1 + z2) * (z1 - z2)) * fBose(z1 / temp, pole, resi, rn, tn, exbe) etal[jind] = -2.J * etaBO * z2 / ( 2. * z2 * (z2 + z1) * (z2 - z1)) * fBose(z2 / temp, pole, resi, rn, tn, exbe) if Delta > 0: etar[iind] = etal[jind].conj() etar[jind] = etal[iind].conj() etaa[iind] = etaa[jind] = sqrt( abs(etal[iind]) * abs(etal[jind])) elif Delta < 0: etar[iind] = etal[iind].conj() etar[jind] = etal[jind].conj() etaa[iind] = abs(etal[iind]) etaa[jind] = abs(etal[jind]) else: raise ValueError("Not prepared for Delta=0") iind += 2 for ipsd in xrange(npsd): zomg = -1.J * pole[ipsd] * temp jsmd = sum(jwdru(zomg, x) for x in jdru) jsms = sum(jwsdr(zomg, x) for x in jsdr) jsum = jsmd + jsms expn[iind] = pole[ipsd] * temp etal[iind] = -2.J * resi[ipsd] * temp * jsum etar[iind] = etal[iind].conj() etaa[iind] = abs(etal[iind]) iind += 1 delr_img = delr mode_img = np.zeros(2 * nind, dtype=int) expn_img = np.zeros(2 * nind, dtype=complex) etal_img = np.zeros(2 * nind, dtype=complex) etar_img = np.zeros(2 * nind, dtype=complex) etaa_img = np.zeros(2 * nind, dtype=float) for i in xrange(nind): mode_img[2 * i] = mode_img[2 * i + 1] = mode[i] expn_img[2 * i] = expn[i] expn_img[2 * i + 1] = -expn[i] etal_img[2 * i] = 0.5 * etal[i] etal_img[2 * i + 1] = 0.5 * etal[i] * cexp(1.J * expn[i] / temp) etar_img[2 * i] = 0.5 * etar[i] etar_img[2 * i + 1] = 0.5 * etar[i] * cexp(-1.J * expn[i] / temp) etaa_img[2 * i] = etaa_img[2 * i + 1] = etaa[i] * 0.5 arma.save(mode_img, inidic['modeFile']) arma.save(etal_img, inidic['etalFile']) arma.save(etar_img, inidic['etarFile']) arma.save(etaa_img, inidic['etaaFile']) arma.save(expn_img, inidic['expnFile']) arma.save(delr_img, inidic['delrFile']) return etal, expn
seq.add_block(rf_td, gx_td, gz_td) # Read out block slice = iz ileaf = ( ((iframe % fmri['nLeafs']) + iz) % fmri['nLeafs']) + 1 # rotate leaf every frame and every kz platter phi = 2 * pi * (ileaf - 1) / fmri['nLeafs'] # leaf rotation angle in radians # Rotate the spiral arm if necessary if phi != 0: g = np.zeros(gx_ro_wav_orig.shape, dtype=complex) for i in range(gx_ro_wav_orig.shape[0]): g[i] = complex(gx_ro_wav_orig[i], gy_ro_wav_orig[i]) g[i] = g[i] * cexp(phi * 1j) gx_ro_wav = np.real(g) gy_ro_wav = np.imag(g) else: gx_ro_wav = gx_ro_wav_orig gy_ro_wav = gy_ro_wav_orig gx_ro = make_arbitrary_grad(channel='x', system=system, waveform=np.squeeze(gx_ro_wav)) gy_ro = make_arbitrary_grad(channel='y', system=system, waveform=np.squeeze(gy_ro_wav))
import matplotlib.pylab as plt import numpy as np import pandas as pd from scipy.stats import norm import seaborn as sns from math import cos, sin, log, tan, gamma, pi, exp, sqrt, cosh, sinh from cmath import exp as cexp, log as clog N = 7500 f = lambda n: n / 11 + n**2 / 21 + n**3 / 31 S = np.cumsum([cexp(f(n) * complex(0, 2 * pi)) for n in range(1, N)]) p = plt.figure(figsize=(14, 14), facecolor='black', dpi=100) p = plt.axis('off') for k in range(440): plt.ylim(-25, 35) plt.xlim(-40, 20) plt.plot([S[i].real for i in range(N - 1)][k * 20:(k + 1) * 20 + 1], [S[i].imag for i in range(N - 1)][k * 20:(k + 1) * 20 + 1], lw=1, color='w', alpha=0.8) p = plt.savefig( f'C:/Users/Alejandro/Pictures/RandomPlots/29022020/plot{k}.PNG', facecolor='black')
def reference_splitradix_fft(x): """ A very simple refernce implementation of the decimate in time FFT algorithm for the DFT. The length of the (possibly complex) array must be a power of two. >>> def scale_it(array): return tuple(int(round(abs(item) * 1000)) for item in array) >>> reference_splitradix_fft([]) () >>> reference_splitradix_fft([1]) (1,) >>> scale_it(reference_splitradix_fft([1] * 2)) (2000, 0) >>> scale_it(reference_splitradix_fft([1] * 2 + [0] * 2)) (2000, 1414, 0, 1414) >>> scale_it(reference_splitradix_fft([1] * 2 + [complex(0,1)] * 2 + [0] * (32 - 4))) (2828, 3310, 3625, 3754, 3696, 3460, 3073, 2571, 2000, 1410, 850, 368, 0, 227, 299, 218, 0, 326, 721, 1139, 1531, 1849, 2053, 2110, 2000, 1718, 1273, 688, 0, 747, 1501, 2212) >>> scale_it(reference_splitradix_fft([1] * 1 + [0] * (16 - 1))) (1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000) >>> scale_it(reference_splitradix_fft([1] * 8 + [0] * (32 - 8))) (8000, 7214, 5126, 2436, 0, 1500, 1800, 1115, 0, 915, 1203, 802, 0, 739, 1020, 711, 0, 711, 1020, 739, 0, 802, 1203, 915, 0, 1115, 1800, 1500, 0, 2436, 5126, 7214) >>> scale_it(reference_splitradix_fft(sin(2 * PI * n * 3 / 32) for n in xrange(32))) (0, 0, 0, 16000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16000, 0, 0) >>> scale_it(reference_splitradix_fft([1] * 2 + [complex(0,1)] * 2 + [0] * (16 - 4))) (2828, 3625, 3696, 3073, 2000, 850, 0, 299, 0, 721, 1531, 2053, 2000, 1273, 0, 1501) >>> tuple(complex(int(round(x.real)), int(round(x.imag))) for x in fft([-1000] * 2 + [-1000j] * 2 + [0] * (16 - 4))) ((-2000-2000j), (-3555-707j), (-3414+1414j), (-1707+2555j), 2000j, (472+707j), 0j, (-293+58j), 0j, (141-707j), (-586-1414j), (-1707-1141j), (-2000+0j), (-1058+707j), 0j, (-293-1472j)) >>> for i in xrange(8): ... scale_it(reference_splitradix_fft(range(1 << i))) (0,) (1000, 1000) (6000, 2828, 2000, 2828) (28000, 10453, 5657, 4330, 4000, 4330, 5657, 10453) (120000, 41007, 20905, 14400, 11314, 9622, 8659, 8157, 8000, 8157, 8659, 9622, 11314, 14400, 20905, 41007) (496000, 163237, 82013, 55118, 41810, 33942, 28799, 25221, 22627, 20698, 19243, 18142, 17318, 16720, 16313, 16077, 16000, 16077, 16313, 16720, 17318, 18142, 19243, 20698, 22627, 25221, 28799, 33942, 41810, 55118, 82013, 163237) (2016000, 652161, 326474, 218087, 164027, 131698, 110237, 94987, 83620, 74844, 67883, 62244, 57598, 53718, 50442, 47650, 45255, 43188, 41397, 39840, 38486, 37308, 36284, 35399, 34637, 33987, 33440, 32989, 32627, 32350, 32155, 32039, 32000, 32039, 32155, 32350, 32627, 32989, 33440, 33987, 34637, 35399, 36284, 37308, 38486, 39840, 41397, 43188, 45255, 47650, 50442, 53718, 57598, 62244, 67883, 74844, 83620, 94987, 110237, 131698, 164027, 218087, 326474, 652161) (8128000, 2607856, 1304321, 869984, 652947, 522830, 436174, 374352, 328053, 292102, 263396, 239959, 220473, 204028, 189973, 177830, 167240, 157931, 149688, 142345, 135767, 129844, 124489, 119627, 115197, 111148, 107437, 104026, 100884, 97983, 95301, 92815, 90510, 88368, 86375, 84521, 82793, 81183, 79681, 78279, 76972, 75753, 74616, 73556, 72569, 71651, 70797, 70006, 69273, 68596, 67973, 67402, 66880, 66405, 65977, 65594, 65254, 64956, 64700, 64485, 64310, 64174, 64077, 64019, 64000, 64019, 64077, 64174, 64310, 64485, 64700, 64956, 65254, 65594, 65977, 66405, 66880, 67402, 67973, 68596, 69273, 70006, 70797, 71651, 72569, 73556, 74616, 75753, 76972, 78279, 79681, 81183, 82793, 84521, 86375, 88368, 90510, 92815, 95301, 97983, 100884, 104026, 107437, 111148, 115197, 119627, 124489, 129844, 135767, 142345, 149688, 157931, 167240, 177830, 189973, 204028, 220473, 239959, 263396, 292102, 328053, 374352, 436174, 522830, 652947, 869984, 1304321, 2607856) """ x = tuple(x) if len(x) < 2: return x negtwopireciplength = -2j * PI / len(x) twiddles = tuple( cexp(n * negtwopireciplength) for n in xrange(3 * len(x) // 4)) # twiddles = tuple(cexp(n * negtwopireciplength) for n in xrange(len(x))) twiddler = partial(islice, twiddles, 0, None) def fft_recursive(xx, twiddle_stride): if len(xx) == 1: return xx evens = fft_recursive(xx[::2], twiddle_stride * 2) if len(evens) >= 4: # we can do the split radix work odds1 = fft_recursive(xx[1::4], 4 * twiddle_stride) odds3 = fft_recursive(xx[3::4], 4 * twiddle_stride) if len(odds1) != len(odds3): raise ValueError("expected a power of two, got len(x) %d" % (len(x), )) twodds1 = tuple( twiddle * odd1 for twiddle, odd1 in izip(twiddler(twiddle_stride), odds1)) twodds3 = tuple( twiddle * odd3 for twiddle, odd3 in izip(twiddler(3 * twiddle_stride), odds3)) assert len(twodds1) == len(twodds3) twoddsums = tuple(twodd1 + twodd3 for twodd1, twodd3 in izip(twodds1, twodds3)) jtwodddiffs = tuple(1j * (twodd1 - twodd3) for twodd1, twodd3 in izip(twodds1, twodds3)) return tuple( chain((even + twoddsum for even, twoddsum in izip(evens, twoddsums)), (even - jtwodddiff for even, jtwodddiff in izip( islice(evens, len(evens) // 2, None), jtwodddiffs)), (even - twoddsum for even, twoddsum in izip(evens, twoddsums)), (even + jtwodddiff for even, jtwodddiff in izip( islice(evens, len(evens) // 2, None), jtwodddiffs)))) odds = fft_recursive(xx[1::2], twiddle_stride * 2) if len(evens) != len(odds): raise ValueError("expected a power of two, got len(x) %d" % (len(x), )) twodds = tuple( twiddle * odd for twiddle, odd in izip(twiddler(twiddle_stride), odds)) return tuple( chain((even + twodd for even, twodd in izip(evens, twodds)), (even - twodd for even, twodd in izip(evens, twodds)))) return fft_recursive(x, 1)
def setSystem(dt,p,q,m,aList,bList,A,B,F,Q): for i in xrange(len(aList)): A[i,0]=-1.0*aList[i] for i in xrange(len(bList)): B[m-1-i,0] = bList[q-i]; F=expm(A*dt) lam,vr = eig(A) vr = matrix(vr) vrTrans = transpose(vr) vrInv = inv(vr) C = vrInv*B*transpose(B)*transpose(vrInv) Q=zeros((m,m)) for i in xrange(m): for j in xrange(m): for k in xrange(m): for l in xrange(m): Q[i,j] += vr[i,k]*C[k,l]*vrTrans[l,j]*((cexp((lam[k] + lam[l])*dt) - 1.0)/(lam[k] + lam[l])) T=cholesky(Q) X=zeros((m,1)) Sigma=zeros((m,m)) P=zeros((m,m)) for i in xrange(m): for j in xrange(m): for k in xrange(m): for l in xrange(m): Sigma[i,j] += vr[i,k]*C[k,l]*vrTrans[l,j]*(-1.0/(lam[k] + lam[l])) P[i,j] = Sigma[i,j] XMinus=zeros((m,1)) PMinus=zeros((m,m)) '''print 'A' print A print print 'B' print B print print 'F' print F print print 'C' print C print print 'Q' print Q print print 'T' print T print print 'Sigma' print Sigma print print 'X' print X print print 'P' print P''' return (X,P,XMinus,PMinus,F,Q)