specnn4pde 0.0.1__py3-none-any.whl

specnn4pde/linalg.py

@@ -0,0 +1,57 @@
+__all__ = ['ROU_cholesky',
+           ]
+
+import numpy as np
+
+def ROU_cholesky(L, v, alpha=1, beta=1):
+    """
+    Perform a rank-one update of the Cholesky decomposition of a matrix.
+
+    Parameters
+    ----------
+    L : ndarray
+        The lower triangular Cholesky factor of the matrix A.
+    alpha : float
+        The scalar multiplier for the matrix. Must be non-negative.
+    beta : float
+        The scalar multiplier for the outer product of v. Must be non-negative.
+    v : ndarray
+        The vector used for the rank-one update.
+
+    Returns
+    ----------
+    L_prime : ndarray
+        The updated lower triangular Cholesky factor of the matrix
+         \tilde{A} = alpha * A + beta * v * v^T.
+
+    References
+    ----------
+    1. https://en.wikipedia.org/wiki/Cholesky_decomposition#Rank-one_update
+    2. Krause Oswin, Igel ChristianA, 2015, 
+        More Efficient Rank-one Covariance Matrix Update for Evolution Strategies,
+        https://christian-igel.github.io/paper/AMERCMAUfES.pdf
+
+    Example
+    ----------
+    >>> L = np.array([[1, 0, 0], [2, 1, 0], [3, 2, 1]])
+    >>> alpha = 2
+    >>> beta = 3
+    >>> v = np.array([1, 2, 3])
+    >>> L_prime = ROU_cholesky(L, v, alpha, beta)
+    >>> print(L_prime)
+    """
+
+    if alpha < 0 or beta < 0:
+        raise ValueError("alpha and beta must be non-negative")
+    
+    n = L.shape[0]
+    L, x = np.sqrt(alpha) * L, np.sqrt(beta) * v
+    for k in range(n):
+        r = np.sqrt(L[k, k]**2 + x[k]**2)
+        c = r / L[k, k]
+        s = x[k] / L[k, k]
+        L[k, k] = r
+        if k < n - 1:
+            L[(k+1):n, k] = (L[(k+1):n, k] + s * x[(k+1):n]) / c
+            x[(k+1):n] = c * x[(k+1):n] - s * L[(k+1):n, k]
+    return L

specnn4pde/npde.py

@@ -0,0 +1,338 @@
+__all__ = ['gradients', 'Jacobian', 'partial_derivative', 'partial_derivative_vector', 
+           'meshgrid_to_matrix', 'gen_collo',
+           ]
+
+import torch
+from torch.autograd.functional import jacobian
+
+
+def gradients(u, x, order=1, retain_graph=False):
+    """
+    Compute the gradients for d dimensional function. It only supports two kinds of functions:
+
+    1. scalar function f(x1, x2, ..., xd)
+        The first order gradients are [df/dx1, df/dx2, ..., df/dxd]
+    2. vector function like F(x1,x2,...,xd) = [f1(x1), f2(x2), ..., fd(xd)]
+        The first order gradients are [df1/dx1, df2/dx2, ..., dfn/dxd]
+
+    Higher order gradients are also supported.
+
+    !!! For functions like F(x1, ..., xd) = [f1(x1, ..., xd), ..., fd(x1, ..., xd)], 
+        use `partial_derivative_vector` instead.
+
+    Parameters
+    ----------
+    u : tensor
+        The values of the function at the point x.
+    x : Tensor, shape (n, d)
+        The point at which to compute the gradients, where n is the number of points and d is the dimension.
+    order : int, optional
+        The order of the gradients. The default is 1.
+    retain_graph : bool, optional
+        Whether to retain the computational graph for further computation. Defaults to False.
+
+    Returns
+    ----------
+    grads: list of tensors of shape like x
+        The gradients up to the order. grads[i] is the (i+1)-th order gradients.
+
+    Example
+    ----------
+    >>> def f(x):
+    ...     return x**2
+    >>> x = torch.tensor([[1.0, 2], [3, 4], [5, 6]], requires_grad=True)
+    >>> u = f(x)
+    >>> gradients(u, x, 2)
+    [tensor([[ 2.,  4.],
+             [ 6.,  8.],
+             [10., 12.]]),
+     tensor([[2., 2.],
+             [2., 2.],
+             [2., 2.]])]
+    """
+
+    grads = [torch.autograd.grad(u, x, grad_outputs=torch.ones_like(u), create_graph=True)[0]]
+    for _ in range(1, order):
+        grads.append(torch.autograd.grad(grads[-1], x, grad_outputs=torch.ones_like(grads[-1]), create_graph=True)[0])
+    # clean the computational graph of the gradients to save memory
+    if not retain_graph:
+        grads = [g.detach() for g in grads]
+    return grads
+
+
+def Jacobian(f, x, order=1, create_graph=False):
+    """
+    Compute the Jacobian of a vector function.
+    But only support univariate function. For multivariate vector function, 
+    use `partial_derivative_vector` instead.
+
+    !!! Not suitale for high order derivatives, because
+        creating computational graphs will consume a lot of time and memory.
+
+    Parameters
+    ----------
+    f : function
+        The function to compute the Jacobian for.
+    x : Tensor
+        The point at which to compute the Jacobian.
+    order : int, optional
+        The order of the derivative. Defaults to 1.
+    create_graph : bool, optional
+        Whether to create a computational graph. Defaults to False.
+
+    Returns
+    ----------
+    Tensor
+        The Jacobian of the function at the given point.
+
+    Example
+    ----------
+    >>> def f(x):
+    ...     return torch.cat([x, x**2], dim=1)
+    >>> x = torch.tensor([[1.0], [2], [3]])
+    >>> Jacobian(f, x)
+    tensor([[1., 2.],
+            [1., 4.],
+            [1., 6.]])
+    """
+
+    def _f(*args, **kwargs):
+        return f(*args, **kwargs).sum(dim=0)
+    if order == 0:
+        return f(x) if create_graph else f(x).detach()
+    elif order == 1:
+        return jacobian(_f, x, create_graph).squeeze(2).T
+    else:
+        def _jacobian(x):
+            return jacobian(_f, x, True).squeeze(2).T
+        return Jacobian(_jacobian, x, order-1, create_graph)
+
+def partial_derivative(F, X, Alpha, create_graph=False):
+    """
+    Compute the partial derivative for vector-valued function but inefficient, 
+    use `partial_derivative_vector` instead.
+
+    !!! Not suitale for high order derivatives, because
+        creating computational graphs will consume a lot of time and memory.    
+
+    Parameters
+    ----------
+    F : function
+        The function to compute the partial derivative for.
+    X : Tensor
+        The points at which to compute the partial derivative.
+    Alpha : list
+        The order of the derivative for each dimension.
+    create_graph : bool, optional
+        Whether to create a computational graph. Defaults to False.
+
+    Returns
+    ----------
+    Tensor
+        The partial derivative of the function at the given points.
+    """
+
+    if len(Alpha) == 1:
+        return Jacobian(F, X, Alpha[0], create_graph)
+    else:
+        X_perfix, x_last = X[:, :-1], X[:, -1:]
+        def _f(x):
+            def _F(X):
+                return F(torch.cat([X, x], dim=1))
+            return partial_derivative(_F, X_perfix, Alpha[:-1], True)
+        return Jacobian(_f, x_last, Alpha[-1], create_graph)
+
+def partial_derivative_vector(F, X, Alpha, create_graph=False, batch_size=[15000,1]):
+    """
+    Compute the partial derivatives for vector-valued function 
+    F(x1, x2, ..., xn) = [f1(x1, x2, ..., xn), f2(x1, x2, ..., xn), ..., fk(x1, x2, ..., xn)],
+    return [\partial^\alpha f1, \partial^\alpha f2, ..., \partial^\alpha fn].
+
+    !!! Not suitale for high order derivatives, because
+        creating computational graphs will consume a lot of time and memory.
+
+    Parameters
+    ----------
+    F : function
+        The function to compute the partial derivatives for.
+    X : tensor, shape (N, d)
+        The points at which to compute the partial derivatives, where N is the number of points and d is the dimension.
+    Alpha : list
+        The order of the derivative for each dimension.
+    create_graph : bool, optional
+        Whether to create a computational graph. Defaults to False.
+    batch_size : list, optional
+        The batch size for computing the partial derivatives. 
+        batch_size[0] is the number of points in each batch, 
+        and batch_size[1] is the number of functions in each batch.
+        Defaults to [15000, 1].
+
+    Returns
+    ----------
+    Tensor, shape (k, N, d)
+        The partial derivatives of the function at the given points.
+
+    Example
+    ----------
+    >>> def F(X):
+    ...     return X.prod(dim=1).unsqueeze(dim=1).repeat(1, 2)
+    >>> X = torch.tensor([[1.0, 2], [3, 4]])
+    >>> partial_derivative_vector(F, X, Alpha = [1, 1])
+    tensor([[1., 1.],
+            [1., 1.]])
+    """
+
+    out_dim = F(X[:1]).shape[1]
+    res = []
+    for i in range(0, X.shape[0], batch_size[0]):
+        res_sub = []
+        for j in range(0, out_dim, batch_size[1]):
+            def _F(X): return F(X)[:, j:j+batch_size[1]]
+            res_sub.append(partial_derivative(_F, X[i:i+batch_size[0]], Alpha, create_graph))
+        res.append(torch.cat(res_sub, dim=1))
+    return torch.cat(res, dim=0)
+
+
+def meshgrid_to_matrix(inputs, indexing='xy'):
+    """
+    Convert the meshgrid to matrix.
+
+    Parameters
+    ----------
+    inputs : list of iterables, length d
+        The grid points in each dimension.
+    indexing : str, optional
+        The indexing of the meshgrid. The default is 'xy'.
+        The options are 'xy' and 'ij', the same as numpy.meshgrid and torch.meshgrid.
+
+    Returns
+    ----------
+    tensor, shape ( n1*n2*...*nd, d)
+        The matrix of the grid points, ni is the number of grid points in the i-th dimension.
+
+    Example
+    ----------
+    >>> x = torch.linspace(1, 2, 3)
+    >>> y = torch.linspace(4, 5, 3)
+    >>> meshgrid_to_matrix([x, y], indexing='xy')
+    tensor([[1.0000, 4.0000],
+            [1.5000, 4.0000],
+            [2.0000, 4.0000],
+            [1.0000, 4.5000],
+            [1.5000, 4.5000],
+            [2.0000, 4.5000],
+            [1.0000, 5.0000],
+            [1.5000, 5.0000],
+            [2.0000, 5.0000]])
+    >>> meshgrid_to_matrix([x, y], indexing='ij')
+    tensor([[1.0000, 4.0000],
+            [1.0000, 4.5000],
+            [1.0000, 5.0000],
+            [1.5000, 4.0000],
+            [1.5000, 4.5000],
+            [1.5000, 5.0000],
+            [2.0000, 4.0000],
+            [2.0000, 4.5000],
+            [2.0000, 5.0000]])
+    """
+
+    Co = torch.meshgrid(*inputs, indexing=indexing)
+    return torch.cat([c.reshape(-1,1) for c in Co], dim=1)
+
+
+def gen_collo(Domain, grids, temporal = False, corner = True):
+    """
+    Generate the collocation points for the PDE problem on regular domain.
+    If Domain and grids are provided, the uniform grids will be generated automatically as G.
+    If Domain and grids are not provided, G should be provided.
+
+    Parameters
+    ----------
+    Domain : list of list, optional
+        The domain of the problem. eg. [[t_min, x1_min, x2_min, ...], [t_max, x1_max, x2_max, ...]]
+    grids : list, optional
+        The number of collocations in each dimension. eg. [N_t, N_x1, N_x2, ...]
+    temporal : bool, optional
+        If the problem is temporal. The default is False.
+    corner : bool, optional
+        If the collocation points include the corner points. The default is True.
+    G : list of tensor, optional
+        The tensors in the list are the collocation points in each dimension.
+        If Domain and grids are not provided, G should be provided.
+    
+    Returns
+    -------
+    collo_rs : tensor
+        The collocation points in the interior of the domain.
+    collo_ic : tensor, optional
+        If temporal is set as True. The collocation points on the initial condition.
+    collo_bc : tensor
+        The collocation points on the boundary condition.
+
+    Example
+    ----------
+    >>> domian = [[0, 0, 1], [2, 3, 4]]
+    >>> grids = [3, 4, 5]
+    >>> gen_collo(domian, grids)
+    (tensor([[1.0000, 1.0000, 1.7500],
+             [1.0000, 1.0000, 2.5000],
+             [1.0000, 1.0000, 3.2500],
+             [1.0000, 2.0000, 1.7500],
+             [1.0000, 2.0000, 2.5000],
+             [1.0000, 2.0000, 3.2500]]),
+     tensor([[0.0000, 0.0000, 1.0000],
+             [0.0000, 0.0000, 1.7500],
+             [0.0000, 0.0000, 2.5000],
+             [0.0000, 0.0000, 3.2500],
+             [0.0000, 0.0000, 4.0000],
+             [2.0000, 0.0000, 1.0000],
+             ......
+             [1.0000, 1.0000, 4.0000],
+             [1.0000, 2.0000, 1.0000],
+             [1.0000, 2.0000, 4.0000]]))
+    """
+
+    if G is None:
+        dim = len(Domain[0])
+        if len(grids) != dim:
+            if len(grids) == 1:
+                Warning("The number of grids is set as the same for all dimensions.")
+                grids = grids * dim
+            else:
+                raise ValueError("The length of grids should be equal to the dimension of the domain.")
+        G = [torch.linspace(l, r, n) for l, r, n in zip(*(Domain + [grids]))]
+    dim = len(G)
+    if temporal:
+        G_rs = [G[0][1:]] + [G[i][1:-1] for i in range(1, dim)]
+        G_ic = [G[0][0]] + G[1:]
+        collo_rs = meshgrid_to_matrix(G_rs)
+        collo_ic = meshgrid_to_matrix(G_ic)
+        collo_bc = []
+        for i in range(1, dim):
+            G_bc = [G[0]]
+            for j in range(1, dim):
+                if j < i:
+                    G_bc.append(G[j][1:-1])
+                elif j == i:
+                    G_bc.append(G[j][[0,-1]])
+                else:
+                    G_bc.append(G[j] if corner else G[j][1:-1])
+            collo_bc.append(meshgrid_to_matrix(G_bc))
+        collo_bc = torch.cat(collo_bc, dim=0)
+        return collo_rs, collo_ic, collo_bc
+    else:
+        G_rs = [G[i][1:-1] for i in range(dim)]
+        collo_rs = meshgrid_to_matrix(G_rs)
+        collo_bc = []
+        for i in range(dim):
+            G_bc = []
+            for j in range(dim):
+                if j < i:
+                    G_bc.append(G[j][1:-1])
+                elif j == i:
+                    G_bc.append(G[j][[0,-1]])
+                else:
+                    G_bc.append(G[j] if corner else G[j][1:-1])
+            collo_bc.append(meshgrid_to_matrix(G_bc))
+        collo_bc = torch.cat(collo_bc, dim=0)
+        return collo_rs, collo_bc

specnn4pde/spectral.py

@@ -0,0 +1,464 @@
+__all__ = ['JacobiP', 'Jacobi_Gauss', 'Jacobi_Gauss_Lobatto', 
+           'HermiteP', 'HermiteF', 'Hermite_Gauss', 'mapped_Jacobi_Gauss',
+           'glue1D', 'glue_pts_1D',
+           ]
+
+"""
+spectral.py
+
+This module provides functions for working with spectral methods.
+The implementation is mainly based on the book: 
+    Shen, J., Tang, T. & Wang, L.-L. Spectral Methods: Algorithms, 
+    Analysis and Applications. vol. 41 (Springer Science & Business 
+    Media, 2011).
+    https://link.springer.com/book/10.1007/978-3-540-71041-7
+"""
+
+import numpy as np
+from scipy.special import roots_hermite, gamma
+from scipy.sparse import diags, eye, lil_matrix, csr_matrix
+from scipy.linalg import eigh, block_diag
+from sympy import symbols, sqrt, atanh, tanh, sinh, log, lambdify, diff
+
+def JacobiP(x, alpha, beta, N):
+    """
+    This function evaluates the orthonormal Jacobi polynomial of order 
+    up to N with parameters alpha and beta at points x.
+    
+    Parameters
+    ----------
+    x : array
+        Points at which the Jacobi polynomial is to be computed.
+    alpha : float
+        The alpha parameter of the Jacobi polynomial. Must be greater than -1.
+    beta : float
+        The beta parameter of the Jacobi polynomial. Must be greater than -1.
+    N : int
+        The order of the Jacobi polynomial.
+
+    Returns
+    ----------
+    PL: ndarray, shape (N + 1, len(x))
+        The N-th row of PL is the values of orthonormal Jacobi 
+        polynomial J_{N}^{alpha, beta}(x) / sqrt(gamma_{N}^{alpha, beta}).
+
+    References:
+    ----------
+    1. Spectral Method P74
+    2. Code-reproduction/Poisson-GPU.ipynb
+    """
+
+    xp = x.copy()
+    if len(xp.shape) == 2 and xp.shape[1] == 1:
+        xp = xp.T
+    PL = np.zeros((N + 1, max(xp.shape)))
+    gamma0 = np.power(2, alpha + beta + 1) * gamma(alpha + 1) * gamma(beta + 1) / gamma(alpha + beta + 2)
+    PL[0] = 1.0 / np.sqrt(gamma0)
+    if N == 0:
+        return PL.T
+    gamma1 = (alpha + 1) * (beta + 1) / (alpha + beta + 3) * gamma0
+    PL[1] = ((alpha + beta + 2) * xp / 2 + (alpha - beta) / 2) / np.sqrt(gamma1)
+    aold = 2 / (2 + alpha + beta) * np.sqrt((alpha + 1) * (beta + 1) / (alpha + beta + 3))
+    for i in range(1, N):
+        h1 = 2 * i + alpha + beta
+        anew = 2 / (h1 + 2) * np.sqrt((i + 1) * (i + 1 + alpha + beta) * (i + 1 + alpha) * (i + 1 + beta) / (h1 + 1) / (h1 + 3))
+        bnew = -(alpha * alpha - beta * beta) / h1 / (h1 + 2)
+        PL[i + 1] = 1 / anew * (-aold * PL[i - 1] + (xp - bnew) * PL[i])
+        aold = anew
+    return PL
+
+def Jacobi_Gauss(alpha, beta, N):
+    """
+    This function computes the Gauss Jacobi quadrature first order 
+    derivative matrix, nodes and weights of Jacobi polynomial J_{N}^{alpha, beta}.
+
+    Parameters
+    ----------
+    alpha : float
+        The alpha parameter of the Gauss Jacobi quadrature. alpha > -1.
+    beta : float
+        The beta parameter of the Gauss Jacobi quadrature. beta > -1.
+        If alpha = beta = 0, the Jacobi polynomial is Legendre polynomial.
+    N : int
+        The order of the Gauss Jacobi quadrature.
+
+    Returns
+    ----------
+    D: ndarray, shape (N, N)
+        The first order derivative matrix of the Gauss Jacobi quadrature.
+    r: ndarray, shape (N,)
+        The Gauss Jacobi quadrature nodes.
+    w: ndarray, shape (N,)
+        The Gauss Jacobi quadrature weights.
+
+    References
+    ----------
+    1. Spectral Method P84
+    """
+
+    if N == 1:
+        D = np.zeros((1,1))
+        r = np.array([-(alpha - beta) / (alpha + beta + 2)])
+        w = np.array([2])
+        return D, r, w
+    
+    h1 = 2.0 * np.arange(N) + alpha + beta
+    h11, h12, h13 = h1 + 1, h1 + 2, h1 + 3
+    h2 = 1.0 * np.arange(1, N)
+    # Adjust h1, h11, h12 values based on alpha and beta
+    # to avoid division by zero
+    if abs(alpha + beta) < 10 * np.finfo(float).eps:
+        h1[0] = 1.0
+    elif abs(alpha + beta + 1) < 10 * np.finfo(float).eps:
+        h11[0] = 1.0
+    elif abs(alpha + beta + 2) < 10 * np.finfo(float).eps:
+        h1[1], h12[0] = 1.0, 1.0
+
+    # equation (3.142) symmetric tridiagonal matrix A_{N+1}
+    A = diags(0.5 * (beta**2 - alpha**2) / h12 / h1).toarray() + \
+        diags(2 / h12[:-1] * np.sqrt(h2 * (h2 + alpha + beta) * \
+        (h2 + alpha) * (h2 + beta) / h11[:-1] / h13[:-1]), 1).toarray()
+
+    r, V = eigh(A + A.T)
+    # equation (3.144)
+    w = np.power(V[0, :], 2) * np.power(2, alpha + beta + 1) * \
+        gamma(alpha + 1) * gamma(beta + 1) / gamma(alpha + beta + 2)
+    
+    l = JacobiP(r, alpha + 1, alpha + 1, N - 1)[-1]
+    # construct first order JG derivative matrix D by equation (3.164)
+    Distance = r[:, None] - r[None, :] + np.eye(N)
+    D = l[:, None] / l[None, :] / Distance
+    np.fill_diagonal(D, 0)
+
+    # for program stability, we force row sum of D to be 0
+    # which ensure the derivative of constants to be zero matrix
+    np.fill_diagonal(D, -np.sum(D, axis=1))
+    return D, r, w
+
+
+def Jacobi_Gauss_Lobatto(alpha, beta, N):
+    """
+    This function computes the Gauss-Lobatto quadrature first order
+    derivative matrix, nodes and weights of Jacobi polynomial J_{N}^{alpha, beta}.
+    The nodes are {-1, 1, zeros of dx(J_N^{alpha, beta}(x))}
+
+    Parameters
+    ----------
+    alpha : float
+        The alpha parameter of the Gauss-Lobatto quadrature. alpha > -1.
+    beta : float
+        The beta parameter of the Gauss-Lobatto quadrature. beta > -1.
+        If alpha = beta = 0, the Jacobi polynomial is Legendre polynomial.
+    N : int
+        The order of the Gauss-Lobatto quadrature.
+
+    Returns
+    ----------
+    D: ndarray, shape (N + 1, N + 1)
+        The first order derivative matrix of the Gauss-Lobatto quadrature.
+    r: ndarray, shape (N + 1,)
+        The Gauss-Lobatto quadrature nodes.
+    w: ndarray, shape (N + 1,)
+        The Gauss-Lobatto quadrature weights.
+
+    References
+    ----------
+    1. Spectral Method P83 
+    2. Code-reproduction/Poisson-GPU.ipynb
+    """
+
+    r = np.zeros((N + 1,))
+    r[0], r[-1] = -1.0, 1.0
+    w = np.zeros((N + 1,))
+    w[0] = (beta + 1) * gamma(beta + 1)**2
+    w[-1] = (alpha + 1) * gamma(alpha + 1)**2
+    
+    if N > 1:
+        # dx(J_N^{alpha, beta}(x)) = C(alpha, beta, N) * J_{N-1}^{alpha+1, beta+1}(x)
+        # thus have same zeros
+        r[1:-1] = Jacobi_Gauss(alpha + 1, beta + 1, N - 1)[1]
+        # equ(3.139)
+        cd = 2**(alpha + beta + 1) * gamma(N) / gamma(N + alpha + beta + 2)
+        md = gamma(N + alpha + 1) / gamma(N + beta + 1)
+        w[0] *= cd * md
+        w[-1] *= cd / md
+        w[1:-1] = (2 * N + alpha + beta + 1) / (1 - r[1:-1]**2)**2 / (N-1) / (N + alpha + beta + 2) / JacobiP(r[1:-1], alpha + 2, beta + 2, N - 2)[-1]**2
+        
+    # construct first order LGL derivative matrix D
+    Distance = r[:, None] - r[None, :] + np.eye(N + 1)
+    omega = np.prod(Distance, axis=1)
+    # equation (3.75)
+    D = diags(omega) @ (1 / Distance) @ diags(1 / omega)
+    # for program stability, we force row sum of D to be 0
+    # which ensure the derivative of constants to be zero matrix
+    np.fill_diagonal(D, 0)
+    np.fill_diagonal(D, -np.sum(D, axis=1))
+    return D, r, w
+
+
+def HermiteP(x, N, normalized=False, return_full=True):
+    """
+    Evaluate orthognormal Hermite polynomial of degree N at x by recurrence relation.
+
+    Parameters
+    ----------
+    x : ndarray
+        The input array.
+    N : int
+        The degree of Hermite polynomial.
+    normalized : bool, optional
+        Whether to normalize PL[N] to have L2 norm 1. Default is False.
+    return_full : bool, optional
+        Whether to return the full PL array. Default is True.
+
+    Returns
+    ----------
+    PL[N] or PL : ndarray, shape (N + 1, len(x))
+        The value of Hermite polynomial of degree N at x, or the full PL array if return_full is True.
+
+    References
+    ----------
+    Spectral Method P254
+    """
+    
+    xp = x.copy()
+    if len(xp.shape) == 2 and xp.shape[1] == 1:
+        xp = xp.T
+    PL = np.ones((N + 1, max(xp.shape)))
+    if normalized:
+        Norm = np.zeros(N + 1)
+        Norm[0] = np.linalg.norm(PL[0])
+    if N == 0:
+        return PL[0] / Norm[0] if normalized else PL[0]
+    PL[1] = 2 * xp
+    if normalized:
+        Norm[1] = np.linalg.norm(PL[1])
+    if N == 1 and normalized:
+        PL[0] /= Norm[0]
+    for i in range(1, N):
+        PL[i + 1] = 2 * xp * PL[i] - 2 * i * PL[i - 1]
+        if normalized:
+            if i == 1:
+                PL[0] /= Norm[0]
+            PL[i] /= Norm[i]
+            PL[i + 1] /= Norm[i]
+            Norm[i + 1] = np.linalg.norm(PL[i + 1])
+    if normalized:
+        PL[N] /= Norm[N]
+    return PL if return_full else PL[N]
+
+
+def HermiteF(x, N, return_full=True):
+    """
+    Evaluate modified Hermite Function of degree N at x by recurrence relation.
+
+    Parameters
+    ----------
+    x : ndarray
+        The input array.
+    N : int
+        The degree of Hermite polynomial.
+    return_full : bool, optional
+        Whether to return the full PL array. Default is True.
+
+    Returns
+    ----------
+    PL[N] or PL : ndarray, shape (N + 1, len(x))
+        The value of modified Hermite polynomial of degree N at x, or the full PL array if return_full is True.
+
+    References
+    ----------
+    Spectral Method P256
+    """
+
+    xp = x.copy()
+    if len(xp.shape) == 2 and xp.shape[1] == 1:
+        xp = xp.T
+    PL = np.ones((N + 1, max(xp.shape)))
+    PL[0] = np.exp(-xp ** 2 / 2) / np.pi ** 0.25    # underflow may occur for large r
+    if N == 0:
+        return PL[0]
+    PL[1] = np.sqrt(2) * xp * PL[0]
+    for i in range(1, N):
+        PL[i + 1] = np.sqrt(2 / (i + 1)) * xp * PL[i] - np.sqrt(i / (i + 1)) * PL[i - 1]
+    return PL if return_full else PL[N]
+
+
+def Hermite_Gauss(N, c=1 / np.sqrt(2)):
+    """
+    Generate the Hermite-Gauss(HG) quadrature points r and weights w w.r.t Hermite function.
+
+    Parameters
+    ----------
+    N : int
+        Number of points, underflow will occur for N > 740 with default c.
+    c : float, optional
+        The decay factor for v = exp(-(cx)^2) * u(x). Default is 1 / sqrt(2).
+        If c = 0, it degenerates to Hermite-ploynomial case.
+
+    Returns
+    ----------
+    D : ndarray, shape (N, N)
+        The first order derivative matrix of Hermite-Gauss quadrature points. 
+    r : ndarray, shape (N,)
+        The Hermite-Gauss quadrature points.
+    w : ndarray, shape (N,)
+        The weights of Hermite-Gauss quadrature points.
+
+    References
+    ----------
+    Spectral Method P261
+    """
+
+    r, w = roots_hermite(N)
+    if c != 0:
+        w = 1 / (HermiteF(r, N - 1, False)**2 * N)  # equ(7.81), modified weights for Hermite function
+    H = HermiteP(r, N - 1, True, False) * np.exp(-(c * r) ** 2)  # equ(7.93), underflow may occur for large r
+    dis = r[:, np.newaxis] - r[np.newaxis, :]
+    np.fill_diagonal(dis, 1)
+    D = H[:, np.newaxis] / H[np.newaxis, :] / dis
+    np.fill_diagonal(D, r * (1 - 2 * c**2))
+    return D, r, w
+
+
+
+def mapped_Jacobi_Gauss(alpha, beta, N, sf = 1, mapping = 'alg'):
+    """
+    Mapped Jacobi-Gauss quadrature points, weights and first order derivative matrix.
+    The mapping is defined by the function y = map(r, s), where r is the original Jacobi-Gauss quadrature points,
+    and s is the scaling factor of the mapping.
+
+    Parameters
+    ----------
+    alpha : float
+        The alpha parameter of the Jacobi polynomial. alpha > -1.
+    beta : float
+        The beta parameter of the Jacobi polynomial. beta > -1.
+        If alpha = beta = 0, the Jacobi polynomial is Legendre polynomial.
+    N : int
+        The order of the Jacobi polynomial.
+    sf : float, optional
+        The scaling factor of the mapping. Default is 1.
+    mapping : str, optional
+        The mapping function. Default is 'alg', which means using the algebraic mapping (cf. equ(7.159)).
+        Other options are 'log' and 'exp'.
+
+    Returns
+    ----------
+    D : ndarray, shape (N, N)
+        The first order derivative matrix of the mapped Jacobi-Gauss quadrature.
+    r : ndarray, shape (N,)
+        The mapped Jacobi-Gauss quadrature nodes.
+    w : ndarray, shape (N,)
+        The modified mapped Jacobi-Gauss quadrature weights.
+
+    References
+    ----------
+    1. Spectral Method P280, P286
+    """
+
+    y, s = symbols('y s')
+
+    if mapping == 'alg':
+        map_expr = s * y / sqrt(1 - y**2)
+        diff_map_expr = diff(map_expr, y)
+    elif mapping == 'log':
+        map_expr = s * atanh(y)
+        diff_map_expr = diff(map_expr, y)
+    elif mapping == 'exp':
+        map_expr = sinh(s * y)
+        diff_map_expr = diff(map_expr, y)
+    else:
+        raise ValueError("Invalid mapping function. Please choose from 'alg', 'log' and 'exp'.")
+
+    map = lambdify((y, s), map_expr, "numpy")
+    diff_map = lambdify((y, s), diff_map_expr, "numpy")
+
+    D, r, w = Jacobi_Gauss(alpha, beta, N)
+    omega = (1 - r)**alpha * (1 + r)**beta
+    diff_g = diff_map(r, sf)
+    D, r, w = D / diff_g[:, None], map(r, sf), w / omega * diff_g
+    return D, r, w
+
+
+
+
+def glue1D(interval, Ncell, D, r, w, end_pts = False):
+    """
+    Glue the differential matrix D, Gauss points r, and quadrature weights w on each cell together.
+
+    Parameters
+    ----------
+    interval : list or tuple, length 2
+        The left and right edge of the domain.
+    Ncell : int
+        The number of cells.
+    D, r, w : ndarray
+        The differential matrix, Gauss points, and quadrature weights on the reference cell [-1, 1],
+        which can be generated by `spectral.Jacobi_Gauss`, `spectral.Jacobi_Gauss_Lobatto`.
+    end_pts : bool, optional
+        Whether the end points -1, 1 are included in r or not. The default is False.
+        E.g., if `spectral.Jacobi_Gauss_Lobatto` is used, the end points are included in r.
+
+    Returns
+    ----------
+    D, r, w : ndarray
+        The differential matrix D, Gauss points r, and quadrature weights w on the interval.
+        if end_pts is False, shape (Ncell * Np, Ncell * Np), (Ncell * Np,), (Ncell * Np,)
+        if end_pts is True, shape (Ncell * (Np - 1) + 1, Ncell * (Np - 1) + 1), (Ncell * (Np - 1) + 1,), (Ncell * (Np - 1) + 1,)
+    """
+
+    Np = len(r)
+    D, r, w = D.copy(), r.copy(), w.copy()
+    left, right = interval
+    Len = (right - left) / Ncell / 2
+    r = (r + 1) * Len + left
+    r = r[None, :].repeat(Ncell, axis=0)
+    r = r + np.arange(Ncell)[:, None] * Len * 2
+    D_blocks = [D / Len] * Ncell
+    D, r, w = block_diag(*D_blocks), r.reshape(-1), np.tile(w, Ncell) * Len
+    if end_pts:
+        Glue = lil_matrix(np.zeros((Ncell * (Np - 1) + 1, Ncell * Np)))
+        for j in range(Ncell):
+            rowStart, colStart = j * (Np - 1), j * Np
+            Glue[rowStart:rowStart+Np, colStart:colStart+Np] = eye(Np)
+        D, Glue = csr_matrix(D), Glue.tocsr()
+        D = (Glue @ D @ Glue.T).toarray()
+        r = np.delete(r, np.arange(Np-1, len(r)-1, Np))
+        w = Glue @ w
+    return D, r, w
+
+def glue_pts_1D(interval, Ncell, r, end_pts = False):
+    """
+    Glue the points r on each cell together.
+
+    Parameters
+    ----------
+    interval : list or tuple, length 2
+        The left and right edge of the domain.
+    Ncell : int
+        The number of cells.
+    r : ndarray
+        The collocation points on the reference cell [-1, 1],
+    end_pts : bool, optional
+        Whether the end points -1, 1 are included in r or not. The default is False.
+
+    Returns
+    ----------
+    r : ndarray
+        The collocation points r on the interval.
+        if end_pts is False, shape (Ncell * Np,)
+        if end_pts is True, shape (Ncell * (Np - 1) + 1,)
+    """
+
+    Np = len(r)
+    r = r.copy()
+    left, right = interval
+    Len = (right - left) / Ncell / 2
+    r = (r + 1) * Len + left
+    r = r[None, :].repeat(Ncell, axis=0)
+    r = r + np.arange(Ncell)[:, None] * Len * 2
+    r = r.reshape(-1)
+    if end_pts:
+        r = np.delete(r, np.arange(Np-1, len(r)-1, Np))
+    return r

specnn4pde/tools.py

@@ -0,0 +1,201 @@
+__all__ = ['pkg_system_info', 'func_timer', 'timer',
+           ]
+
+import platform
+import psutil
+import pandas as pd
+from datetime import datetime
+from IPython.display import display, HTML
+import GPUtil
+import importlib
+import subprocess
+
+import time
+from functools import wraps
+
+def pkg_system_info(packages, show_pkg=True, show_gpu=True, show_system=True):
+    """
+    This function takes a list of package names as input, imports each package dynamically, 
+    and displays the version information of each package and the system information.
+
+    Parameters
+    ----------
+    packages : list of str
+        A list of package names to import and get version information.
+    show_pkg : bool
+        Whether to show package version information. Default is True.
+    show_system : bool
+        Whether to show system information. Default is True.
+    show_gpu : bool
+        Whether to show GPU information. Default is True.
+
+    Returns
+    ----------
+    None
+
+    Example
+    ----------
+    >>> pkg_system_info(['numpy', 'pandas', 'scipy', 'qiskit'], show_pkg=True, show_gpu=True, show_system=False)
+    """
+
+    def get_cpu_info():
+        # Get CPU information on Linux
+        cpu_info = subprocess.check_output("lscpu", shell=True).decode()
+        architecture = subprocess.check_output("uname -m", shell=True).decode().strip()
+        lines = cpu_info.split('\n')
+        info_dict = {}
+        for line in lines:
+            if "Vendor ID:" in line:
+                info_dict['Vendor ID'] = line.split(':')[1].strip()
+            if "CPU family:" in line:
+                info_dict['CPU family'] = line.split(':')[1].strip()
+            if "Model:" in line:
+                info_dict['Model'] = line.split(':')[1].strip()
+            if "Stepping:" in line:
+                info_dict['Stepping'] = line.split(':')[1].strip()
+        return architecture, info_dict
+
+
+    if show_pkg:
+        # Get packages version information
+        pkg_versions = []
+        for pkg_name in packages:
+            try:
+                pkg = importlib.import_module(pkg_name)
+                version = pkg.__version__
+            except AttributeError:
+                version = "Version not available"
+            pkg_versions.append((pkg.__name__, version))
+        
+        pkg_versions_df = pd.DataFrame(pkg_versions, columns=['Package', 'Version'])
+        display(HTML(pkg_versions_df.to_html(index=False)))
+
+    if show_gpu:
+        # Get GPU information
+        gpus = GPUtil.getGPUs()
+        gpu_info_list = []
+        if gpus:
+            for gpu in gpus:
+                gpu_info = [gpu.name, f"{round(gpu.memoryTotal / 1024, 1)} Gb", 1]
+                for existing_gpu_info in gpu_info_list:
+                    if existing_gpu_info[0] == gpu_info[0] and existing_gpu_info[1] == gpu_info[1]:
+                        existing_gpu_info[2] += 1
+                        break
+                else:
+                    gpu_info_list.append(gpu_info)
+        else:
+            gpu_info_list = [['No GPU detected', 'N/A', 'N/A']]
+
+        gpu_info_df = pd.DataFrame(gpu_info_list, columns=['GPU Version', 'GPU Memory', 'Count'])
+        display(HTML(gpu_info_df.to_html(index=False)))
+
+    if show_system:
+        # Get system information
+        system_info = {
+            'Python version': platform.python_version(),
+            'Python compiler': platform.python_compiler(),
+            'Python build': platform.python_build(),
+            'OS': platform.system(),
+            'CPU Version': platform.processor(),
+            'CPU Number': psutil.cpu_count(),
+            'CPU Memory': f"{round(psutil.virtual_memory().total / (1024.0 **3), 1)} Gb",
+            'Time': datetime.now().strftime("%a %b %d %H:%M:%S %Y %Z")
+        }
+
+        if system_info['OS'] == 'Linux':
+            architecture, cpu_info = get_cpu_info()
+            system_info['CPU Version'] = f"{architecture} Family {cpu_info['CPU family']} Model {cpu_info['Model']} Stepping {cpu_info['Stepping']}, {cpu_info['Vendor ID']}"
+
+        system_info_df = pd.DataFrame(list(system_info.items()), columns=['System Information', 'Details'])
+        display(HTML(system_info_df.to_html(index=False)))
+
+
+
+
+def func_timer(function):
+    """
+    This is a timer decorator. It calculates the execution time of the function.
+    
+    Args
+    ----------
+    function : callable
+        The function to be timed.
+
+    Returns
+    ----------
+    function : callable
+        The decorated function which will print its execution time when called.
+
+    Example
+    ----------
+    >>> @func_timer
+    >>> def my_function(n):
+    >>>     return sum(range(n))
+    >>> my_function(1000000)
+    """
+
+    @wraps(function)
+    def function_timer(*args, **kwargs):
+        t0 = time.time()
+        result = function(*args, **kwargs)
+        t1 = time.time()
+        print ("Running time of %s: %.3e seconds" % (function.__name__, t1-t0))
+        return result
+    return function_timer
+
+
+class timer:
+    """
+    A simple timer class.
+    
+    Attributes
+    ----------
+    start_time : float
+        The time when the timer was started.
+    last_lap_time : float
+        The time when the last lap was recorded.
+
+    Methods
+    -------
+    __init__():
+        Initializes the timer.
+    __str__():
+        Returns a string representation of the timer.
+    __repr__():
+        Returns a formal string representation of the timer.
+    reset():
+        Resets the timer.
+    update():
+        Updates the last lap time without printing anything.
+    lap():
+        Records a lap time and prints the time difference since the last lap.
+    stop():
+        Prints the total time.
+    """
+    
+    def __init__(self):
+        self.start_time = time.time()
+        self.last_lap_time = self.start_time
+
+    def __str__(self):
+        return 'Timer(start_time=%.3e, last_lap_time=%.3e)' % (self.start_time, self.last_lap_time)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def reset(self):
+        self.start_time = time.time()
+        self.last_lap_time = self.start_time
+
+    def update(self):
+        self.last_lap_time = time.time()
+
+    def lap(self):
+        current_time = time.time()
+        lap_time = current_time - self.last_lap_time
+        self.last_lap_time = current_time
+        print('Lap time: %.3e s' % lap_time)
+
+    def stop(self):
+        total_time = time.time() - self.start_time
+        return print('Total time: %.3e s' % total_time)

specnn4pde-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mingxing Weng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

specnn4pde-0.0.1.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: specnn4pde
+Version: 0.0.1
+Summary: Solving partial differential equations using spectral methods and neural networks.
+Home-page: https://github.com/mxweng/specnn4pde
+Author: MXWeng
+Author-email: 2431141461@qq.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: GPUtil
+Requires-Dist: IPython
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: psutil
+Requires-Dist: scipy
+Requires-Dist: sympy
+
+# SpecNN4PDE
+SpecNN4PDE is an under development Python library for solving partial differential equations using spectral methods and neural networks. It consists of the following modules:
+
+- `spectral`: Provides functions for working with spectral methods as described in the book [Spectral Methods: Algorithms, Analysis and Applications](https://link.springer.com/book/10.1007/978-3-540-71041-7) by Shen, Tang, and Wang.
+- `linalg`: This module primarily focuses on numerical algebra methods.
+- `tools`: A collection of utility functions for system and package information retrieval, time measurement, etc.
+- `npde`: Functions for solving partial differential equations, e.g., calculating the multivariate derivatives.
+
+This project is still in the early stages of development, and the API is subject to change. The library is designed to be used in research and educational settings.
+
+## Dependencies
+
+When you install this library using pip, most dependencies will be automatically handled. However, please note that the `npde` module requires PyTorch, which needs to be installed separately.
+
+You can install PyTorch by following the instructions on the [official PyTorch website](https://pytorch.org/get-started/locally/). Please ensure that you select the correct installation command based on your operating system, package manager, Python version, and the specifications of your CUDA toolkit if you are planning to use PyTorch with GPU support.
+
+If you are not planning to use the `npde` module, you do not need to install PyTorch.
+
+## Installation
+
+To install this library, you can use pip:
+
+```bash
+pip install specnn4pde

specnn4pde-0.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+specnn4pde/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+specnn4pde/linalg.py,sha256=8qHJG24RUgwvkSofSYQy-1tm25R0gi6RymJ-zIFzhTY,1755
+specnn4pde/npde.py,sha256=wUBWddAB25eU37UBQCPypMRzUaDb2wjlwR-J9Cd-pKI,12133
+specnn4pde/spectral.py,sha256=txPb70G7_VUIqbJDD-rHYm_UaLsikoGSuz-WLjTKik8,16254
+specnn4pde/tools.py,sha256=hOhyJXVJ7mH_Y_K7bkB0BRT8BcyAxZKRsIKWfne4TW0,6621
+specnn4pde-0.0.1.dist-info/LICENSE,sha256=9tZg7MJu1ISWOuSfR85POKrnVpqeuSCk-1yc6iJOFfg,1091
+specnn4pde-0.0.1.dist-info/METADATA,sha256=BZ3gMyQjKeQNd2cMZv8MHELKwHIxVfDCfXM0COpmtTI,2716
+specnn4pde-0.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+specnn4pde-0.0.1.dist-info/top_level.txt,sha256=fKk-8IFaXpUmX3oazaH2Solv2v9peikEL3WO_ek5lGk,11
+specnn4pde-0.0.1.dist-info/RECORD,,

specnn4pde-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

specnn4pde-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+specnn4pde