def LiX(num):
function = lambda t: (1 / math.log(t))
res = 0
#Special case: integration leads to 0 in denominator
if (num == 2):
return 1
#Split into components for more precise integration for num > 1000
if (num > 1000 and int(num / 1000) > 1):
mod = num % 1000
div = int(num / 1000)
#Add integration over 1000s
for i in range(1, div + 1, 1):
res += quadpack.quad(function, (i - 1) * 1000, i * 1000)[0]
#Add remainder
res += quadpack.quad(function, div * 1000, div * 1000 + mod)[0]
#Just calculate it directly
else:
res += quadpack.quad(function, 0, num)[0]
return math.floor(res)
def main(x0, y0, x1, y1, x2, y2):
arr = [[0, 0], [0, 1], [1, 0]]
pts = []
for e, n in arr:
pnt = generalT(e, n)
pts.append([pnt[0][0], pnt[1][0]])
global det
det = np.linalg.det(matrix)
res1 = 0
res2 = 0
res3 = 0
lagrange = calcLagrange((x0, y0), (x1, y1), (x2, y2))
for i in range(3):
alpha, err = quad(outerIntegral, a=0, b=1, args=(i, lagrange))
print("alpha #" + str(i) + ": " + '{:.2f}'.format(alpha))
res1 += alpha * fxy1(pts[i][0], pts[i][1])
res2 += alpha * fxy2(pts[i][0], pts[i][1])
res3 += alpha * fxy3(pts[i][0], pts[i][1])
print()
print("Ergebnis0: " + '{:.4f}'.format(res1))
print("Ergebnis1: " + '{:.4f}'.format(res2))
print("Ergebnis2: " + '{:.4f}'.format(res3))
return res2 #für g
def compute_tau_z(Q, zmin=0.6, zmax=14., dz=0.3):
z_integrate = arange(zmin, zmax, dz)
taus_plot = []
for i in z_integrate:
taus_plot.append(quadpack.quad(tau, 0.3, i)[0])
return z_integrate, taus_plot
def test1DNormalDist(self):
# prepare data
U = dists.Normal(1.85, .3, 0, 3)
trainSamples = np.array([U.rvs(500)]).T
testSamples = np.array([U.rvs(1000)]).T
# build parameter set
dist = KDEDist(trainSamples,
kernelType=KernelType_GAUSSIAN,
bandwidthOptimizationType=
BandwidthOptimizationType_MAXIMUMLIKELIHOOD,
bounds=U.getBounds())
# fig = plt.figure()
# plotDensity1d(U)
# plotDensity1d(dist)
print("quad = %s" % (quad(lambda x: dist.pdf([x]), 0, 3), ))
print("mean = %g ~ %g" % (U.mean(), dist.mean()))
print("var = %g ~ %g" % (U.var(), dist.var()))
print("KL = %g" % U.klDivergence(dist, testSamples, testSamples))
print("CE = %g" % dist.crossEntropy(testSamples))
print("MSE = %g" % dist.l2error(U, testSamples, testSamples))
plt.show()
def calc_area(f_x_sym, f_y_sym, t_val):
from sympy.abc import t
f_x = lambdify(t, f_x_sym,['numpy'])
f_y = lambdify(t, f_y_sym, ['numpy'])
df_x = lambdify(t, diff(f_x_sym), ['numpy'])
df_y = lambdify(t, diff(f_y_sym), ['numpy'])
integrand = lambda tau: f_x(tau)*df_y(tau)-df_x(tau)*f_y(tau)
return abs(0.5 * quad(integrand, 0, t_val)[0])
def calc_area(f_x_sym, f_y_sym, t_val):
from sympy.abc import t
f_x = lambdify(t, f_x_sym, ['numpy'])
f_y = lambdify(t, f_y_sym, ['numpy'])
df_x = lambdify(t, diff(f_x_sym), ['numpy'])
df_y = lambdify(t, diff(f_y_sym), ['numpy'])
integrand = lambda tau: f_x(tau) * df_y(tau) - df_x(tau) * f_y(tau)
return abs(0.5 * quad(integrand, 0, t_val)[0])
def secondOrderSys(C, t_span):
t_deriv = np.zeros(1)
for i in range(t_span[1]):
sol = opt.fsolve(deriv, i, args=(C))
t_deriv = np.append(t_deriv, sol[0])
sys_t_deriv = sys(t_deriv, C)
sys_max = np.max(sys_t_deriv)
sys_min = np.min(sys_t_deriv)
if abs(sys_max) > abs(sys_min):
t_sol = sys_max
else:
t_sol = sys_min
err = quad.quad(integral, t_span[0], t_span[1], args=(C))
print('Peak location: t = {:.3f}'.format(t_sol))
print('Peak value: x = {:.3f}'.format(sys(t_sol, C)))
print('Error integral: err = {:.3f}'.format(err[0]))
import numpy as np
from scipy.integrate.quadpack import quad
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.style.use('default')
b = 5.0
# Function which is to be integrated
def func(x):
return np.array(x**2)
x = np.linspace(-10, 10, 201)
integral, err = quad(func, 1, 5)
# Numerical quadrature that calculates the integral and error using fortran's quadpack library.
print("The integral is :", integral)
print("The error is :", err)
section = np.linspace(-5, 5, 20)
plt.plot(x, func(x), label='Function', color='b')
plt.fill_between(section, func(section), facecolor='red')
plt.grid()
plt.legend()
plt.title('Area under the curve')
plt.show()
import scipy.integrate
from scipy.integrate.quadpack import quad
# print(help(quad))
scipy.special.b
[a, b] = [0, 1]
def f1(x): return np.exp(-x**2)
def kernel(x): return np.exp(-x**2)
quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08,
limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50)
[xmin,xmax,nx]=[-2,2,100]
xx = np.linspace(xmin, xmax, nx)
yy = np.heaviside(xx, 0)
yint=np.trapz(yy,xx)
yy/=yint
ylist=[yy.tolist()]
ylist
xlist=[xx.tolist()]
# x2 = np.convolve(xx[::],xx[::])
nbox=4
for i in range(nbox):
Q_not.append(Q[len(Q) - i - 1][0])
z_not.append(zs[len(zs) - i - 1])
# now interpolate
Q = interp1d(array(z_not), array(Q_not), kind='linear') # p is rho UV(z)
TOTAL = plot(z_not, Q(z_not), 'g-', linewidth=3, zorder=-1)
#TOTAL = plot(zs,Q,'r--',linewidth=3,zorder=-1)
# SOLVE TAU:
z_integrate = arange(0.6, 14., 0.3)
os.system('rm tau_predict.txt')
for i in z_integrate:
#print Q(i)
A = quadpack.quad(tau, 0.1, i)[0]
print >> open('tau_predict.txt', 'a'), i, A
"""
# LEGEND
I1=legend((TOTAL[0],LAEs[0],LBGS[0]),(r'Total LBGs',r'LAEs',r'Non-LAEs'), shadow = True, loc=3,numpoints=1)
ltext = gca().get_legend().get_texts()
setp(ltext[0], fontsize = 24, color='0.1')
setp(ltext[1], fontsize = 24, color='k')
#setp(ltext[2], fontsize = 15, color = '0.1')
frame=I1.get_frame()
frame.set_linewidth(0)
frame.set_visible(False)
"""
# Define the axis
def continuous_convolution(f, g):
return lambda t: quad(lambda v: (f(v) * g(t - v)), -Inf, Inf)[0]
def spectra(l, T):
h = D['Planck constant'][0]
k = D['Boltzmann constant'][0]
c = D['speed of light in vacuum'][0]
func = ((2.0 * np.pi * h * c**2) / (l**5)) / (np.exp(h * c /
(l * k * T)) - 1.0)
return func
T1 = 5770.0 # Surface temperature of the sun!
T2 = 6000.0
T3 = 5000.0
T4 = 4000.0
int1, err1 = quad(spectra, 0.38e-6, 0.78e-6, args=(T1))
E1 = s * T1**4
l = np.linspace(0, 5e-6, 2**12 + 1)
s1 = spectra(l, T1)
s2 = spectra(l, T2)
s3 = spectra(l, T3)
s4 = spectra(l, T4)
print "The total Energy flux is :", E1
print "The Energy flux in the band is :", int1
print "The Energy flux Fraction is:", int1 / E1
print "The error is :", err1
def arclength(df_x, df_y, t):
integrand = lambda tau: np.sqrt( df_x(tau)**2+df_y(tau)**2 )
return quad(integrand,0,t)[0]
s = D['Stefan-Boltzmann constant'][0]
def spectra(l,T):
h = D['Planck constant'][0]
k = D['Boltzmann constant'][0]
c = D['speed of light in vacuum'][0]
func = ((2.0*np.pi*h*c**2)/(l**5))/(np.exp(h*c/(l*k*T)) - 1.0)
return func
T1 = 5770.0 # Surface temperature of the sun!
T2 = 6000.0
T3 = 5000.0
T4 = 4000.0
int1,err1 = quad(spectra, 0.38e-6, 0.78e-6, args=(T1))
E1 = s*T1**4
l = np.linspace(0, 5e-6, 2**12 + 1)
s1 = spectra(l, T1)
s2 = spectra(l, T2)
s3 = spectra(l, T3)
s4 = spectra(l, T4)
print "The total Energy flux is :", E1
print "The Energy flux in the band is :", int1
print "The Energy flux Fraction is:", int1/E1
print "The error is :", err1
def dfermi(n, eta, beta, use_timmes=False):
res = quadpack.quad(fdfunc1, 0.0, quadpack.Inf, args=(n,eta,beta,False))
return res[0]
def outerIntegral(x, i, lagrange):
ans, abserr = quad(innerIntegral, a=0, b=1 - x, args=(x, i, lagrange))
return ans
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 2 09:48:40 2018
@author: VP LAB
"""
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')
import numpy as np
from scipy.integrate.quadpack import quad
def func(x):
return np.array(2.0 * x**2 - x - 4.0)
x = np.linspace(0, 10, 100)
integral = quad(func, 1, 5)
section = np.linspace(1, 5, 20)
plt.plot(x, func(x))
plt.fill_between(section, func(section), facecolor='g')
def arclength(df_x, df_y, t):
integrand = lambda tau: np.sqrt(df_x(tau)**2 + df_y(tau)**2)
return quad(integrand, 0, t)[0]
