shenfun.optimization package

Submodules

shenfun.optimization.cython module

chebval(x, c)
convolve_1D(u, v, uv, k)
convolve_real_1D(u, v, uv, k)
evaluate_2D(b, u, P, r2c, M, start)
evaluate_3D(b, u, P, r2c, M, start)
evaluate_lm_2D(bases, b, u, x0, x1, w0, w1, r2c, M, start)
evaluate_lm_3D(bases, b, u, x0, x1, x2, w0, w1, w2, r2c, M, start)
Biharmonic_Solve(b, u, u0, u1, u2, l0, l1, ak, bk, a0, axis=0)
Biharmonic_factor_oe_pr(odd, a, b, l0, l1)
Biharmonic_factor_pr(a, b, l0, l1, axis)
Biharmonic_factor_pr_1D(a, b, l0, l1)
Biharmonic_factor_pr_2D(axis, a, b, l0, l1)
Biharmonic_factor_pr_3D(axis, a, b, l0, l1)
DiagMA_Solve(u, data, axis)
DiagMA_Solve_2D(u, data, axis)
DiagMA_Solve_3D(u, data, axis)
DiagMA_inner_solve(u, data)
FDMA_LU(data)
FDMA_Solve(u, data, axis)
FDMA_inner_solve(u, data)
HeptaDMA_LU(data)
HeptaDMA_Solve(u, data, axis)
HeptaDMA_inner_solve(u, data)
LU_Biharmonic(a0, alfa, beta, sii, siu, siuu, ail, aii, aiu, bill, bil, bii, biu, biuu, u0, u1, u2, l0, l1, axis)
LU_Biharmonic_1D(a, b, c, sii, siu, siuu, ail, aii, aiu, bill, bil, bii, biu, biuu, u0, u1, u2, l0, l1)
LU_Biharmonic_2D_n(axis, alfa, beta, ceta, sii, siu, siuu, ail, aii, aiu, bill, bil, bii, biu, biuu, u0, u1, u2, l0, l1)
LU_Biharmonic_3D_n(axis, alfa, beta, ceta, sii, siu, siuu, ail, aii, aiu, bill, bil, bii, biu, biuu, u0, u1, u2, l0, l1)
LU_Helmholtz(A, B, A_s, B_s, neumann, d0, d1, d2, L, axis)
LU_Helmholtz_1D(A, B, A_scale, B_scale, neumann, d0, d1, d2, L)
LU_Helmholtz_2D(A, B, axis, A_scale, B_scale, neumann, d0, d1, d2, L)
LU_Helmholtz_3D(A, B, axis, A_scale, B_scale, neumann, d0, d1, d2, L)
LU_oe_Biharmonic_1D(odd, a, b, c, sii, siu, siuu, ail, aii, aiu, bill, bil, bii, biu, biuu, u0, u1, u2, l0, l1)
PDMA_LU(data)
PDMA_Solve(u, data, axis)
PDMA_inner_solve(u, data)
Poisson_Solve_ADD(A, b, u, axis=0)
Poisson_Solve_ADD_2D_ptr(d, d1, scale, b, u, axis)
Poisson_Solve_ADD_3D_ptr(d, d1, scale, b, u, axis)
Solve_Biharmonic_1D(fk, uk, u0, u1, u2, l0, l1, a, b, ac)
Solve_Biharmonic_2D_n(axis, fk, uk, u0, u1, u2, l0, l1, a, b, a0)
Solve_Biharmonic_3D_n(axis, fk, uk, u0, u1, u2, l0, l1, a, b, a0)
Solve_Helmholtz(b, u, neumann, d0, d1, d2, L, axis)
Solve_Helmholtz_1D(fk, u_hat, neumann, d0, d1, d2, L)
Solve_Helmholtz_2D_ptr(axis, fk, u_hat, neumann, d0, d1, d2, L)
Solve_Helmholtz_3D_ptr(axis, fk, u_hat, neumann, d0, d1, d2, L)
Solve_oe_Biharmonic_1D(odd, fk, uk, u0, u1, u2, l0, l1, a, b, ac)

Solve (aS+b*A+cB)x = f, where S, A and B are 4th order Laplace, stiffness and mass matrices of Shen with Dirichlet BC

SolverGeneric1ND_solve_data(u, data, sol, naxes, is_zero_index)
TDMA_LU(data)
TDMA_O_LU(data)
TDMA_O_Solve(u, data, axis)
TDMA_O_inner_solve(u, data)
TDMA_Solve(u, data, axis)
TDMA_inner_solve(u, data)
ThreeDMA_Solve(u, data, axis)
ThreeDMA_inner_solve(u, data)
TwoDMA_Solve(u, data, axis)
TwoDMA_inner_solve(u, data)
ADD_matvec(v, b, axis, dd)
ATT_matvec(v, b, axis)
BBD_matvec(v, b, axis, ld, dd, ud, uud)
BDN_matvec(v, b, axis, ld, dd, ud)
Biharmonic_matvec(v, b, a0, alfa, beta, sii, siu, siuu, ail, aii, aiu, bill, bil, bii, biu, biuu, axis=0)
CBD_matvec(v, b, axis, ld, ud, udd)
CDB_matvec(v, b, axis, lld, ld, ud)
CDD_matvec(v, b, axis, ld, ud)
CDN_matvec(v, b, axis, ld, ud)
CLL_matvec(v, b, axis)
CTSD_matvec(v, b, axis)
CTT_matvec(v, b, axis)
GLL_matvec(v, b, axis)
Helmholtz_Neumann_matvec(v, b, alfa, beta, A, B, axis)
Helmholtz_matvec(v, b, alfa, beta, A, B, axis)
Pentadiagonal_matvec(v, b, axis, ldd, ld, dd, ud, udd)
SBB_matvec(v, b, axis, dd)
Tridiagonal_matvec(v, b, axis, ld, dd, ud)
imult(array, scale)
FMMcheb(input_array, output_array, axis, Nn, A, Nk, T, Th, ThT, D, Mmin, s, diags, trans)
FMMdirect1(input_array, output_array, axis, a, n0, trans)
FMMdirect2(input_array, output_array, axis, a, h, Nd, n0, trans)
FMMdirect3(input_array, output_array, axis, dn, a, h, Nd, n0)
FMMdirect4(input_array, output_array, axis, dn, a, n0)
Lambda(x)

Return

\[\Lambda(x) =\]

rac{Gamma(x+ rac{1}{2})}{Gamma(x+1)}

x : array of floats

cheb2leg(input_array, output_array, axis=0)
chebval(x, u)
evaluate_expansion_all(input_array, output_array, x, axis, a)
leg2cheb(input_array, output_array, axis=0, transpose=0)
normf(u)
restricted_product(L, input_array, output_array, x, i0, i1, a0, axis, a)
scalar_product(input_array, output_array, x, w, axis, a)

shenfun.optimization.numba module

apply_bmask_1D(u, mask)[source]
apply_bmask_2D(u, mask)[source]
apply_bmask_3D(u, mask)[source]
apply_bmask_4D(u, mask)[source]
apply_bxmask(u_hat, mask)[source]
apply_mask(u_hat, mask)[source]
apply_mask_1D(u, mask)[source]
apply_mask_2D(u, mask)[source]
apply_mask_3D(u, mask)[source]
apply_mask_4D(u, mask)[source]
cross2D(c, a, b)[source]
cross3D(c, a, b)[source]
crossND(c, a, b)[source]
outer2D(a, b, c, symmetric)[source]
outer3D(a, b, c, symmetric)[source]
Biharmonic_Solve(b, u, u0, u1, u2, l0, l1, ak, bk, a0, axis=0)[source]
Biharmonic_factor_pr(a, b, l0, l1, axis)[source]
Biharmonic_matvec(v, b, a0, alfa, beta, sii, siu, siuu, ail, aii, aiu, bill, bil, bii, biu, biuu, axis)[source]
LU_Biharmonic(a0, alfa, beta, sii, siu, siuu, ail, aii, aiu, bill, bil, bii, biu, biuu, u0, u1, u2, l0, l1, axis)[source]
ANN_matvec(v, b, A, axis=0)[source]
Helmholtz_Neumann_matvec(v, b, alfa, beta, A, B, axis)[source]
Helmholtz_matvec(v, b, alfa, beta, A, B, axis)[source]
LU_Helmholtz(A, B, A_s, B_s, neumann, d0, d1, d2, L, axis)[source]
Poisson_Solve_ADD(A, b, u, axis=0)[source]
Poisson_Solve_ADD_1D(d, d1, scale, b, u)[source]
Solve_Helmholtz(b, u, neumann, d0, d1, d2, L, axis)[source]
PDMA_LU(data)[source]

LU decomposition

PDMA_Solve(x, data, axis=0)[source]
PDMA_inner_solve(u, data)[source]
TDMA_LU(data)[source]
TDMA_O_LU(data)[source]
TDMA_O_Solve(x, data, axis=0)[source]
TDMA_O_inner_solve(u, data)[source]
TDMA_Solve(x, data, axis=0)[source]
TDMA_inner_solve(u, data)[source]
ThreeDMA_Solve(x, data, axis=0)[source]
ThreeDMA_inner_solve(u, data)[source]
TwoDMA_Solve(x, data, axis=0)[source]
TwoDMA_inner_solve(u, data)[source]
DiagMA_Solve(x, data, axis=0)[source]
DiagMA_inner_solve(u, data)[source]
FDMA_LU(data)[source]
FDMA_Solve(x, data, axis=0)[source]
FDMA_inner_solve(u, data)[source]
FMMdirect1(u, v, a, n0, trans)[source]
FMMdirect2(u, v, a, h, Nd, n0, trans)[source]
FMMdirect3(u, v, dn, a, h, Nd, n0)[source]
FMMdirect4(u, v, dn, a, n0)[source]
cheb2leg(input_array, output_array=None, axis=0)[source]
evaluate_expansion_all(input_array, output_array, x, axis, a)[source]
leg2cheb(input_array, output_array=None, axis=0, transpose=False)[source]
restricted_product(space, input_array, output_array, x, i0, i1, a0, axis, a)[source]
scalar_product(input_array, output_array, x, w, axis, a)[source]

Module contents

Module for optimized functions

Some methods performed in Python may be slowing down solvers. In this optimization module we place optimized functions that are to be used instead of default Python methods. Some methods are implemented solely in Cython and only called from within the regular Python modules.

class runtimeoptimizer(func)[source]

Bases: object

optimizer(func, wrap=True)[source]

Decorator used to wrap calls to optimized versions of functions.

The optimized version must be implemented in the cython or numba modules. For example, the la.TDMA linear algebra solver has a method called Solve(), which is implemented with faster (optimized) code in TDMA_Solve() and TDMA_Solve().

Parameters:

  • func (The function to optimize)

  • wrap (bool, optional) – If True, return function wrapped using functools wraps. If False, return unwrapped function.