def quadratic_results(request):
    import math, cmath
    output_request = {}
    output_request['calculate'] = False
    if request.GET:
        temp_form = QuadraticForm(request.GET)
        if temp_form.is_valid():
            output_request['calculate'] = True
            a = temp_form.cleaned_data['a']
            b = temp_form.cleaned_data['b']
            c = temp_form.cleaned_data['c']
            output_request['D'] = b**2 - 4*a*c
            if output_request['D'] > 0:
                output_request['x1'] = float((-b + math.sqrt(output_request['D']))/(2*a))
                output_request['x2'] = float((-b - math.sqrt(output_request['D']))/(2*a))
            elif output_request['D'] == 0:
                output_request['x1'] = output_request['x2'] = float(-b / 2*a)
            elif output_request['D'] < 0:
                output_request['x1'] = complex((-b + cmath.sqrt(output_request['D']))/(2*a))
                output_request['x2'] = complex((-b - cmath.sqrt(output_request['D']))/(2*a))    
    else:
        temp_form = QuadraticForm()

    output_request['form'] = temp_form
    return render(request,'quadratic/results.html',output_request)
Beispiel #2
0
 def _n_Z(Omega, c10, Dt, loc_q, loc_ym, loc_yp, loc_alcc, loc_alss, loc_bsc, loc_bcs):
     arg1 = cmath.sqrt(2.0*loc_yp)/2.0/Dt/c10
     arg2 = cmath.sqrt(2.0*loc_ym)/2.0/Dt/c10
     return ((loc_alcc*cmath.cosh(arg1)*cmath.cosh(arg2) +
              loc_alss*cmath.sinh(arg1)*cmath.sinh(arg2) + loc_q)/
             (loc_bsc*cmath.sinh(arg1)*cmath.cosh(arg2) +
              loc_bcs*cmath.cosh(arg1)*cmath.sinh(arg2)))
Beispiel #3
0
def soddy(triplet):
	"""
	Calcule le rayon et le centre du cercle de Soddy, en prenant en paramètre un triplet de cercle.

	:param triplet: list of three circles
	:type triplet: list
	:return: circle of soddy
	:rtype: tuple

	"""
	k1=1/triplet[0][2]
	k2=1/triplet[1][2]
	k3=1/triplet[2][2]
	k4=(k1+k2+k3)+(2*sqrt((k1*k2)+(k1*k3)+(k2*k3)))
	z1=complex(triplet[0][0], triplet[0][1])
	z2=complex(triplet[1][0], triplet[1][1])
	z3=complex(triplet[2][0], triplet[2][1])
	z4=(z1*k1+z2*k2+z3*k3+2*cmath.sqrt(k1*k2*z1*z2+k2*k3*z2*z3+k1*k3*z1*z3))/k4
    # on calcule la corbure k4 du cercle de soddy
	a=int(Distance(z4,z1)),int((triplet[0][2]+1/k4)),triplet[0][2]  ,int(Distance(z4,z2)),int((triplet[1][2]+1/k4)),triplet[1][2],int(Distance(z4,z3)),int((triplet[2][2]+1/k4)), triplet[2][2]
	if  int(Distance(z4,z1))==int((triplet[0][2]+1/k4)) and int(Distance(z4,z2))==int((triplet[1][2]+1/k4)) and int(Distance(z4,z3))==int((triplet[2][2]+1/k4)):
		return (z4.real,z4.imag,1/k4,True)
	else:
		#print(a)
		k1=-1/triplet[0][2]
		k4=(k1+k2+k3)+(2*sqrt((k1*k2)+(k1*k3)+(k2*k3)))
		z4=(z1*k1+z2*k2+z3*k3+2*cmath.sqrt(k1*k2*z1*z2+k2*k3*z2*z3+k1*k3*z1*z3))/k4
		return (z4.real,z4.imag,1/k4,False)
Beispiel #4
0
def SeidelB(q2, mb, mu):
    """Function $A(s\equiv q^2)$ defined in eq. (30) of hep-ph/0403185v2.
    """
    sh = q2/mb**2
    z = (4 * mb**2)/q2
    x1 = 1/2 + 1j/2 * sqrt(z - 1)
    x2 = 1/2 - 1j/2 * sqrt(z - 1)
    x3 = 1/2 + 1j/(2 * sqrt(z - 1))
    x4 = 1/2 - 1j/(2 * sqrt(z - 1))
    return ((8)/(243 * sh) * ((4 - 34 * sh - 17 * pi * 1j * sh) *
    log((mb**2)/(mu**2)) + 8 * sh * log((mb**2)/(mu**2))**2 + 17 * sh * log(sh) *
    log((mb**2)/(mu**2))) + ((2 + sh) * sqrt( z - 1))/(729 * sh) * (-48 *
    log((mb**2)/(mu**2)) * acot( sqrt(z - 1)) - 18 * pi * log(z - 1) + 3 * 1j *
    log(z - 1)**2 - 24 * 1j * li2(-x2/x1) - 5 * pi**2 * 1j + 6 * 1j * (-9 *
    log(x1)**2 + log(x2)**2 - 2 * log(x4)**2 + 6 * log(x1) * log(x2) - 4 * log(x1) *
    log(x3) + 8 * log(x1) * log(x4)) - 12 * pi * (2 * log(x1) + log(x3) + log(x4))) -
    (2)/(243 * sh * (1 - sh)) * (4 * sh * (-8 + 17 * sh) * (li2(sh) + log(sh) *
    log(1 - sh)) + 3 * (2 + sh) * (3 - sh) * log(x2/x1)**2 + 12 * pi * (-6 - sh +
    sh**2) * acot( sqrt(z - 1))) + (2)/(2187 * sh * (1 - sh)**2) * (-18 * sh * (120 -
    211 * sh + 73 * sh**2) * log(sh) - 288 - 8 * sh + 934 * sh**2 - 692 * sh**3 + 18 *
    pi * 1j * sh * (82 - 173 * sh + 73 * sh**2)) - (4)/(243 * sh * (1 - sh)**3) *
    (-2 * sqrt( z - 1) * (4 - 3 * sh - 18 * sh**2 + 16 * sh**3 - 5 * sh**4) * acot(
    sqrt(z - 1)) - 9 * sh**3 * log(sh)**2 + 2 * pi * 1j * sh * (8 - 33 * sh + 51 *
    sh**2 - 17 * sh**3) * log( sh)) + (2)/(729 * sh * (1 - sh)**4) * (72 * (3 - 8 *
    sh + 2 * sh**2) * acot( sqrt(z - 1))**2 - pi**2 * (54 - 53 * sh - 286 * sh**2 +
    612 * sh**3 - 446 * sh**4 + 113 * sh**5)) )
def lanczos(b, Amul, k, tol=1E-8):
    """Perform basic Lanczos Iteration given a starting vector 'b',
    a function 'Amul' representing multiplication by some matrix A,
    a number 'k' of iterations to perform, and a tolerance 'tol' to
    determine if the algorithm should stop early."""
    # Some Initialization
    # We will use $q_0$ and $q_1$ to store the needed $q_i$
    q0 = 0
    q1 = b / sqrt(np.inner(b.conjugate(), b))
    alpha = np.empty(k, dtype=complex)
    beta = np.empty(k)
    beta[-1] = 0.
    # Perform the iteration.
    for i in xrange(k):
        # z is a temporary vector to store q_{i+1}
        z = Amul(q1)
        alpha[i] = np.inner(q1.conjugate(), z)
        z -= alpha[i] * q1
        z -= beta[i-1] * q0
        beta[i] = sqrt(np.inner(z.conjugate(), z)).real
        # Stop if ||q_{j+1}|| is too small.
        if beta[i] < tol:
            return alpha[:i+1].copy(), beta[:i].copy()
        z /= beta[i]
        # Store new q_{i+1} and q_i on top of q0 and q1
        q0, q1 = q1, z
    return alpha, beta[:-1]
def arnoldi(b, Amul, k, tol=1E-8):
    """Perform 'k' steps of the Arnoldi Iteration for
    sparse array 'A' and starting point 'b'with multiplicaiton
    function 'Amul'. Stop if the projection of a vector
    orthogonal to the current subspace has norm less than 'tol'."""
    # Some initialization steps.
    # Initialize to complex arrays to avoid some errors.
    Q = np.empty((b.size, k+1), order='F', dtype=np.complex128)
    H = np.zeros((k+1, k), order='F', dtype=np.complex128)
    ritz_vals = []
    # Set q_0 equal to b.
    Q[:,0] = b
    # Normalize q_0.
    Q[:,0] /= sqrt(np.inner(b.conjugate(), b))
    # Perform actual iteration.
    for j in xrange(k):
        # Compute A.dot(q_j).
        Q[:,j+1] = Amul(Q[:,j])
        # Modified Graham Schmidt
        for i in xrange(j+1):
            # Set values of $H$
            H[i,j] = np.inner(Q[:,i].conjugate(), Q[:,j+1])
            Q[:,j+1] -= H[i,j] * Q[:,i]
        # Set subdiagonel element of H.
        H[j+1,j] = sqrt(np.inner(Q[:,j+1].conjugate(), Q[:,j+1]))
        # Stop if ||q_{j+1}|| is too small.
        if abs(H[j+1, j]) < tol:
            # Here I'll copy the array to avoid excess memory usage.
            return np.array(H[:j,:j], order='F')
        # Normalize q_{j+1}
        Q[:,j+1] /= H[j+1, j]
    return H[:-1]
Beispiel #7
0
def find_opt_sn(source_g, sink_g, corr, mat, ts):
    mat_size, temp = mat[0].shape
    n_configs, n_types, t_size = corr.shape
    n_iter = 20
    source = source_g
    sink = sink_g
    for n in range(n_iter):
        sigma2_source = np.matrix(np.zeros((mat_size, mat_size), dtype=np.complex128))
        sigma2_sink = np.matrix(np.zeros((mat_size, mat_size), dtype=np.complex128))
        for x in range(n_configs):
            c = np.matrix(np.zeros((mat_size, mat_size), dtype=np.complex128))
            for y in range(n_types):
                c[math.floor(y/mat_size), y%mat_size] = corr[x, y, ts]
            sigma2_source += c * source * source.H * c.H
            sigma2_sink += c.H * sink * sink.H * c
        sigma2_source /= n_configs
        sigma2_sink /= n_configs
        inv_sigma2_source = np.linalg.inv(sigma2_source)
        inv_sigma2_sink = np.linalg.inv(sigma2_sink)
        a_source = (source.H * mat[ts].H * inv_sigma2_source * inv_sigma2_source * mat[ts] * source)[0,0]
        a_sink = (sink.H * mat[ts] * inv_sigma2_sink * inv_sigma2_sink * mat[ts].H * sink)[0,0]
        a_source = 1.0/cmath.sqrt(a_source)
        a_sink = 1.0/cmath.sqrt(a_sink)
        old_source = source
        old_sink = sink
        source = a_sink * inv_sigma2_sink * mat[ts].H * old_sink
        sink = a_source * inv_sigma2_source * mat[ts] * old_source
        # source = a_source * inv_sigma2_source * mat[ts] * old_source
        source /= cmath.sqrt((source.H * source)[0,0])
        sink /= cmath.sqrt((sink.H * sink)[0,0])
        # print('Iter '+str(n)+' '+ str((old_source.H * source)[0,0])+' '+str((old_sink.H * sink)[0,0])+' '+str((source.H * sink)[0,0]))
    return source, sink
    def test_power_complex(self):
        x = blaze.array([1+2j, 2+3j, 3+4j])
        assert_equal(x**0, [1., 1., 1.])
        assert_equal(x**1, x)
        assert_almost_equal(x**2, [-3+4j, -5+12j, -7+24j])
        assert_almost_equal(x**3, [(1+2j)**3, (2+3j)**3, (3+4j)**3])
        assert_almost_equal(x**4, [(1+2j)**4, (2+3j)**4, (3+4j)**4])
        assert_almost_equal(x**(-1), [1/(1+2j), 1/(2+3j), 1/(3+4j)])
        assert_almost_equal(x**(-2), [1/(1+2j)**2, 1/(2+3j)**2, 1/(3+4j)**2])
        assert_almost_equal(x**(-3), [(-11+2j)/125, (-46-9j)/2197,
                                      (-117-44j)/15625])
        assert_almost_equal(x**(0.5), [cmath.sqrt(1+2j), cmath.sqrt(2+3j),
                                       cmath.sqrt(3+4j)])
        norm = 1./((x**14)[0])
        assert_almost_equal(x**14 * norm,
                [i * norm for i in [-76443+16124j, 23161315+58317492j,
                                    5583548873 +  2465133864j]])

        def assert_complex_equal(x, y):
            assert_array_equal(x.real, y.real)
            assert_array_equal(x.imag, y.imag)

        for z in [complex(0, np.inf), complex(1, np.inf)]:
            z = blaze.array([z], dshape="complex[float64]")
            assert_complex_equal(z**1, z)
            assert_complex_equal(z**2, z*z)
            assert_complex_equal(z**3, z*z*z)
Beispiel #9
0
def delay(omegaV, free):
	E_0 = -1.1591
	E_m = [-0.8502, -0.3278, -0.1665]
	T = 3/0.02419
	delta_m = np.zeros(np.size(E_m))
	for j in (0, 1, 2):
	    delta_m[j] = E_m[j] - E_0
	optSize = np.size(omegaV)
	alpha1f = np.zeros(optSize, 'complex')
	alpha3f = np.zeros(optSize, 'complex')
	realFactor = np.zeros(optSize, 'complex')
	imagFactor = np.zeros(optSize, 'complex')
	T = 3 / 0.02419

	for i in range(0, np.size(defs.omega_dip)-1):
	    alpha1f[i] = dipole.constructDipole(omegaV[i], defsDipole.wf1)
	    alpha3f[i] = dipole.constructDipole(omegaV[i], defsDipole.wf3)

	dawsArg1st = T*(delta_m[0] - omegaV)
	dawsArg3rd = T*(delta_m[1] - omegaV)
	realFactor = np.real((alpha1f * np.exp(-free*np.power(dawsArg1st,2.0)))\
            + (alpha3f * np.exp(-np.sqrt(free)*np.power(dawsArg3rd, 2.0))))

	imagFactor = (alpha1f * ((-2 * cmath.sqrt(-1))\
            / (np.sqrt(np.pi))) * spcl.dawsn(free*dawsArg1st))\
                + (alpha3f * ((-2 * cmath.sqrt(-1))\
                    / (np.sqrt(np.pi))) * spcl.dawsn(np.sqrt(free)*dawsArg3rd))

	dE = np.gradient(omegaV)
	dIm = np.gradient(imagFactor, dE)
	dRe = np.gradient(realFactor, dE)
	derivFactor = (realFactor * dIm) - (np.imag(imagFactor * dRe))
	zSquared = realFactor*realFactor + np.imag(imagFactor)*np.imag(imagFactor)
	ans =  (realFactor * np.imag(dIm) - np.imag(imagFactor * dRe)) / zSquared
	return ans
Beispiel #10
0
def find_opt_sn(source_g, sink_g, mat, ts):
    n_configs, t_size, mat_size, temp = mat.shape
    av_mat = average(mat)
    n_iter = 20
    source = np.matrix(source_g)
    sink = np.matrix(sink_g)
    for n in range(n_iter):
        sigma2_source = np.matrix(np.zeros((mat_size, mat_size), dtype=np.complex128))
        sigma2_sink = np.matrix(np.zeros((mat_size, mat_size), dtype=np.complex128))
        for x in range(n_configs):
            sigma2_source += np.matrix(mat[x, ts]) * source * source.H * np.matrix(mat[x, ts]).H
            sigma2_sink += np.matrix(mat[x, ts]).H * sink * sink.H * np.matrix(mat[x, ts])
        sigma2_source /= float(n_configs)
        sigma2_sink /= float(n_configs)
        inv_sigma2_source = np.linalg.inv(sigma2_source)
        inv_sigma2_sink = np.linalg.inv(sigma2_sink)
        a_source = (source.H * np.matrix(av_mat[ts]).H * inv_sigma2_source * inv_sigma2_source * np.matrix(av_mat[ts]) * source)[0,0]
        a_sink = (sink.H * np.matrix(av_mat[ts]) * inv_sigma2_sink * inv_sigma2_sink * np.matrix(av_mat[ts]).H * sink)[0,0]
        a_source = 1.0/cmath.sqrt(a_source)
        a_sink = 1.0/cmath.sqrt(a_sink)
        old_source = source
        old_sink = sink
        source = a_sink * inv_sigma2_sink * np.matrix(av_mat[ts]).H * old_sink
        sink = a_source * inv_sigma2_source * np.matrix(av_mat[ts]) * old_source
        source /= cmath.sqrt((source.H * source)[0,0])
        sink /= cmath.sqrt((sink.H * sink)[0,0])
        # print('Iter '+str(n)+' '+ str((old_source.H * source)[0,0])+' '+str((old_sink.H * sink)[0,0])+' '+str((source.H * sink)[0,0]))
    return source, sink
Beispiel #11
0
def get_pfix_transformed(p0, x4Ns, h):
    """
    Try to get the same result as the function in the kimura module.
    Change of variables according to eqn 3 of Chen et al.
    When I type
    (integral from 0 to p of exp(b*s*(x-a)**2) ) /
    (integral from 0 to 1 of exp(b*s*(x-a)**2) )
    I get
    ( erfi(sqrt(b)*sqrt(s)*a) - erfi(sqrt(b)*sqrt(s)*(a-p)) ) /
    ( erfi(sqrt(b)*sqrt(s)*a) - erfi(sqrt(b)*sqrt(s)*(a-1)) )
    @param p0: proportion of mutant alleles in the population
    @param x4Ns: 4Ns
    @return: fixation probability
    """
    if not x4Ns:
        # This is the neutral case.
        return p0
    if h == 0.5:
        # This is the genic case.
        # Checking for exact equality of 0.5 is OK.
        return math.expm1(-x4Ns*p0) / math.expm1(-x4Ns)
    b = 2.0 * h - 1.0
    a = h / (2.0 * h - 1.0)
    q = cmath.sqrt(b) * cmath.sqrt(x4Ns)
    #
    top = kimura.erfi(q*a) - kimura.erfi(q*(a-p0))
    bot = kimura.erfi(q*a) - kimura.erfi(q*(a-1))
    return top / bot
Beispiel #12
0
def gFakeSPA(DA,E):
  """ An SPA thing that I worked out in Mathematica.
    Probably totally wrong."""
  A = 1j*sqrt(1j/DA)*sqrt(E)/(sqrt(3.0*pi)*(t+0j)**(3.0/2.0))
  #EQ = exp(sig*2*1j*abs(DA)*acos( -sqrt( 1 - E**2/t**2 ) ) )

  return A#*EQ
Beispiel #13
0
  def int_temp(kA):
    qp = acos( 0.5*(-cos(kA) + sqrt( (E**2/t**2) - (sin(kA))**2 ) )  )
    qm = acos( 0.5*(-cos(kA) - sqrt( (E**2/t**2) - (sin(kA))**2 ) )  ) 

    if qp.imag < 0.0: qp = -qp
    if qm.imag < 0.0: qm = -qm

    sig = copysign(1,DZ)		# Check this versus zigzag SI (should be same though, on exponential)
    const = 1j/(2.0*pi*t**2)
    
    if s_lat == 'bb':
      return const*E*exp(1j*sig*qp*(DZ))*sin(kA*DA1)*sin(kA*DA2) / ( sin(2*qp) + sin(qp)*cos(kA) )		\
	+ const*E*exp(1j*sig*qm*(DZ))*sin(kA*DA1)*sin(kA*DA2) / ( sin(2*qm) + sin(qm)*cos(kA)  ) 
    elif s_lat == 'ww':
      fp = 1.0 + 2.0*cos(qp)*exp(1j*kA)
      fm = 1.0 + 2.0*cos(qm)*exp(1j*kA)
      ftp = 1.0 + 2.0*cos(qp)*exp(-1j*kA)
      ftm = 1.0 + 2.0*cos(qm)*exp(-1j*kA)
      fpasq = 1.0 + 4.0*cos(qp)*cos(kA) + 4.0*cos(qp)**2
      fmasq = 1.0 + 4.0*cos(qm)*cos(kA) + 4.0*cos(qm)**2
      Np = ( ftp*exp(-1j*kA*DA1) - fp*exp(1j*kA*DA1) )*( fp*exp(1j*kA*DA2) - ftp*exp(-1j*kA*DA2) )/fpasq
      Nm = ( ftm*exp(-1j*kA*DA1) - fm*exp(1j*kA*DA1) )*( fm*exp(1j*kA*DA2) - ftm*exp(-1j*kA*DA2) )/fmasq
      return 0.25*const*E*exp(1j*sig*qp*DZ)*Np / ( sin(2*qp) + sin(qp)*cos(kA) )		\
	+ 0.25*const*E*exp(1j*sig*qm*DZ)*Nm / ( sin(2*qm) + sin(qm)*cos(kA)  ) 
    else: print 's_lat not a valid character'
def condition_no(name):
    from math import sqrt
    h=0.001
    f=[]
    fh=[]
    ab=[]
    conditi=[]
    x=list
    for x in nup.arange(-1,1.1,0.1):
        for y in nup.arange(-1,1.1,0.1):
            try:
                f.append(eval(name))
                ab.append(sqrt(add(x**2,y**2)))
            except ValueError:
                pass
    for x in nup.arange(-1,1.1,0.1):
        try:
            x=x+h
            for y in nup.arange(-1,1.1,0.1):
                try:
                    y=y+h
                    fh.append(eval(name))
                except ValueError:
                    pass
        except ValueError:
            pass
    for num in range(0,len(f)):
        if f[num]!=0:
            D=abs(f[num])*sqrt(2)*h
            N=abs(fh[num]-f[num])*ab[num]
            conditi.append(N/D)
        else:
            conditi.append(None)
    return conditi
Beispiel #15
0
def get_pfix_transformed(p0, s_in, h):
    """
    Try to get the same result as the function in the kimura module.
    Change of variables according to eqn 3 of Chen et al.
    When I type
    (integral from 0 to p of exp(b*s*(x-a)**2) ) /
    (integral from 0 to 1 of exp(b*s*(x-a)**2) )
    I get
    ( erfi(sqrt(b)*sqrt(s)*a) - erfi(sqrt(b)*sqrt(s)*(a-p)) ) /
    ( erfi(sqrt(b)*sqrt(s)*a) - erfi(sqrt(b)*sqrt(s)*(a-1)) )
    """
    s = s_in * 2
    b = 2.0 * h - 1.0
    #XXX
    if not b:
        return float('nan')
    # transform h to alpha and beta, represented here by a and b
    a = h / (2.0 * h - 1.0)
    # intermediate parameter
    q = cmath.sqrt(b) * cmath.sqrt(s)
    #
    """
    top = 2*q*cmath.exp(a*a*b*s)
    bot_a = kimura.erfi(q*(1-a))
    bot_b = kimura.erfi(q*a)
    """
    top = kimura.erfi(q*a) - kimura.erfi(q*(a-p0))
    bot = kimura.erfi(q*a) - kimura.erfi(q*(a-1))
    return top / bot
Beispiel #16
0
  def int_temp(kA):
    qp = acos( 0.5*(-cos(kA) + sqrt( (E**2/t**2) - (sin(kA))**2 ) )  )
    qm = acos( 0.5*(-cos(kA) - sqrt( (E**2/t**2) - (sin(kA))**2 ) )  ) 

    if qp.imag < 0.0: qp = -qp
    if qm.imag < 0.0: qm = -qm

    sig = copysign(1,m-n)
    const = 1j/(4.0*pi*t**2)
    
    if s == 0:
      return const*E*( exp( 1j*( kA*(m+n) + sig*qp*(m-n) )  ) / ( sin(2*qp) + sin(qp)*cos(kA)  )		\
	+ exp( 1j*( kA*(m+n) + sig*qm*(m-n) )  ) / ( sin(2*qm) + sin(qm)*cos(kA)  )  )
    elif s == 1:
      fp = t*( 1.0 + 2.0*cos(qp)*exp(1j*kA)  )
      fm = t*( 1.0 + 2.0*cos(qm)*exp(1j*kA)  )
      
      return const*( exp( 1j*( kA*(m+n) + sig*qp*(m-n) )  )*fp / ( sin(2*qp) + sin(qp)*cos(kA)  )  	\
	+ exp( 1j*( kA*(m+n) + sig*qm*(m-n) )  )*fm / ( sin(2*qm) + sin(qm)*cos(kA)  )  ) 
    elif s == -1:
      ftp = t*( 1.0 + 2.0*cos(qp)*exp(-1j*kA)  )
      ftm = t*( 1.0 + 2.0*cos(qm)*exp(-1j*kA)  )

      return const*( exp( 1j*( kA*(m+n) + sig*qp*(m-n) )  )*ftp / ( sin(2*qp) + sin(qp)*cos(kA)  )  	\
      + exp( 1j*( kA*(m+n) + sig*qm*(m-n) )  )*ftm / ( sin(2*qm) + sin(qm)*cos(kA)  )  ) 
    else: print "Sublattice error in gBulk_kA"
Beispiel #17
0
def isqrt(c):
  if not isinstance(c,pol): return 1/math.sqrt(c)
  a0,p=c.separate(); p/=a0
  lst=[1/math.sqrt(a0)]
  for n in range(1,c.order+1):
    lst.append(-lst[-1]/a0/2/n*(2*n-1))
  return phorner(lst,p)
 def solve_quadratic_equation(a, b, c, d=0.):
     c -= d
     D = b**2 - 4*a*c
     tmp = 2*a
     x1 = (-b - cmath.sqrt(D)) / tmp
     x2 = (-b + cmath.sqrt(D)) / tmp
     return x1, x2
Beispiel #19
0
def get_eigenvectors(Data, N):
	   """                                                                                                                        Function to get eigenvectors in LL and RR for each time or frequency                                                                                                                                                                                  ====params====                                                                                                                                 
	   Data - Array with unpol visibilites 
	   N - Either number of frequencies or number of times on which to solve e-vec                                                                    
	   """
	   Gain_mat = np.zeros([n_ant, n_ant, N], np.complex128)

	   for ant_i in range(n_ant):
			 for ant_j in range(n_ant):
				    if ant_i <= ant_j:
						  Gain_mat[ant_i,ant_j,:] = Data[antmap(ant_i+1, ant_j+1, n_ant), :]
						  Gain_mat[ant_j,ant_i,:] = np.conj(Data[antmap(ant_i+1, ant_j+1, n_ant), :]) #Should be Hermitian                  
#                                Gain_mat[ant_j,ant_j,:] = 0 # Set autocorrelations to zero            

	   # Now try to find eigenvectors of 64x64 gainmatrices for all N
									 
	   gain_approx = np.zeros([n_ant, N, 2], np.complex128)

	   for k in range(N):
			 # Get the last two e-vals and e-vecs. Gain_mat should be rank 2
			 w, v = np.linalg.eigh(Gain_mat[:, :, k], UPLO='U')         
		
			 v1 = v[:,-1] / v[0,-1]
			 v2 = v[:,-2] / v[0,-2]

			 gain_approx[:, k, 0] = cmath.sqrt(w[-1]) * v1 / np.sqrt(abs(v1**2).sum())
			 gain_approx[:, k, 1] = cmath.sqrt(w[-2]) * v2 / np.sqrt(abs(v2**2).sum())


	   return gain_approx
Beispiel #20
0
def generate_quad(integer=False, real=True):

    if integer:
        root1 = random.randint(-10, 10)
        root2 = random.randint(-10, 10)

        b = root1 + root2
        c = root1 * root2

        return f"x^2 + {b}x + {c}"

    while True:
        b = random.randint(-25, 25)
        c = random.randint(-100, 100)

        root1 = (-b + cmath.sqrt(b**2 - 4*c)) / 2
        root2 = (-b - cmath.sqrt(b**2 - 4*c)) / 2

        if real and (root1.imag != 0 or root2.imag != 0):
            continue

        root1 = root1.real
        root2 = root2.real

        if abs(int(root1) - root1) < .01 or abs(int(root2) - root2) < .01:
            continue
        else:
            return f"x^2 + {b}x + {c}"
Beispiel #21
0
    def calc(self):
        """
        Surrogate model of a finite element analysis

        Limited to the following boundaries
           * wing.aspectRatio = 12. - 17.
           * wing.tcAVG = 0.08 - 0.13
           * wing.twist = -4. - -10.
           * wing.phi25 = 5. - 20.
           * aircraft.mTOM = 60000. - 90000.
           * strut.etaStrut = 0.2 - 0.7
           * strut.depth = 0.1 - 0.2

        :Source: Boehnke, D., A Multi-Fidelity Workflow to Derive Physics-Based Conceptual Design Methods, TUHH, tbp.
        """
        AR = self.parent.aircraft.wing.aspectRatio.getValue()
        S = self.parent.aircraft.wing.refArea.getValue()
        tc = self.parent.aircraft.wing.tcAVG.getValue()
        sw = self.parent.aircraft.wing.phi25.getValue() * pi / 180.0
        mTOM = self.parent.aircraft.mTOM.getValue()
        c = self.parent.depth.getValue()
        eta = self.parent.etaStrut.getValue()
        res = (
            0.02061845578 * sw * mTOM
            + 87.70552679 * eta * c * sqrt(AR * S)
            + S * eta * c * sqrt(AR * S)
            - 21790.78072 * sw * tc * eta
        )
        return self.setValueCalc(res)
Beispiel #22
0
    def answer_question(self, event):
        print 'answer'
        red = (self.red_slider.value - self.color_entry[1]) / 255.0
        green = (self.green_slider.value - self.color_entry[2]) / 255.0
        blue = (self.blue_slider.value - self.color_entry[3]) / 255.0
        # calculate distance from answer value
        distance = sqrt(red**2 + green**2 + blue**2)
        max_distance = sqrt(3)
        # calculate score
        score = (max_distance - distance) * sqrt(3) * 1000 / 3
        self.target_score += int(score.real if score.real > 0 else 0)
        # schedule score increment
        Clock.schedule_interval(self.increment_score, 1.0/60)
        # show answer color and guess color
        with self.color_guess.canvas.before:
            Color(self.red_slider.value / 255.0, self.green_slider.value / 255.0, self.blue_slider.value / 255.0)
            Rectangle(pos=self.color_guess.pos, size=self.color_guess.size)

        with self.color_answer.canvas.before:
            Color(self.color_entry[1] / 255.0, self.color_entry[2] / 255.0, self.color_entry[3] / 255.0)
            Rectangle(pos=self.color_answer.pos, size=self.color_answer.size)

        # change answer button to next question
        self.guess_button.text = 'Next Question'
        self.guess_button.unbind(on_press=self.answer_question)
        self.guess_button.bind(on_press=self.create_question)
Beispiel #23
0
def soddy(triplet):
    """
    Calcule le rayon et le centre du cercle de Soddy, en prenant en paramètre un triplet de cercle.
    :param triplet: list of three circles
    :type triplet: list
    :return: circle of soddy
    :rtype: tuple
    """
    rayon = get_rayons(triplet)
    centre= get_centres(triplet)
    k2=1/rayon[1]
    k3=1/rayon[2]
    z1=complex(centre[0][0],centre[0][1])
    z2=complex(centre[1][0],centre[1][1])
    z3=complex(centre[2][0],centre[2][1])
    # on calcule la corbure k4 du cercle de soddy
    if  rayon[0]<rayon[1] and rayon[0]<rayon[2]:
        k1 = 1/rayon[0]
        k4 = (k1+k2+k3)+(2*sqrt((k1*k2)+(k1*k3)+(k2*k3)))
        # on récupére les centres des trois cercles
        # on calcule le centre du cercle de soddy sous forme d'un complexe z4
        z4 = (z1*k1+z2*k2+z3*k3+2*cmath.sqrt(k1*k2*z1*z2+k2*k3*z2*z3+k1*k3*z1*z3))/k4
        return ( z4.real, z4.imag, 1/k4)
    else:
        k1= -1/rayon[0]
        k4= (k1+k2+k3)+(2*sqrt((k1*k2)+(k1*k3)+(k2*k3)))
        # on récupére les centres des trois cercles
        # Idem que precedemment 
        z4 = (z1*k1+z2*k2+z3*k3+2*cmath.sqrt(k1*k2*z1*z2+k2*k3*z2*z3+k1*k3*z1*z3))/k4
        return (z4.real, z4.imag, 1/k4)
def cercle_soddy(triplet):
    """
    Calculates the radius of the circle and the center of Soddy , taking in parameter triplet

    :param triplet: list of three circles (triplets)
    :type triplet: list
    :return: circle
    :rtype: tuple
    :UC:
    """

    # on récupére les centres des trois cercles
    # on calcule le centre du cercle de soddy sous forme d'un complexe z4
    k1 = 1 / triplet[0][2]
    k2 = 1 / triplet[1][2]
    k3 = 1 / triplet[2][2]
    k4 = (k1 + k2 + k3) + (2 * sqrt((k1 * k2) + (k1 * k3) + (k2 * k3)))
    z1 = complex(triplet[0][0], triplet[0][1])
    z2 = complex(triplet[1][0], triplet[1][1])
    z3 = complex(triplet[2][0], triplet[2][1])
    z4 = (z1 * k1 + z2 * k2 + z3 * k3 + 2 * cmath.sqrt(k1 * k2 * z1 * z2 + k2 * k3 * z2 * z3 + k1 * k3 * z1 * z3)) / k4
    # la condition verifie si la distance entre deux cercles est egale à la somme des deux rayons
    if (
        int(Distance(z4, z1)) == int((triplet[0][2] + 1 / k4))
        and int(Distance(z4, z2)) == int((triplet[1][2] + 1 / k4))
        and int(Distance(z4, z3)) == int((triplet[2][2] + 1 / k4))
    ):
        return (z4.real, z4.imag, 1 / k4)
    else:
        k1 = -1 / triplet[0][2]  # la courbure du cercle qui contient les autres est negative
        k4 = (k1 + k2 + k3) + (2 * sqrt((k1 * k2) + (k1 * k3) + (k2 * k3)))
        z4 = (
            z1 * k1 + z2 * k2 + z3 * k3 + 2 * cmath.sqrt(k1 * k2 * z1 * z2 + k2 * k3 * z2 * z3 + k1 * k3 * z1 * z3)
        ) / k4
        return (z4.real, z4.imag, 1 / k4)
def P(k) :
    D1=D10
    D2=D20
    i = 1
    while i < len(parlist):
        xi = parlist[i-1]
        r = k*pow(10,parlist[i])
        xi1 = parlist[i+1]
        D1new = (D1*math.pi*(r*scipy.special.jv(1.5 + 1./xi, r/xi+0j)*scipy.special.yv(0.5 + 1./xi1, r/xi1+0j) - 
        scipy.special.jv(0.5 + 1./xi, r/xi+0j)*((xi - xi1)*scipy.special.yv(0.5 + 1./xi1, r/xi1+0j) + 
        r*scipy.special.yv(1.5 + 1./xi1, r/xi1+0j)))/(2*cmath.sqrt(xi*xi1)) - 
        1j*D2*math.pi*(-r*scipy.special.yv(1.5 + 1./xi, r/xi+0j)*scipy.special.yv(0.5 + 1./xi1, r/xi1+0j) + 
        scipy.special.yv(0.5 + 1./xi, r/xi+0j)*((xi - xi1)*scipy.special.yv(0.5 + 1./xi1, r/xi1+0j) + 
        r*scipy.special.yv(1.5 + 1./xi1, r/xi1+0j)))/(2*cmath.sqrt(xi*xi1)))
        D2new = (-1j*D1*math.pi*(-r*scipy.special.jv(1.5 + 1./xi, r/xi+0j)*scipy.special.jv(0.5 + 1./xi1, r/xi1+0j) + 
        scipy.special.jv(0.5 + 1./xi, r/xi+0j)*((xi - xi1)*scipy.special.jv(0.5 + 1./xi1, r/xi1+0j) + 
        r*scipy.special.jv(1.5 + 1./xi1, r/xi1+0j)))/(2*cmath.sqrt(xi*xi1)) + 
        D2*math.pi*(r*scipy.special.jv(1.5 + 1./xi1, r/xi1+0j)*scipy.special.yv(0.5 + 1./xi, r/xi+0j) + 
        scipy.special.jv(0.5 + 1./xi1, r/xi1+0j)*((xi - xi1)*scipy.special.yv(0.5 + 1./xi, r/xi+0j) - 
        r*scipy.special.yv(1.5 + 1./xi, r/xi+0j)))/(2*cmath.sqrt(xi*xi1)))
        D1=D1new
        D2=D2new
        i+=2
#        print D1,D2,xi,r,xi1


#    return A * (k/k_0)**(n_s-1.)
    return A*pow(k,(2. - 2./xi1))*pow(abs(D2),2)
def myeig(M):
    """
    compute eigen values and eigenvectors analytically

    Solve quadratic:

      lamba^2 - tau*lambda +/- Delta = 0

    where tau = trace(M) and Delta = Determinant(M)

    if M = | a b |
           | c d |

    the trace is a+d and the determinant is a*d-b*c

    Return value is lambda1, lambda2
    """

    a,b = M[0,0], M[0,1]
    c,d = M[1,0], M[1,1]
    tau = a+d       # the trace
    delta = a*d-b*c # the determinant

    lambda1 = (tau + cmath.sqrt(tau**2 - 4*delta))/2.
    lambda2 = (tau - cmath.sqrt(tau**2 - 4*delta))/2.
    return lambda1, lambda2
def oh_r(eps_top, eps_low, f, theta, rms_g):
    """
    Oh et.al. (1992) surface backscatter calculations

    This functions calculations surface backscatter using the Oh et al. (1992) surface model.
    References
    Oh et al., 1992, An empirical model and an inversion technique for rader scattering
    from bare soil surfaces. IEEE Trans. Geos. Rem., 30, pp. 370-380

    Parameters
    ----------
    eps_top : complex number
        complex permittivity of upper(incoming) medium
    eps_low : complex number
        complex permittivity of lower medium
    f : float
        frequency in hertz
    theta : float
        incidence angle in degrees
    rms_g : float
        surface rms height in m
    """

    # speed of light in m/s
    c = 2.998e8

    # calculate wavelength in upper medium by using real part of refarctive index
    n_upper = cmath.sqrt(eps_top)
    wavelength = (c / f) / n_upper.real
    k_rms = (2. * cmath.pi / wavelength) * rms_g

    eps_eff = eps_low / eps_top

    gam0 = gammah(eps_eff, 0)

    gamh = gammah(eps_eff, theta)
    gamv = gammav(eps_eff, theta)
    theta = theta / 180.0 * cmath.pi

    # precalulcate cosines of angles
    ct = cmath.cos(theta)

    # Oh model equations
    g = 0.7 * (1. - cmath.exp(-0.65 * k_rms ** 1.8))
    root_p = 1. - ((2. * theta / cmath.pi) ** (1. / (3. * gam0))) * cmath.exp(-k_rms)
    p = (1 - (2 * theta / cmath.pi) ** (1 / (3 * gam0)) * cmath.exp(-1 * k_rms)) ** 2

    q = 0.23 * cmath.sqrt(gam0) * (1. - cmath.exp(-k_rms))

    sigma0 = {}

    sigma0['vv'] = g * (ct * (ct * ct)) * (gamv + gamh) / root_p

    # sig0vv = ((g*(cos(theta))^3)/sqrt(p))*(gamv+gamh);

    sigma0['vh'] = q * sigma0['vv']
    sigma0['hh'] = root_p * root_p * sigma0['vv']

    return sigma0
Beispiel #28
0
def fib4(n):
	phi1 = (1+cmath.sqrt(5))/2.
	phi2 = (1-cmath.sqrt(5))/2.
	
	a = 1./cmath.sqrt(5)
	b = -1./cmath.sqrt(5)
	
	return a*(phi1**n) + b*(phi2**n)	
Beispiel #29
0
def _get_xavier_weights(dim1, dim2, name=None, use_sigmoid=False):
    _high = cmath.sqrt(6) / cmath.sqrt(dim1 + dim2)
    _low = -_high
    if use_sigmoid:
        w = numpy.random.uniform(low=4 * _low, high=_high, size=(dim1, dim2))
    else:
        w = numpy.random.uniform(low=_low, high=_high, size=(dim1, dim2))
    return theano.shared(w.astype(DTYPE), name=name)
def middlebrook(a, b, c):
    try:
        q = math.sqrt(a*c)/b
        f = .5+ math.sqrt(1-4*q*q)/2
    except ValueError:
        q = cmath.sqrt(a*c)/b
        f = .5+ cmath.sqrt(1-4*q*q)/2
    return (-b/a)*f, -c/(b*f)
Beispiel #31
0
                            yy1=j
                            flag=True
                            break
                    if(flag == True):
                        break
                flag=False
                for i in range(GrabMat.shape[0]-1,0,-1):
                    for j in range(GrabMat.shape[1]-1):
                        if(GrabMat[i,j] !=0):#!=0
                            xx2=i
                            yy2=j
                            flag=True
                            break
                    if(flag == True):
                        break
                height = cmath.sqrt((xx1-xx2)**2 + (yy1-yy2)**2)
                height =  0.3971*int(height.real) + 112.57# 調整比率
 
                print('height:',height)
                #身高 height
                cv2.line(vis, (yy1, xx1), (yy2, xx2), (0,255,0))
                cv2.imshow('line',vis)
                cv2.waitKey(1)

                StardredWight =( height-150)*0.6+50
                
                #Area
                BodyArea =0
                for i in range(GrabMat.shape[0]-1):
                    for j in range(GrabMat.shape[1]-1):
                        if(GrabMat[i,j] !=0):
Beispiel #32
0
def VecAbs(vector):
    return cmath.sqrt(vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2]).real
Beispiel #33
0
def operation(num_one: str, oper: str,
              num_two: str) -> Union[int, float, complex]:
    """Takes two numbers in string format and performs specified input operation."""
    try:

        num_one = float(num_one)

    except:

        num_one = complex(num_one)

    try:

        num_two = float(num_two)

    except:

        num_two = complex(num_two)

    operation_ans = 0

    if oper == "^":

        operation_ans = num_one**num_two

    elif oper == "/":

        # Check if division by zero
        if div_check(num_one, num_two) == True:

            operation_ans = math.inf

        else:

            operation_ans = num_one / num_two

    elif oper == "*":

        operation_ans = num_one * num_two

    elif oper == "+":

        operation_ans = num_one + num_two

    elif oper == "-":

        operation_ans = num_one - num_two

    elif oper == "SIN":

        num_two = math.radians(num_two)
        operation_ans = round(math.sin(num_two), 7)

    elif oper == "COS":

        num_two = math.radians(num_two)
        operation_ans = round(math.cos(num_two), 7)

    elif oper == "TAN":

        num_two = math.radians(num_two)
        operation_ans = round(math.tan(num_two), 7)

    elif oper == "SEC":

        num_two = math.radians(num_two)
        if div_check(1, round(math.cos(num_two), 7)) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(1 / math.cos(num_two), 7)

    elif oper == "CSC":

        num_two = math.radians(num_two)
        if div_check(1, round(math.sin(num_two), 7)) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(1 / math.sin(num_two), 7)

    elif oper == "COT":

        num_two = math.radians(num_two)
        if div_check(1, round(math.tan(num_two), 7)) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(1 / math.tan(num_two), 7)

    elif oper == "ASIN":

        operation_ans = math.asin(num_two)
        operation_ans = round(math.degrees(operation_ans), 7)

    elif oper == "ACOS":

        operation_ans = math.acos(num_two)
        operation_ans = round(math.degrees(operation_ans), 7)

    elif oper == "ATAN":

        operation_ans = math.atan(num_two)
        operation_ans = round(math.degrees(operation_ans), 7)

    elif oper == "ASEC":

        if div_check(1, num_two) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(math.degrees(math.acos(1 / num_two)), 7)

    elif oper == "ACSC":

        if div_check(1, num_two) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(math.degrees(math.asin(1 / num_two)), 7)

    elif oper == "ACOT":

        if div_check(1, num_two) == True:

            operation_ans = round(math.degrees(math.atan(math.inf)), 7)

        else:

            operation_ans = round(math.degrees(math.atan(1 / num_two)), 7)

    elif oper == "SINH":

        operation_ans = round(math.sinh(num_two), 7)

    elif oper == "COSH":

        operation_ans = round(math.cosh(num_two), 7)

    elif oper == "TANH":

        operation_ans = round(math.tanh(num_two), 7)

    elif oper == "SECH":

        if div_check(1, round(math.cosh(num_two), 7)) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(1 / math.cosh(num_two), 7)

    elif oper == "CSCH":

        if div_check(1, round(math.sinh(num_two), 7)) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(1 / math.sinh(num_two), 7)

    elif oper == "COTH":

        if div_check(1, round(math.tanh(num_two), 7)) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(1 / math.tanh(num_two), 7)

    elif oper == "ASINH":

        operation_ans = round(math.asinh(num_two), 7)

    elif oper == "ACOSH":

        operation_ans = round(math.acosh(num_two), 7)

    elif oper == "ATANH":

        operation_ans = round(math.atanh(num_two), 7)

    elif oper == "ASECH":

        if div_check(1, num_two) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(math.acosh(1 / num_two), 7)

    elif oper == "ACSCH":

        if div_check(1, num_two) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(math.asinh(1 / num_two), 7)

    elif oper == "ACOTH":

        if div_check(1, num_two) == True:

            operation_ans = math.inf

        else:

            operation_ans = round(math.atanh(1 / num_two), 7)

    elif oper == "LN":

        operation_ans = math.log(num_two)

    elif oper == "LOG":

        operation_ans = math.log(num_two, num_one)

    elif oper == "SQRT":

        operation_ans = cmath.sqrt(num_two)

    return operation_ans
def solving_square_equation(a, b, c):

    x1 = (-b - cmath.sqrt(b**2 - 4 * a * c)) / 2 * a
    x2 = (-b + cmath.sqrt(b**2 - 4 * a * c)) / 2 * a

    return x1, x2
Beispiel #35
0
"""
Original file iteration failed to function as the math sqrt function cannot handle negative values. Imported cmath
to handle the problem.
"""

from cmath import sqrt

a = 2
b = 1
c = 2

q = b**2 - 4 * a * c
q_sr = sqrt(q)

x1 = (-b + q_sr) / 2 * a
x2 = (-b - q_sr) / 2 * a
print(x1, x2)
import cmath
a = int(input("Enter a value : "))
b = int(input("Enter b value : "))
c = int(input("Enter c value : "))
d = (b ** 2)-(4 * a * c)
sol1 = (-b - cmath.sqrt(d) / (2*a))
sol2 = (-b + cmath.sqrt(d) / (2*c ))
print("The solution is : {0} and {1} ".format(sol1,sol2))
Beispiel #37
0
def findSolutions(a, b, c):
  d = b*b - 4*a*c
  x1, x2 = (-b+sqrt(d))/2*a, (-b-sqrt(d))/2*a 
  return [x1, x2] if x1 != x2 else [x1, '2-krotny']
Beispiel #38
0
 def quadratic_eq(a, b, c):
     d = b**2 - 4 * a * c
     s1 = (b - cmath.sqrt(d)) / (2 * a)
     s2 = (-b - cmath.sqrt(d)) / (2 * a)
     return (s1, s2)
# Formula= ax^2+bx+c=0




#Code
# import complex math module  
import cmath  
a = float(input('Enter a: '))  
b = float(input('Enter b: '))  
c = float(input('Enter c: '))  
  
# calculate the discriminant  
d = (b**2) - (4*a*c)  
  
# find two solutions  
sol1 = (-b-cmath.sqrt(d))/(2*a)  
sol2 = (-b+cmath.sqrt(d))/(2*a)  
print('The solution are {0} and {1}'.format(sol1,sol2))
Beispiel #40
0
nq = 200000

prefix = 'TE'+str(tend) + '_a' + str(dx_mag)
simulate = True
plot = False

restart = False
restart_ts = 14

slow_factor = 1
############################ Linear Analysis ##################################
k2 = dx_mode**2
v2 = v**2

roots = [None,None,None,None]
roots[0] = cm.sqrt(k2 * v2+ omega_p**2 + omega_p * cm.sqrt(4*k2*v2+omega_p**2))
roots[1] = cm.sqrt(k2 * v2+ omega_p**2 - omega_p * cm.sqrt(4*k2*v2+omega_p**2))
roots[2] = -cm.sqrt(k2 * v2+ omega_p**2 + omega_p * cm.sqrt(4*k2*v2+omega_p**2))
roots[3] = -cm.sqrt(k2 * v2+ omega_p**2 - omega_p * cm.sqrt(4*k2*v2+omega_p**2))

real_slope = roots[1].imag

############################ Setup and Run ####################################
sim_params = {}
beam1_params = {}
loader1_params = {}
beam2_params = {}
loader2_params = {}
mesh_params = {}
mLoader_params = {}
analysis_params = {}
Beispiel #41
0
print("hdhdhdh is " + repr (a) )
str(0.1)


greeting='hello'
greeting.count('h')


print("hdhdhdh is %s " %a )


# In[254]:

#复数
import cmath
cmath.sqrt(-1)


# In[246]:

#保存并运行Python
#以  .py 结尾
#运行  python  hello.py
#脚本首行 加上   #!/usr/bin/env python
#在实际运行脚本之前,必须让脚本文件具有可执行属性   $chmod a+x hello.py


# In[ ]:

print str("hello world!")
theta_TM = list()

theta = 0
wavelength_scan = np.linspace(0.5, 3.2, 201)

## dispersive
I = np.identity(2 * num_ord + 1)
indices = np.arange(-num_ord, num_ord + 1)
spectra_R = []
spectra_T = []
# arrays to hold reflectivity and transmissitivity
omega_p = 0.72 * np.pi * 1e15
gamma = 5e12
eps_r = eps_r.astype('complex')
for wvlen in wavelength_scan:
    j = cmath.sqrt(-1)
    lam0 = wvlen
    k0 = 2 * np.pi / lam0
    #free space wavelength in SI units
    omega = 2 * np.pi * 3e8 / lam0 * 1e6
    epsilon_metal = 1 - omega_p**2 / (omega**2 + j * gamma * omega)
    #print(epsilon_metal)

    ## dispersive epsilon
    eps_r[0:border] = epsilon_metal

    ##construct convolution matrix
    E = convmat1D(eps_r, PQ)
    ## IMPORTANT TO NOTE: the indices for everything beyond this points are indexed from -num_ord to num_ord+1
    ## FFT of 1/e;
    E_conv_inv = convmat1D(1 / eps_r, PQ)
def Fresn_Refl0(eps):

    # calculates Fresnel reflectivity at normal incidence.
    gamma0 = (abs((1 - cmath.sqrt(eps)) / (1 + cmath.sqrt(eps)))) ** 2
    return(gamma0)
Beispiel #44
0
a = complex(1, 2)
print(a.real)
print(a.imag)
print(a.conjugate())

b = 3 - 5j

#a b两个复数进行运算
print(a + b)
print(a * b)
print(a / b)
print(abs(a))

#要使用sin和cos等函数 可以引入cmath模块
import cmath
print(cmath.sin(a))
print(cmath.cos(a))
print(cmath.exp(a))
print(cmath.sqrt(-1))
#使用一般无感知复数的模块 负数求平方根会直接报错 如下
import math
# print(math.sqrt(-1))

#numpy模块 可以直接创建复数数组
import numpy as ny
nyarr = ny.array([1 + 2j, 2 + 3j, 3 + 4j, 4 + 5j])
print(nyarr)
print(nyarr + 2)
print(ny.sin(nyarr))
Beispiel #45
0
def GSC(z):
    return 2.0 * (z + sqrt(1 - z**2) * (log(1 - z) - log(-1 + z)) / pi)
Beispiel #46
0
D = 11**2 - 4 * 28
if D < 0:
    print('Net korney')
else:
    x1 = (11 + sqrt(D)) / 2
    x2 = (11 - sqrt(D)) / 2
    print(x1, x2, x1**2 - 11 * x1 + 28)
#1.5
print('Zad 1.5')
z1 = 1 / 3 * (3 - 5j)
z2 = 1 + 2j
print(z1 + z2, z1 * z2, z1**2 + z2**3, z1 / z2)
#1.6
print('Zad 1.6')
print(((2 + 1j) * (1 / 2 + 3j))**(-2), (1 - 2j) / (2 + 3j) - (3 + 1j) / 2j)
#1.7
print('Zad 1.7')
z1 = (1 + 1j)**15 / (1 - 1j)**9
z2 = (2 - 3j) * cmath.sqrt(-1 + 1j)
z3 = (1 + 1j + 1j**2 + 1j**3)**10
print(cmath.polar(z1), cmath.polar(z2), cmath.polar(z3))
#1.8
print('Zad1.8')
print(sin(1) * cmath.sin(1 + 1j) * sqrt(3) + cmath.sqrt(1 - 1j))
#1.9
print('Zad1.11')
surname = input('Vvedite Familiju ')
age = int(input('Vvedite Vozrast '))
mark = float(input('Vvedite ozenku '))
print('Familija:', surname, 'Vozrast:', age, 'Ozenka:', mark)
Beispiel #47
0
    unorm = sqrt(sum([abs(u_[i])**2 for i in range(N)]))
    for i in range(N):
        u_[i] /= unorm


#########################################################################
## 开始第(2)小问
if __name__ == '__main__':
    x_max, dx = 2000, 0.1
    Nx = int(x_max / dx)
    x = [dx * i for i in range(-Nx, Nx + 1)]  # x的格点
    # 初始化-1,0,1级对角
    a = [0] + [-0.5 / dx**2 for i in range(len(x) - 1)]
    c = [-0.5 / dx**2 for i in range(len(x) - 1)] + [0]
    b = [
        1. / dx**2 - 1 / sqrt(((i - Nx) * dx)**2 + 2) + 0.48
        for i in range(len(x))
    ]
    lam, u = eigen_solver(a, b, c, [1 for i in range(len(x))])  # 求解!
    print('和 0.48 的偏差 ΔE = %.8f' % lam.real)

    unorm = sqrt(sum([abs(u[i])**2 for i in range(len(x))]))
    for i in range(len(x)):
        u[i] /= unorm
    u0 = u.copy()  # 拷贝一下初始波函数
    ## 以上是一样的内容:求初始的氢原子 1s 态波函数
    #########################################################################

    E0, Npulse = sqrt(1 / 3.5094448314), 18
    ome = 1
    T = 2 * Npulse * pi / ome
Beispiel #48
0
    def checkIntersections(self) -> None:
        """
        Check if any of the silkscreen intersects
        with pads, etc
        """

        self.intersections = []

        for graph in self.f_silk + self.b_silk:
            if "angle" in graph:
                # TODO
                pass
            elif "center" in graph:
                for pad in self.module.pads:
                    padComplex = complex(pad["pos"]["x"], pad["pos"]["y"])
                    padOffset = 0 + 0j
                    if "offset" in pad["drill"]:
                        if "x" in pad["drill"]["offset"]:
                            padOffset = complex(pad["drill"]["offset"]["x"],
                                                pad["drill"]["offset"]["y"])

                    edgesPad = {}
                    edgesPad[0] = (complex(pad["size"]["x"] / 2.0,
                                           pad["size"]["y"] / 2.0) +
                                   padComplex + padOffset)
                    edgesPad[1] = (complex(-pad["size"]["x"] / 2.0,
                                           -pad["size"]["y"] / 2.0) +
                                   padComplex + padOffset)
                    edgesPad[2] = (complex(pad["size"]["x"] / 2.0,
                                           -pad["size"]["y"] / 2.0) +
                                   padComplex + padOffset)
                    edgesPad[3] = (complex(-pad["size"]["x"] / 2.0,
                                           pad["size"]["y"] / 2.0) +
                                   padComplex + padOffset)

                    vectorR = cmath.rect(
                        1, cmath.pi / 180 * pad["pos"]["orientation"])
                    for i in range(4):
                        edgesPad[i] = (edgesPad[i] -
                                       padComplex) * vectorR + padComplex

                    centerComplex = complex(graph["center"]["x"],
                                            graph["center"]["y"])
                    endComplex = complex(graph["end"]["x"], graph["end"]["y"])
                    radius = abs(endComplex - centerComplex)
                    if "circle" in pad["shape"]:
                        distance = radius + pad["size"]["x"] / 2.0 + 0.075
                        if abs(centerComplex - padComplex) < distance and abs(
                                centerComplex - padComplex) > abs(
                                    -radius + pad["size"]["x"] / 2.0 + 0.075):
                            self.intersections.append({
                                "pad": pad,
                                "graph": graph
                            })
                    else:
                        # if there are edges inside and outside the circle, we have an intersection
                        edgesInside = []
                        edgesOutside = []
                        for i in range(4):
                            if abs(centerComplex - edgesPad[i]) < radius:
                                edgesInside.append(edgesPad[i])
                            else:
                                edgesOutside.append(edgesPad[i])
                        if edgesInside and edgesOutside:
                            self.intersections.append({
                                "pad": pad,
                                "graph": graph
                            })
            else:
                for pad in self.module.pads:

                    # Skip checks on NPTH and Connect holes
                    if pad["type"] in ["np_thru_hole", "connect"]:
                        continue

                    padComplex = complex(pad["pos"]["x"], pad["pos"]["y"])
                    padOffset = 0 + 0j
                    if "offset" in pad["drill"]:
                        if "x" in pad["drill"]["offset"]:
                            padOffset = complex(pad["drill"]["offset"]["x"],
                                                pad["drill"]["offset"]["y"])

                    edgesPad = {}
                    edgesPad[0] = (complex(pad["size"]["x"] / 2.0,
                                           pad["size"]["y"] / 2.0) +
                                   padComplex + padOffset)
                    edgesPad[1] = (complex(-pad["size"]["x"] / 2.0,
                                           -pad["size"]["y"] / 2.0) +
                                   padComplex + padOffset)
                    edgesPad[2] = (complex(pad["size"]["x"] / 2.0,
                                           -pad["size"]["y"] / 2.0) +
                                   padComplex + padOffset)
                    edgesPad[3] = (complex(-pad["size"]["x"] / 2.0,
                                           pad["size"]["y"] / 2.0) +
                                   padComplex + padOffset)

                    vectorR = cmath.rect(
                        1, cmath.pi / 180 * pad["pos"]["orientation"])
                    for i in range(4):
                        edgesPad[i] = (edgesPad[i] -
                                       padComplex) * vectorR + padComplex

                    startComplex = complex(graph["start"]["x"],
                                           graph["start"]["y"])
                    endComplex = complex(graph["end"]["x"], graph["end"]["y"])
                    if endComplex.imag > startComplex.imag:
                        vector = endComplex - startComplex
                        padComplex = padComplex - startComplex
                        for i in range(4):
                            edgesPad[i] = edgesPad[i] - startComplex
                    else:
                        vector = startComplex - endComplex
                        padComplex = padComplex - endComplex
                        for i in range(4):
                            edgesPad[i] = edgesPad[i] - endComplex
                    length = abs(vector)

                    vectorR = cmath.rect(1, -cmath.phase(vector))
                    padComplex = padComplex * vectorR
                    for i in range(4):
                        edgesPad[i] = edgesPad[i] * vectorR

                    if "circle" in pad["shape"]:
                        distance = cmath.sqrt((pad["size"]["x"] / 2.0)**2 -
                                              (padComplex.imag)**2).real
                        padMinX = padComplex.real - distance
                        padMaxX = padComplex.real + distance
                    else:
                        edges = [
                            [0, 3],
                            [0, 2],
                            [2, 1],
                            [1, 3],
                        ]  # lines of the rectangle pads
                        x0 = []  # vector of value the x to y=0
                        for edge in edges:
                            x1 = edgesPad[edge[0]].real
                            x2 = edgesPad[edge[1]].real
                            y1 = edgesPad[edge[0]].imag
                            y2 = edgesPad[edge[1]].imag
                            if y1 != y2:
                                x = -y1 / (y2 - y1) * (x2 - x1) + x1
                                if x < max(x1, x2) and x > min(x1, x2):
                                    x0.append(x)
                        if x0:
                            padMinX = min(x0)
                            padMaxX = max(x0)
                        else:
                            continue
                    if ((padMinX < length and padMinX > 0)
                            or (padMaxX < length and padMaxX > 0)
                            or (padMaxX > length and padMinX < 0)):
                        if "circle" in pad["shape"]:
                            distance = pad["size"]["x"] / 2.0
                            padMin = padComplex.imag - distance
                            padMax = padComplex.imag + distance
                        else:
                            padMin = min(
                                edgesPad[0].imag,
                                edgesPad[1].imag,
                                edgesPad[2].imag,
                                edgesPad[3].imag,
                            )
                            padMax = max(
                                edgesPad[0].imag,
                                edgesPad[1].imag,
                                edgesPad[2].imag,
                                edgesPad[3].imag,
                            )
                        try:
                            differentSign = padMax / padMin
                        except ZeroDivisionError:
                            differentSign = padMin / padMax
                        if ((differentSign < 0) or (abs(padMax) < 0.075)
                                or (abs(padMin) < 0.075)):
                            self.intersections.append({
                                "pad": pad,
                                "graph": graph
                            })
Beispiel #49
0
 def matrix(self):
     return 1. / cmath.sqrt(2.) * np.matrix([[1, 1], [1, -1]])
Beispiel #50
0
    def fix(self) -> None:
        """
        Proceeds the fixing of the rule, if possible.
        """

        module = self.module

        if self.check():
            if self.refDesError:
                ref = self.module.reference
                if (self.checkReference()
                    ):  # @todo checkReference() does not return anything
                    ref["value"] = "REF**"
                    ref["layer"] = "F.SilkS"
                    ref["font"]["width"] = KLC_TEXT_SIZE
                    ref["font"]["height"] = KLC_TEXT_SIZE
                    ref["font"]["thickness"] = KLC_TEXT_THICKNESS
            for graph in self.bad_width:
                graph["width"] = KLC_SILK_WIDTH
            for inter in self.intersections:
                pad = inter["pad"]
                graph = inter["graph"]
                if "angle" in graph:
                    # TODO
                    pass
                elif "center" in graph:
                    # TODO
                    pass
                else:
                    padComplex = complex(pad["pos"]["x"], pad["pos"]["y"])
                    startComplex = complex(graph["start"]["x"],
                                           graph["start"]["y"])
                    endComplex = complex(graph["end"]["x"], graph["end"]["y"])
                    if endComplex.imag < startComplex.imag:
                        startComplex, endComplex = endComplex, startComplex

                        graph["start"]["x"] = startComplex.real
                        graph["start"]["y"] = startComplex.imag
                        graph["end"]["x"] = endComplex.real
                        graph["end"]["y"] = endComplex.imag

                    vector = endComplex - startComplex
                    padComplex = padComplex - startComplex
                    length = abs(vector)
                    phase = cmath.phase(vector)
                    vectorR = cmath.rect(1, -phase)
                    padComplex = padComplex * vectorR
                    distance = cmath.sqrt((pad["size"]["x"] / 2.0 + 0.226)**2 -
                                          (padComplex.imag)**2).real
                    padMin = padComplex.real - distance
                    padMax = padComplex.real + distance

                    if 0 < padMin < length:
                        if padMax > length:
                            padComplex = (padMin + 0j) * cmath.rect(
                                1, phase) + startComplex
                            graph["end"]["x"] = round(padComplex.real, 3)
                            graph["end"]["y"] = round(padComplex.imag, 3)
                        else:
                            padComplex = (padMin + 0j) * cmath.rect(
                                1, phase) + startComplex
                            graph2 = deepcopy(graph)
                            graph["end"]["x"] = round(padComplex.real, 3)
                            graph["end"]["y"] = round(padComplex.imag, 3)
                            padComplex = (padMax + 0j) * cmath.rect(
                                1, phase) + startComplex
                            graph2["start"].update(
                                {"x": round(padComplex.real, 3)})
                            graph2["start"].update(
                                {"y": round(padComplex.imag, 3)})
                            module.lines.append(graph2)
                    elif padMin < 0 and 0 < padMax < length:
                        padComplex = (padMax + 0j) * cmath.rect(
                            1, phase) + startComplex
                        graph["start"]["x"] = round(padComplex.real, 3)
                        graph["start"]["y"] = round(padComplex.imag, 3)
                    elif padMax > length and padMin < 0:
                        module.lines.remove(graph)
        return Rvhpol[1] - 180

    elif (Rvh.real > 0 and Rvh.imag < 0):

        return 360 - Rvhpol[1]

    else:
        return Rvhpol[1]


#--------------------calculos de ejercicio------------------

r = complex(Er * (math.sin(y)), -(x * (math.sin(y))))
comp = complex(Er - (math.cos(y)**2), -x)

Rv1 = ((r) - (cmath.sqrt(comp)))
Rv2 = ((r) + (cmath.sqrt(comp)))
Rv = (Rv1 / Rv2)

Rvpol = cmath.polar(Rv)

ang = correct_angle(Rv, Rvpol)

rad = Rvpol[0]

R1 = math.sqrt((d * 1000)**2 + (h1 - h2)**2)
R2 = math.sqrt((d * 1000)**2 + (h1 + h2)**2)
R2_R1 = (R2 - R1)

angR = (360 / landa) * R2_R1
Beispiel #52
0
import numpy as np
import matplotlib.pyplot as plt
import cmath as cm
m=int(input("enter value="))
k=int(input("enter number of samples for x[n]:"))
a=[]
for n in range(0,m-1):
	c=np.cos(2*np.pi*n/(m-1))
	r=np.abs(0.54-0.5*c)
	a=np.append(a,r)
N=1000
j=cm.sqrt(-1)
X=[]
w=np.linspace(-np.pi,np.pi,N)
for i in range(0,N):
	s=0
	for n in range(0,len(a)):
		s=s+(a[n]*np.exp(-n*w[i]*j))
	X.append(s)
print("X[n]=",np.abs(X))
plt.plot(w,np.abs(X))
plt.xlabel("freq(w/pi)")
plt.ylabel("magnitude")
plt.title("magnitude spectrum")
plt.show()
print 'VTail Chord     : ', AsUnit(Aircraft.VTail.Chord(0 * IN), 'in')
print 'VTail Length    : ', AsUnit(Aircraft.VTail.L, 'in')
print
print 'S&C PROPERTIES'
print 'Steady state roll rate: ', AsUnit(
    Deriv.RollDueToAileron(15 * ARCDEG, 'Aileron'), 'deg/s')
print 'Steady state pitch rate: ', Deriv.PitchResponseDueToElevator(
    10 * ARCDEG, 1 * SEC, 'Elevator') * 180 / math.pi
print 'Yaw Damping : ', Deriv.Np()
print 'AVL Xnp      : ', Deriv.Xnp, 'in'
print 'Aircraft Xnp : ', AsUnit(Aircraft.Xnp(), 'in')
#print 'Horizontal Tail incidence angle  : ', AsUnit( Aircraft.HTail.i, 'deg' )
print
print 'AVL Cma, Ma    : ', Deriv.Cma, Ma
print 'AVL Ma**0.5    : ', (-Ma)**0.5
print 'AVL sqrt(Ma)   : ', math.sqrt(-Ma / (1 / SEC**2))
print 'AVL Cmq, Mq    : ', Deriv.Cmq, Mq
print 'AVL Madot      : ', Madot
print -((Mq + Madot) / (2 * (-Ma)**0.5))
print
print 'Aircraft Cmadot   : ', Aircraft.Cmadot()
print 'Aircraft Cmq      : ', Aircraft.Cmq()

#print 'Spiral Mode: ', Deriv.SpiralMode()
#print 'Spiral double time: ', Deriv.SpiralDoubleTime()
#print 'AVL Clr    : ', Deriv.Clr
#print 'AVL Clb    : ', Deriv.Clb
#print 'AVL Cnr    : ', Deriv.Cnr
#print 'AVL Cnb    : ', Deriv.Cnb

endTime = time.time()  # mark the end of the simulation
Beispiel #54
0
from matplotlib import pyplot as plt
import numpy as np
from cmath import sqrt

#Physical constants
e = 1.60217662e-19
epsilon_0 = 8.85e-12
j = sqrt(-1)
k_B = 1.38064852e-23


def get_phi_scl_gaussian(x_list, mu, sigma, phi_0):
    return phi_0*np.exp(-np.power(x_list - mu, 2.) / (2 * np.power(sigma, 2.)))

def get_second_derivative(array):
    array = np.diff(np.diff(array))
    array = np.insert(array, 0, array[0])
    array = np.append(array, array[-1])
    return array/x_step_size**2

# def get_c_oh_scl(charge_density_per_formula_unit):
#     return charge_density_per_formula_unit + c_acc

def get_c_oh_scl(gaussian_phi_scl):
    return c_oh_bulk*(1/np.exp((e*gaussian_phi_scl)/(k_B*T)))

def get_z_scl(resistivity_scl):
    z_scl = []
    for w in w_list:
        z_scl_at_w = np.sum((resistivity_scl*x_step_size)/(1 + j*w*resistivity_scl*epsilon_0*epsilon_r))
        z_scl.append(z_scl_at_w)
Beispiel #55
0
print("ax" + SQUARED + " + bx + c = 0")
a = get_float("enter a: ", False)
b = get_float("enter b: ", True)
c = get_float("enter c: ", True)

if a%1 == 0:
    a = int(a)
if b%1 == 0:
    b = int(b)
if c%1 == 0:
    c = int(c)

x1 = None
x2 = None
discriminant = (b ** 2) - (4 * a * c)
if discriminant == 0:
    x1 = -(b / (2 * a))
else:
    if discriminant > 0:
        root = math.sqrt(discriminant)
    else: # discriminant < 0
        root = cmath.sqrt(discriminant)
    x1 = (-b + root) / (2 * a)
    x2 = (-b - root) / (2 * a)

equation = ("{a}x{SQUARED} {b:+}x {c:+} = 0 {ARROW} x = {x1}"
            .format(**locals()))
if x2 is not None:
    equation += " or x = {0}".format(x2)
print(equation)
input('Press ENTER to exit')
tau = tauMin
G = []
CR = []

tau_opt = 0.0
C_R_opt = 1000.0

# create file
f = open("C_R.csv", 'w')
f.close()

# calculate C_R for different gamma values
while (tau < tauMax):
    tmp = Lx
    for i in range(2, dampres + 2, 1):
        k[i] = cmath.sqrt((w**2) / (c**2) +
                          (1j * w * tau * b(tmp + 0.5 * xd[i])) / ((c)**2))
        tmp += xd[i]

    # calculate transmission and reflection coefficients
    for i in range(
            dampres, 0, -1
    ):  # go cell-by-cell from the end of the relaxation zone to its entrance. E.g. for 3 zones, start with zone 3, then 2, then 1.
        beta[i + 1] = fbeta(i + 1)
        Cr[i] = fCr(i)
        Ct[i] = fCt(i)

    # write reflection coefficients to file
    f = open("C_R.csv", 'a')
    f.write(str(tau * forcedEQs) + csv_file_separator + str(abs(Cr[1])) + "\n")
    G.append(tau * forcedEQs)
    CR.append(abs(Cr[1]))
Beispiel #57
0
def lambertw_branchpt(z):
    """Series for W(z, 0) around the branch point."""
    a, b, c = -1.0 / 3.0, 1.0, -1.0
    p = cmath.sqrt(2 * (cmath.e * z + 1))

    return cevalpoly(a, b, c, 2, p)
	'ord': ord,
	'chr': chr,
	'hex': hex,
	'oct': oct,
	'int': int,
	# direct imports
	'e': math.e,
	'pi': math.pi,
	'atan2': math.atan2,
	'fmod': math.fmod,
	'frexp': math.frexp,
	'hypot': math.hypot,
	'ldexp': math.ldexp,
	'modf': math.modf,
	# other nice-to-have constants
	'j': cmath.sqrt(-1),
	# marshall between the math and cmath functions automatically
	'acos': lambda x: which_call(x, math.acos, cmath.acos),
	'asin': lambda x: which_call(x, math.asin, cmath.asin),
	'atan': lambda x: which_call(x, math.atan, cmath.atan),
	'cos': lambda x: which_call(x, math.cos, cmath.cos),
	'cosh': lambda x: which_call(x, math.cosh, cmath.cosh),
	'sin': lambda x: which_call(x, math.sin, cmath.sin),
	'sinh': lambda x: which_call(x, math.sinh, cmath.sinh),
	'tan': lambda x: which_call(x, math.tan, cmath.tan),
	'tanh': lambda x: which_call(x, math.tanh, cmath.tanh),
	'exp': lambda x: which_call(x, math.exp, cmath.exp),
	'log10': lambda x: which_call(x, math.log10, cmath.log10, False),
	'sqrt': lambda x: which_call(x, math.sqrt, cmath.sqrt, False),
	# functions defined here
	'degrees': degrees,
Beispiel #59
0
                  [-omega**2 -3*gamma*y[0]**2 -2*eta*y[0]*y[1], -2*beta -eta*y[0]**2, p*np.cos(y[2])],
                  [0, 0, 0]])
    yd = np.array([y[1],
                   -2*beta*y[1] -omega**2*y[0] -gamma*y[0]**3 -eta*y[0]**2*y[1] +p*np.sin(y[2]),
                   Omega,
                   J[0,0]*y[3] + J[0,1]*y[4] + J[0,2]*y[5],
                   J[1,0]*y[3] + J[1,1]*y[4] + J[1,2]*y[5],
                   J[2,0]*y[3] + J[2,1]*y[4] + J[2,2]*y[5]])
    return yd


#%% Parameters

### System parameters
beta = 0.01
omega = sqrt(-0.5)
gamma = 0.4
eta = 0.05
p = 0.2
Omega = 0.82
fn = 'Omega' + str(Omega).replace('.','_')

par = [eta,gamma,p,omega,beta,Omega]
parRef = ['eta','gamma','p','omega','beta','Omega']

### Solving parameters
nSys    = 3          # Dimension of ODE
nDiv    = 100        # Cycles of 2.pi/Omega for determining time step spacing

### PERIODIC SOLUTION
nSkipTransient = 300 # Cycles of transient to skip
Beispiel #60
0
import cmath

a = int(input("Enter first factor : "))
b = int(input("Enter second factor: "))
c = int(input("Enter third factor: "))

d = b**2 - (4 * a * c)

if (d < 0):
    print("no solution")

elif (d == 0):
    x1 = -1 * b / (2 * a)
    print("Solution: " + str(x1))

else:
    x1 = (-1 * b - cmath.sqrt(d)) / (2 * a)
    x2 = (-1 * b + cmath.sqrt(d)) / (2 * a)
    print("Solution: " + str(x1) + ", " + str(x2))