def newton_weights(x, newtonCotesOrder):
"""
Constructs the weights for a composite Newton-Cotes rule for integration.
These weights should be multipled by the step-size, equally spaced steps
are assumed. The argument x should be a numpy array of the x samples points.
If the order Newton-Cotes order specified does not produce a rule that fits
into len(x), the order is decremented and that is used to fill gaps that do no fit.
"""
# ensure we have a 1xN array
x = np.array(x).squeeze()
if newtonCotesOrder == 0:
return np.ones(x.shape)
W = newton_cotes(newtonCotesOrder, 1)[0]
wx = np.zeros(x.shape, dtype=np.float64)
N = len(W)
i = 0
while i < len(x) - 1:
try:
wx[i:(i + len(W))] += W
i += len(W) - 1
except ValueError as ex:
if len(wx[i:(i + len(W))]) < len(W):
newtonCotesOrder -= 1
W = newton_cotes(newtonCotesOrder, 1)[0]
return wx
def newtonCotes(inf, sup, h, func):
"""
nc's algorithms's tests
"""
nc1 = nc.trapeze(inf, sup, h, func)
nc2 = nc.simpson_1_3(inf, sup, h, func)
nc3 = nc.simpson_3_8(inf, sup, h, func)
nc4 = nc.villarceau(inf, sup, h, func)
print("trapeze :", nc1, "simpson 1/3 :", nc2)
print("simpson 3/8 :", nc3, "villarceau :", nc4)
# Use of integrate
somme = [0, 0, 0, 0]
x = inf
N = int(abs(sup - inf) / h)
for i in range(0, N):
for n in range(1, 5):
y = np.linspace(x, x + h, n + 1)
an, B = integrate.newton_cotes(n, 1)
dy = h / n
quad = dy * np.sum(an * func(y))
somme[n - 1] += quad
x += h
for result in somme:
print('{:10.9f}'.format(result))
def mynewton_cotes(x, f) :
if x.shape[0] < 2 :
return 0
rn = (x.shape[0] - 1) * (x - x[0]) / (x[-1] - x[0])
#weights = scipy.integrate.newton_cotes(rn)[0]
weights = newton_cotes(rn)[0]
return (x[-1] - x[0]) / (x.shape[0] - 1) * np.dot(weights, f)
def test_newton_cotes2(self):
"""Test newton_cotes with points that are not evenly spaced."""
x = np.array([0.0, 1.5, 2.0])
y = x**2
wts, errcoff = newton_cotes(x)
exact_integral = 8.0/3
numeric_integral = np.dot(wts, y)
assert_almost_equal(numeric_integral, exact_integral)
x = np.array([0.0, 1.4, 2.1, 3.0])
y = x**2
wts, errcoff = newton_cotes(x)
exact_integral = 9.0
numeric_integral = np.dot(wts, y)
assert_almost_equal(numeric_integral, exact_integral)
def _newton_cotes(order, lower, upper, segments=1, growth=False):
"""Backend for Newton-Cotes quadrature rule."""
if order == 0:
return numpy.array([0.5 * (lower + upper)]), numpy.ones(1)
order = 2**order if growth else order
if segments != 1 and order > 2:
segments = segments if segments else int(numpy.sqrt(order))
assert segments < order, "fewer samples to distribute than intervals"
abscissas = []
weights = []
nodes = numpy.linspace(0, 1, segments + 1)
for lower, upper in zip(nodes[:-1], nodes[1:]):
abscissa, weight = _newton_cotes(order // segments, lower, upper)
weight = weight * (upper - lower)
if abscissas:
weights[-1] += weight[0]
abscissa = abscissa[1:]
weight = weight[1:]
abscissas.extend(abscissa)
weights.extend(weight)
assert len(abscissas) == order + 1
assert len(weights) == order + 1
return numpy.array(abscissas), numpy.array(weights)
return (
numpy.linspace(lower, upper, order + 1),
newton_cotes(order)[0] / (upper - lower) / order,
)
def test_newton_cotes2(self):
"""Test newton_cotes with points that are not evenly spaced."""
x = np.array([0.0, 1.5, 2.0])
y = x**2
wts, errcoff = newton_cotes(x)
exact_integral = 8.0/3
numeric_integral = np.dot(wts, y)
assert_almost_equal(numeric_integral, exact_integral)
x = np.array([0.0, 1.4, 2.1, 3.0])
y = x**2
wts, errcoff = newton_cotes(x)
exact_integral = 9.0
numeric_integral = np.dot(wts, y)
assert_almost_equal(numeric_integral, exact_integral)
def _newton_cotes(order, lower, upper, growth):
"""Backend for Newton-Cotes quadrature rule."""
if order == 0:
return numpy.array([0.5*(lower+upper)]), numpy.ones(1)
order = 2**order if growth else order
return (
numpy.linspace(lower, upper, order+1),
newton_cotes(order)[0]/(upper-lower),
)
def newton_cotes(x, f):
if x.shape[0] < 2:
return 0
rn = (x.shape[0]-1)*(x-x[0])/(x[-1]-x[0])
# Just making sure ...
rn[0]= 0
rn[-1]= len(rn)-1
weights= integrate.newton_cotes(rn)[0]
return (x[-1]-x[0])/(x.shape[0]-1)*numpy.dot(weights,f)
def newton_cotes(x, f):
if x.shape[0] < 2:
return 0
rn = (x.shape[0] - 1) * (x - x[0]) / (x[-1] - x[0])
# Just making sure ...
rn[0] = 0
rn[-1] = len(rn) - 1
weights = integrate.newton_cotes(rn)[0]
return (x[-1] - x[0]) / (x.shape[0] - 1) * numpy.dot(weights, f)
def integrate_newton_cotes(func, a, b):
N = 9
X = numpy.linspace(a, b, N)
A, B = integrate.newton_cotes(N - 1)
result = 0
for i in range(N):
result += A[i] * func(X[i])
result *= (b - a) / (N - 1)
return result
def test_newton_cotes(self):
"""Test the first few degrees, for evenly spaced points."""
n = 1
wts, errcoff = newton_cotes(n, 1)
assert_equal(wts, n*np.array([0.5, 0.5]))
assert_almost_equal(errcoff, -n**3/12.0)
n = 2
wts, errcoff = newton_cotes(n, 1)
assert_almost_equal(wts, n*np.array([1.0, 4.0, 1.0])/6.0)
assert_almost_equal(errcoff, -n**5/2880.0)
n = 3
wts, errcoff = newton_cotes(n, 1)
assert_almost_equal(wts, n*np.array([1.0, 3.0, 3.0, 1.0])/8.0)
assert_almost_equal(errcoff, -n**5/6480.0)
n = 4
wts, errcoff = newton_cotes(n, 1)
assert_almost_equal(wts, n*np.array([7.0, 32.0, 12.0, 32.0, 7.0])/90.0)
assert_almost_equal(errcoff, -n**7/1935360.0)
def test_newton_cotes(self):
"""Test the first few degrees, for evenly spaced points."""
n = 1
wts, errcoff = newton_cotes(n, 1)
assert_equal(wts, n*np.array([0.5, 0.5]))
assert_almost_equal(errcoff, -n**3/12.0)
n = 2
wts, errcoff = newton_cotes(n, 1)
assert_almost_equal(wts, n*np.array([1.0, 4.0, 1.0])/6.0)
assert_almost_equal(errcoff, -n**5/2880.0)
n = 3
wts, errcoff = newton_cotes(n, 1)
assert_almost_equal(wts, n*np.array([1.0, 3.0, 3.0, 1.0])/8.0)
assert_almost_equal(errcoff, -n**5/6480.0)
n = 4
wts, errcoff = newton_cotes(n, 1)
assert_almost_equal(wts, n*np.array([7.0, 32.0, 12.0, 32.0, 7.0])/90.0)
assert_almost_equal(errcoff, -n**7/1935360.0)
def newton_cotes(x, f):
if x.shape[0] < 2:
return 0
rn = (x.shape[0] - 1) * (x - x[0]) / (x[-1] - x[0])
weights = integrate.newton_cotes(rn)[0]
"""
# I added this part for the last remaining non 5 points, it will only use the available points
lw, lf = len(weights), len(f)
if lw != lf:
last_weights = []
for i, fi in enumerate(f):
last_weights.append(weights[i])
weights = np.array(last_weights)
"""
dot_wf = np.dot(weights, f)
return (x[-1] - x[0]) / (x.shape[0] - 1) * dot_wf
def integrate_newton_cotes(func, a, b):
'''
Calculates an integral of `func`
for t = a..b via newton-cotes of order 9.
'''
# Количество точек используемых в формуле Ньютона-Котеса
N = 9
# the 9 sample points
X = numpy.linspace(a, b, N)
# get newton-cotes coefficients
# for the order N
A, B = integrate.newton_cotes(N - 1)
result = 0
for it in range(N):
result += A[it] * func(X[it])
# multiply by the average step
result *= (b - a) / (N - 1)
return result
def _newton_cotes(order):
"""Backend for Newton-Cotes quadrature rule."""
if order == 0:
return numpy.full((1, 1), 0.5), numpy.ones(1)
return numpy.linspace(0, 1,
order + 1), integrate.newton_cotes(order)[0] / order
def newton_cotes(x, f) :
if x.shape[0] < 2 :
return 0
rn = (x.shape[0] - 1) * (x - x[0]) / (x[-1] - x[0])
weights = integrate.newton_cotes(rn)[0]
return (x[-1] - x[0]) / (x.shape[0] - 1) * np.dot(weights, f)
def riemann_HG_knm(x,
y,
mode_in,
mode_out,
q1,
q2,
q1y=None,
q2y=None,
Axy=None,
cache=None,
delta=(0, 0),
params={},
newtonCotesOrder=0):
if Axy is None:
Axy == np.ones((len(x), len(y)))
if q1y is None:
q1y = q1
if q2y is None:
q2y = q2
if len(mode_in) != 2 or len(mode_out) != 2:
raise BasePyKatException(
"Both mode in and out should be a container with modes [n m]")
dx = abs(x[1] - x[0])
dy = abs(y[1] - y[0])
if cache is None:
Hg_in = HG_mode(qx=q1, qy=q1y, n=mode_in[0], m=mode_in[1])
Hg_out = HG_mode(qx=q2, qy=q2y, n=mode_out[0], m=mode_out[1])
U1 = Hg_in.Unm(x + delta[0], y + delta[1])
U2 = Hg_out.Unm(x, y).conjugate()
if newtonCotesOrder > 0:
W = newton_cotes(newtonCotesOrder, 1)[0]
if newtonCotesOrder > 1:
if (len(x) - len(W)) % newtonCotesOrder != 0:
raise ValueError(
"To use Newton-Cotes order {0} the number of data points in x must ensure: (N_x - ({0}+1)) mod {0} == 0"
.format(newtonCotesOrder))
if (len(y) - len(W)) % newtonCotesOrder != 0:
raise ValueError(
"To use Newton-Cotes order {0} the number of data points in y must ensure: (N_y - ({0}+1)) mod {0} == 0"
.format(newtonCotesOrder))
wx = np.zeros(x.shape, dtype=np.float64)
wy = np.zeros(y.shape, dtype=np.float64)
N = len(W)
for i in range(0, (len(wx) - 1) / newtonCotesOrder):
wx[(i * (N - 1)):(i * (N - 1) + N)] += W
for i in range(0, (len(wy) - 1) / newtonCotesOrder):
wy[(i * (N - 1)):(i * (N - 1) + N)] += W
Wxy = np.outer(wx, wy)
if newtonCotesOrder == 0:
return dx * dy * np.einsum('ij,ij', Axy, U1 * U2)
else:
return dx * dy * np.einsum('ij,ij', Axy, U1 * U2 * Wxy)
else:
strx = "u1[%i,%i]" % (mode_in[0], mode_out[0])
stry = "u2[%i,%i]" % (mode_in[1], mode_out[1])
return dx * dy * np.einsum('ij,ij', Axy,
np.outer(cache[strx], cache[stry]))
