pdesolver 0.1.0__py3-none-any.whl

pdesolver/Auxs/FuncAux.py

@@ -0,0 +1,24 @@
+import re
+
+import sympy as sp
+from sympy.parsing.sympy_parser import parse_expr
+
+def symbol_references(in_list):
+    slist = []
+
+    for e in in_list:
+        globals()[e] = sp.Symbol(e)
+        slist.append(e)
+    return slist
+
+def d_dt(expr_str: str) -> str:
+    t = sp.Symbol('t')
+    try:
+        e = parse_expr(expr_str, evaluate=False)
+        return str(sp.diff(e, t))
+    except Exception:
+        return expr_str
+
+def repl_symbol(expr: str, sym: str, repl: str) -> str:
+    pattern = rf'(?<![A-Za-z0-9_]){sym}(?![A-Za-z0-9_])'
+    return re.sub(pattern, repl, expr)

pdesolver/Auxs/PDESEncoder.py

@@ -0,0 +1,13 @@
+import json
+import numpy as np
+import sympy as sp
+
+class PDESEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        if isinstance(obj, sp.Basic):
+            return str(obj)
+        if hasattr(obj, '__dict__'):
+            return obj.__dict__
+        return super().default(obj)

pdesolver/Auxs/Visualize.py

@@ -0,0 +1,266 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+
+
+def visualize(pdes_obj, mode='heatmap', func_idx=0, time_step=-1, **kwargs):
+
+    if pdes_obj.results is None:
+        print("Erro: rode .solve() antes de visualizar.")
+        return
+
+    _, historico = pdes_obj.results
+
+    if not historico or not historico[func_idx]:
+        print("Erro: histórico vazio.")
+        return
+
+    if _is_1d(pdes_obj):
+        x = _get_x1d(pdes_obj)
+        if mode in ('plot1d', 'plot'):
+            plot1d(historico, x, pdes_obj.funcs, func_idx, time_step, **kwargs)
+        elif mode == 'plot1d_all':
+            plot1d_all(historico, x, pdes_obj.funcs, func_idx, **kwargs)
+        elif mode == 'heatmap1d':
+            heatmap1d(historico, x, pdes_obj.funcs, pdes_obj.pdes, func_idx, **kwargs)
+        elif mode == 'animation1d':
+            animate1d(historico, x, pdes_obj.funcs, func_idx, **kwargs)
+        else:
+            print(f"Modo '{mode}' não reconhecido para 1D. "
+                  f"Use: 'plot1d', 'plot1d_all', 'heatmap1d', 'animation1d'.")
+        return
+
+    nx, ny = pdes_obj.disc_n
+    x = np.linspace(0, 1, nx)
+    y = np.linspace(0, 1, ny)
+    X, Y = np.meshgrid(x, y, indexing='ij')
+
+    if mode == 'heatmap':
+        plot_heatmap(historico, X, Y, pdes_obj.funcs, pdes_obj.disc_n, func_idx, time_step)
+    elif mode == 'animation':
+        animate2d(historico, X, Y, pdes_obj.funcs, pdes_obj.disc_n, func_idx, **kwargs)
+    elif mode == 'plot3d':
+        plot3d(historico, X, Y, pdes_obj.funcs, pdes_obj.disc_n, func_idx, time_step, **kwargs)
+    elif mode == 'animation3d':
+        animate3d(historico, X, Y, pdes_obj.funcs, pdes_obj.disc_n, func_idx, **kwargs)
+    else:
+        print(f"Modo '{mode}' desconhecido para 2D. "
+              f"Use: 'heatmap', 'animation', 'plot3d', 'animation3d'.")
+
+
+def _is_1d(pdes_obj):
+    return len(pdes_obj.disc_n) == 1
+
+
+def _get_x1d(pdes_obj):
+    a, b = pdes_obj.pdes[0].ivar_boundary[0]
+    return np.linspace(a, b, pdes_obj.disc_n[0])
+
+
+def plot1d(historico, x, funcs, func_idx, time_step, **kwargs):
+    color = kwargs.get('color', 'steelblue')
+    lw    = kwargs.get('lw', 2)
+
+    data  = np.array(historico[func_idx][time_step])
+    label = time_step if time_step >= 0 else len(historico[func_idx]) + time_step
+
+    fig, ax = plt.subplots(figsize=(7, 4))
+    ax.plot(x, data, color=color, linewidth=lw, label=f't = passo {label}')
+    ax.set_xlabel('x')
+    ax.set_ylabel(funcs[func_idx])
+    ax.set_title(f"Perfil de {funcs[func_idx]} — passo {label}")
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    plt.tight_layout()
+    plt.show()
+
+
+def plot1d_all(historico, x, funcs, func_idx, **kwargs):
+    n_profiles = kwargs.get('n_profiles', 10)
+    cmap       = kwargs.get('cmap', 'viridis')
+    lw         = kwargs.get('lw', 1.5)
+    tf_real    = kwargs.get('tf', None)
+
+    n_passos = len(historico[func_idx])
+    indices  = np.linspace(0, n_passos - 1, n_profiles, dtype=int)
+    cm       = plt.get_cmap(cmap)
+    colors   = [cm(i / (n_profiles - 1)) for i in range(n_profiles)]
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+
+    for idx_cor, idx_passo in enumerate(indices):
+        data = np.array(historico[func_idx][idx_passo])
+        if tf_real is not None:
+            t_val = tf_real * idx_passo / (n_passos - 1)
+            lbl   = f't = {t_val:.2f}'
+        else:
+            lbl = f'passo {idx_passo}'
+        ax.plot(x, data, color=colors[idx_cor], linewidth=lw, label=lbl)
+
+    ax.set_xlabel('x')
+    ax.set_ylabel(funcs[func_idx])
+    ax.set_title(f"Evolução de {funcs[func_idx]} ao longo do tempo")
+    ax.legend(fontsize=8, loc='best')
+    ax.grid(True, alpha=0.3)
+
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=0, vmax=1))
+    sm.set_array([])
+    cbar = plt.colorbar(sm, ax=ax, pad=0.02)
+    cbar.set_label('t / tf')
+
+    plt.tight_layout()
+    plt.show()
+
+
+def heatmap1d(historico, x, funcs, pdes, func_idx, **kwargs):
+    cmap    = kwargs.get('cmap', 'viridis')
+    tf_real = kwargs.get('tf', None)
+
+    matriz   = np.array(historico[func_idx])
+    n_passos = matriz.shape[0]
+    t_max    = tf_real if tf_real is not None else n_passos - 1
+    a, b     = pdes[0].ivar_boundary[0]
+
+    fig, ax = plt.subplots(figsize=(8, 5))
+    im = ax.imshow(
+        matriz.T,
+        aspect='auto',
+        origin='lower',
+        extent=[0, t_max, a, b],
+        cmap=cmap
+    )
+    ax.set_xlabel('t')
+    ax.set_ylabel('x')
+    ax.set_title(f"Evolução espaciotemporal de {funcs[func_idx]}")
+    plt.colorbar(im, ax=ax, label=funcs[func_idx])
+    plt.tight_layout()
+    plt.show()
+
+
+def animate1d(historico, x, funcs, func_idx, **kwargs):
+    frames_step = kwargs.get('frames_step', 1)
+    interval    = kwargs.get('interval', 50)
+    color       = kwargs.get('color', 'steelblue')
+    lw          = kwargs.get('lw', 2)
+    tf_real     = kwargs.get('tf', None)
+
+    n_passos = len(historico[func_idx])
+    frames   = list(range(0, n_passos, frames_step))
+
+    todos  = np.concatenate([historico[func_idx][f] for f in frames])
+    y_min, y_max = todos.min(), todos.max()
+    margem = (y_max - y_min) * 0.05 or 0.1
+
+    fig, ax = plt.subplots(figsize=(8, 4))
+    linha,  = ax.plot(x, historico[func_idx][0], color=color, linewidth=lw)
+    ax.set_xlim(x[0], x[-1])
+    ax.set_ylim(y_min - margem, y_max + margem)
+    ax.set_xlabel('x')
+    ax.set_ylabel(funcs[func_idx])
+    ax.grid(True, alpha=0.3)
+    titulo = ax.set_title('')
+
+    def update(frame_idx):
+        passo = frames[frame_idx]
+        linha.set_ydata(np.array(historico[func_idx][passo]))
+        if tf_real is not None:
+            t_val = tf_real * passo / (n_passos - 1)
+            titulo.set_text(f"{funcs[func_idx]} — t = {t_val:.3f}")
+        else:
+            titulo.set_text(f"{funcs[func_idx]} — passo {passo}")
+        return linha, titulo
+
+    anim = FuncAnimation(fig, update, frames=len(frames),
+                         interval=interval, blit=True)
+    plt.tight_layout()
+    plt.show()
+
+def plot_heatmap(historico, X, Y, funcs, disc_n, func_idx, time_step):
+    data = np.array(historico[func_idx][time_step]).reshape(disc_n)
+    plt.figure(figsize=(7, 6))
+    contorno = plt.contourf(X, Y, data, levels=30, cmap='hot')
+    plt.title(f"Distribuição de {funcs[func_idx]} no passo {time_step}")
+    plt.colorbar(contorno)
+    plt.show()
+
+
+def animate2d(historico, X, Y, funcs, disc_n, func_idx, **kwargs):
+    frames_step = kwargs.get('frames_step', 1)
+    interval    = kwargs.get('interval', 50)
+
+    fig, ax = plt.subplots(figsize=(7, 6))
+    Z_ini   = np.array(historico[func_idx][0]).reshape(disc_n)
+    contorno = ax.contourf(X, Y, Z_ini, levels=30, cmap='hot')
+    fig.colorbar(contorno, ax=ax)
+
+    def update(frame):
+        ax.clear()
+        Z    = np.array(historico[func_idx][frame]).reshape(disc_n)
+        cont = ax.contourf(X, Y, Z, levels=30, cmap='hot')
+        ax.set_title(f"Evolução de {funcs[func_idx]} - Passo {frame}")
+        ax.set_xlabel('x')
+        ax.set_ylabel('y')
+        return cont,
+
+    frames_list = range(0, len(historico[func_idx]), frames_step)
+    anim = FuncAnimation(fig, update, frames=frames_list,
+                         interval=interval, blit=False)
+    plt.show()
+
+
+def plot3d(historico, X, Y, funcs, disc_n, func_idx, time_step, **kwargs):
+    cmap  = kwargs.get('cmap', 'hot')
+    alpha = kwargs.get('alpha', 1.0)
+    elev  = kwargs.get('elev', 30)
+    azim  = kwargs.get('azim', -60)
+
+    data  = np.array(historico[func_idx][time_step]).reshape(disc_n)
+    label = time_step if time_step >= 0 else len(historico[func_idx]) + time_step
+
+    fig = plt.figure(figsize=(8, 6))
+    ax  = fig.add_subplot(111, projection='3d')
+    ax.plot_surface(X, Y, data, cmap=cmap, alpha=alpha)
+    ax.set_title(f"Superfície 3D de {funcs[func_idx]} - Passo {label}")
+    ax.set_xlabel('x')
+    ax.set_ylabel('y')
+    ax.set_zlabel(str(funcs[func_idx]))
+    ax.view_init(elev=elev, azim=azim)
+    plt.tight_layout()
+    plt.show()
+
+
+def animate3d(historico, X, Y, funcs, disc_n, func_idx, **kwargs):
+    frames_step = kwargs.get('frames_step', 1)
+    interval    = kwargs.get('interval', 50)
+    cmap        = kwargs.get('cmap', 'hot')
+    alpha       = kwargs.get('alpha', 1.0)
+    elev        = kwargs.get('elev', 30)
+    azim        = kwargs.get('azim', -60)
+
+    todos_frames = [
+        np.array(historico[func_idx][f]).reshape(disc_n)
+        for f in range(0, len(historico[func_idx]), frames_step)
+    ]
+    z_min = min(Z.min() for Z in todos_frames)
+    z_max = max(Z.max() for Z in todos_frames)
+
+    fig = plt.figure(figsize=(8, 6))
+    ax  = fig.add_subplot(111, projection='3d')
+
+    def update(frame):
+        ax.clear()
+        Z = todos_frames[frame]
+        ax.plot_surface(X, Y, Z, cmap=cmap, alpha=alpha)
+        ax.set_title(
+            f"Evolução 3D de {funcs[func_idx]} - Passo {frame * frames_step}"
+        )
+        ax.set_xlabel('x')
+        ax.set_ylabel('y')
+        ax.set_zlabel(str(funcs[func_idx]))
+        ax.set_zlim(z_min, z_max)
+        ax.view_init(elev=elev, azim=azim)
+
+    anim = FuncAnimation(fig, update, frames=len(todos_frames),
+                         interval=interval, blit=False)
+    plt.show()

pdesolver/Auxs/__init__.py

@@ -0,0 +1,2 @@
+from .FuncAux import symbol_references, repl_symbol, d_dt
+from .Visualize import visualize

pdesolver/Disc/Disc.py

@@ -0,0 +1,372 @@
+from typing import List, Tuple
+import re
+from ..Auxs.FuncAux import repl_symbol as _repl_symbol
+from .boundaries import get_boundary
+
+def _build_discretized_eqs(
+    eqrs: List[str],
+    xd_var: List[str],
+    str_sp_vars: str,
+    method: str,
+) -> List[str]:
+
+    SCHEMES = {
+        "forward": {
+            "d2x": "({v}_i+1_j - 2*{v}_ii_j + {v}_i-1_j)/ h{v}_ ** 2",
+            "d1x": "({v}_i+1_j - {v}_ii_j)/ h{v}_",
+            "d2y": "({v}_ii_j+1 - 2*{v}_ii_j + {v}_ii_j-1)/ h{v}_ ** 2",
+            "d1y": "({v}_ii_j+1 - {v}_ii_j)/ h{v}_",
+        },
+        "central": {
+            "d2x": "({v}_i+1_j - 2*{v}_ii_j + {v}_i-1_j)/ h{v}_ ** 2",
+            "d1x": "({v}_i+1_j - {v}_i-1_j)/(2* h{v}_)",
+            "d2y": "({v}_ii_j+1 - 2*{v}_ii_j + {v}_ii_j-1)/ h{v}_ ** 2",
+            "d1y": "({v}_ii_j+1 - {v}_ii_j-1)/(2* h{v}_)",
+        },
+        "backward": {
+            "d2x": "({v}_i+1_j - 2*{v}_ii_j + {v}_i-1_j)/ h{v}_ ** 2",
+            "d1x": "({v}_ii_j - {v}_i-1_j)/ h{v}_",
+            "d2y": "({v}_ii_j+1 - 2*{v}_ii_j + {v}_ii_j-1)/ h{v}_ ** 2",
+            "d1y": "({v}_ii_j - {v}_ii_j-1)/ h{v}_",
+        },
+    }
+
+    if method not in SCHEMES:
+        raise ValueError(
+            f"Método inválido: '{method}'. Use 'forward', 'central' ou 'backward'."
+        )
+
+    s = SCHEMES[method]
+
+    for j in range(len(eqrs)):
+        for k, sp_var in enumerate(str_sp_vars):
+            for v in xd_var:
+                if k == 0:
+                    eqrs[j] = eqrs[j].replace(f"d2{v}{str_sp_vars}/d{sp_var}2", s["d2x"].format(v=v))
+                    eqrs[j] = eqrs[j].replace(f"d{v}{str_sp_vars}/d{sp_var}",   s["d1x"].format(v=v))
+                elif k == 1:
+                    eqrs[j] = eqrs[j].replace(f"d2{v}{str_sp_vars}/d{sp_var}2", s["d2y"].format(v=v))
+                    eqrs[j] = eqrs[j].replace(f"d{v}{str_sp_vars}/d{sp_var}",   s["d1y"].format(v=v))
+
+        for v in xd_var:
+            eqrs[j] = eqrs[j].replace(f"{v}{str_sp_vars}", f"{v}_ii_j")
+
+    for j in range(len(eqrs)):
+        eqrs[j] = _repl_symbol(eqrs[j], str_sp_vars[0], f"ii * h{xd_var[0]}_")
+        if len(str_sp_vars) == 2:
+            eqrs[j] = _repl_symbol(eqrs[j], str_sp_vars[1], f"j * h{xd_var[0]}_")
+
+    return eqrs
+
+
+def _expand_indices(
+    eqrs: List[str],
+    n_part: List[int],
+    str_sp_vars: str,
+) -> List[List[str]]:
+
+    partial = []
+    for eq in eqrs:
+        row = [
+            eq
+            .replace("i+1", str(i + 1))
+            .replace("i-1", str(i - 1))
+            .replace("i-2", str(i - 2))
+            .replace("i+2", str(i + 2))
+            .replace("ii",  str(i))
+            for i in range(1, n_part[0] - 1)
+        ]
+        partial.append(row)
+
+    list_eq: List[List[str]] = [[] for _ in partial]
+
+    if len(str_sp_vars) == 2:
+        for j_eq, row in enumerate(partial):
+            for eq_i in row:
+                for k in range(1, n_part[1] - 1):
+                    list_eq[j_eq].append(
+                        eq_i
+                        .replace("j+1", str(k + 1))
+                        .replace("j-1", str(k - 1))
+                        .replace("j-2", str(k - 2))
+                        .replace("j+2", str(k + 2))
+                        .replace("j",   str(k))
+                    )
+    else:
+        for j_eq, row in enumerate(partial):
+            for eq_i in row:
+                list_eq[j_eq].append(eq_i.replace("j", "0"))
+
+    return list_eq
+
+
+def _build_position_labels(n_part, str_sp_vars, n_funcs):
+    positions = []
+
+    if len(str_sp_vars) == 2:
+        for func in range(n_funcs):
+            aux = []
+            for i in range(n_part[0]):
+                for j in range(n_part[1]):
+                    if i == 0:                   aux.append(f"W{func}_{i}_{j}")
+                    elif i == n_part[0] - 1:     aux.append(f"E{func}_{i}_{j}")
+                    elif j == 0:                 aux.append(f"S{func}_{i}_{j}")
+                    elif j == n_part[1] - 1:     aux.append(f"N{func}_{i}_{j}")
+                    else:                        aux.append(f"Ce{func}_{i}_{j}")
+            positions.append(aux)
+    else:
+        positions = [[""] * n_part[0] for _ in range(n_funcs)]
+
+    return positions
+
+def df(
+    pdes,
+    n_part: List[int],
+    west_bd=None,
+    method:   str = "forward",
+    north_bd=None,
+    south_bd=None,
+    east_bd=None,
+    north_func_bd=None,
+    south_func_bd=None,
+    west_func_bd=None,
+    east_func_bd=None,
+    north_alpha_bd: str = "0",
+    south_alpha_bd: str = "0",
+    east_alpha_bd:  str = "0",
+    north_beta_bd:  str = "1",
+    south_beta_bd:  str = "1",
+    east_beta_bd:   str = "1",
+) -> Tuple[List[str], List[str], dict, dict]:
+
+    n_funcs_total = len(pdes.funcs)
+
+    def _as_list(val, default="neumann"):
+        if val is None:
+            return [default] * n_funcs_total
+        if isinstance(val, list):
+            return val
+        return [val] * n_funcs_total
+
+    west_bd       = _as_list(west_bd,  "neumann")
+    east_bd       = _as_list(east_bd,  "neumann")
+    north_bd      = _as_list(north_bd, "neumann")
+    south_bd      = _as_list(south_bd, "neumann")
+    west_func_bd  = _as_list(west_func_bd,  "0")
+    east_func_bd  = _as_list(east_func_bd,  "0")
+    north_func_bd = _as_list(north_func_bd, "0")
+    south_func_bd = _as_list(south_func_bd, "0")
+
+    xd_var = pdes.xs(pdes.funcs)
+    eqrs = [eq.split("=")[1] for eq in pdes.eqs]
+    str_sp_vars = "".join(pdes.sp_vars)
+
+    for j in range(len(eqrs)):
+        for i, func in enumerate(pdes.funcs):
+            eqrs[j] = eqrs[j].replace(str(func), f"{xd_var[i]}{str_sp_vars}")
+
+
+    eqrs = _build_discretized_eqs(eqrs, xd_var, str_sp_vars, method)
+
+    list_eq = _expand_indices(eqrs, n_part, str_sp_vars)
+
+    n_funcs = len(pdes.funcs)
+
+    if len(str_sp_vars) == 2:
+        list_south = [[] for _ in range(n_funcs)]
+        list_north = [[] for _ in range(n_funcs)]
+        list_west  = [[] for _ in range(n_funcs)]
+        list_east  = [[] for _ in range(n_funcs)]
+
+        for func in range(n_funcs):
+            s_bc = get_boundary(south_bd[func], south_func_bd[func], south_alpha_bd, south_beta_bd)
+            list_south[func] = s_bc.apply("south", list_eq, n_part, xd_var, str_sp_vars)[func]
+
+            n_bc = get_boundary(north_bd[func], north_func_bd[func], north_alpha_bd, north_beta_bd)
+            list_north[func] = n_bc.apply("north", list_eq, n_part, xd_var, str_sp_vars)[func]
+
+            w_bc = get_boundary(west_bd[func], west_func_bd[func])
+            list_west[func] = w_bc.apply("west", list_eq, n_part, xd_var, str_sp_vars)[func] \
+                              if west_bd[func].lower() in ("dirichlet", "neumann", "robin") else []
+
+            e_bc = get_boundary(east_bd[func], east_func_bd[func], east_alpha_bd, east_beta_bd)
+            east_col = e_bc.apply("east", list_eq, n_part, xd_var, str_sp_vars)[func]
+            list_east[func] = [list_south[func][-1]] + east_col + [list_north[func][-1]]
+
+    list_positions = _build_position_labels(n_part, str_sp_vars, n_funcs)
+
+    if len(str_sp_vars) == 1:
+        for func in range(n_funcs):
+            C = 0
+            for i in range(n_part[0]):
+                if i == 0:
+                    bc = get_boundary(west_bd[func], west_func_bd[func])
+                    list_positions[func][i] = bc.apply(
+                        "west", list_eq, n_part, xd_var, str_sp_vars
+                    )[func][0]
+                elif i == n_part[0] - 1:
+                    bc = get_boundary(east_bd[func], east_func_bd[func], east_alpha_bd, east_beta_bd)
+                    list_positions[func][i] = bc.apply(
+                        "east", list_eq, n_part, xd_var, str_sp_vars
+                    )[func][0]
+                else:
+                    list_positions[func][i] = list_eq[func][C]
+                    C += 1
+
+    elif len(str_sp_vars) == 2:
+        for func in range(n_funcs):
+            C = 0
+            for idx in range(len(list_positions[func])):
+                label = list_positions[func][idx]
+                if   "S" in label: list_positions[func][idx] = list_south[func].pop(0) if list_south[func] else label
+                elif "N" in label: list_positions[func][idx] = list_north[func].pop(0) if list_north[func] else label
+                elif "E" in label: list_positions[func][idx] = list_east[func].pop(0)  if list_east[func]  else label
+                elif "W" in label: list_positions[func][idx] = list_west[func].pop(0)  if list_west[func]  else label
+                elif "C" in label:
+                    list_positions[func][idx] = list_eq[func][C]
+                    C += 1
+
+    d_vars: List[str] = []
+    if len(str_sp_vars) == 2:
+        for func in range(n_funcs):
+            for i in range(n_part[0]):
+                for j in range(n_part[1]):
+                    name = f"XX{func}_{i}_{j}"
+                    if name not in d_vars:
+                        d_vars.append(name)
+    else:
+        for func in range(n_funcs):
+            for i in range(n_part[0]):
+                name = f"XX{func}_{i}_0"
+                if name not in d_vars:
+                    d_vars.append(name)
+
+    flat_list_positions: List[str] = []
+    for L in list_positions:
+        flat_list_positions.extend(L)
+
+    hx_val = str(1.0 / (n_part[0] - 1))
+    for i in range(len(flat_list_positions)):
+        for func_name in xd_var:
+            flat_list_positions[i] = flat_list_positions[i].replace(
+                    f"h{func_name}_", hx_val
+            )
+
+    _h_pattern = re.compile(r'\bh[A-Za-z0-9]+_\b')
+    for i in range(len(flat_list_positions)):
+        flat_list_positions[i] = _h_pattern.sub(hx_val, flat_list_positions[i])
+
+    dirichlet_constraints: dict = {}
+    neumann_constraints: dict = {}
+    hx = 1.0 / (n_part[0] - 1)
+    hy = 1.0 / (n_part[1] - 1) if len(str_sp_vars) == 2 else 1.0
+
+    if len(str_sp_vars) == 2:
+        sides = {
+            'west':  west_bd,
+            'east':  east_bd,
+            'north': north_bd,
+            'south': south_bd,
+        }
+        func_exprs = {
+            'west':  west_func_bd,
+            'east':  east_func_bd,
+            'north': north_func_bd,
+            'south': south_func_bd,
+        }
+        Nx, Ny = n_part[0], n_part[1]
+
+        any_neumann = any(
+            sides[s][f].lower() == 'neumann'
+            for s in sides for f in range(n_funcs)
+        )
+        if any_neumann and (Nx < 3 or Ny < 3):
+            raise ValueError(
+                f"Neumann com discretizacao one-sided de 2a ordem exige "
+                f"min(Nx, Ny) >= 3. Recebido: Nx={Nx}, Ny={Ny}."
+            )
+
+        def _idx(func, i, j):
+            return func * Nx * Ny + i * Ny + j
+
+        for func in range(n_funcs):
+            for i in range(Nx):
+                for j in range(Ny):
+                    idx = _idx(func, i, j)
+                    side = None
+                    if   i == 0:      side = 'west'
+                    elif i == Nx - 1: side = 'east'
+                    elif j == 0:      side = 'south'
+                    elif j == Ny - 1: side = 'north'
+                    if side is None:
+                        continue
+                    bc_kind = sides[side][func].lower()
+
+                    if bc_kind == 'dirichlet':
+                        dirichlet_constraints[idx] = {
+                            'expr': func_exprs[side][func],
+                            'x': i * hx,
+                            'y': j * hy,
+                        }
+                    elif bc_kind == 'neumann':
+                        if side == 'south':
+                            n1 = _idx(func, i, 1)
+                            n2 = _idx(func, i, 2)
+                        elif side == 'north':
+                            n1 = _idx(func, i, Ny - 2)
+                            n2 = _idx(func, i, Ny - 3)
+                        elif side == 'west':
+                            n1 = _idx(func, 1, j)
+                            n2 = _idx(func, 2, j)
+                        else:
+                            n1 = _idx(func, Nx - 2, j)
+                            n2 = _idx(func, Nx - 3, j)
+
+                        neumann_constraints[idx] = {
+                            'expr': func_exprs[side][func],
+                            'x': i * hx,
+                            'y': j * hy,
+                            'side': side,
+                            'idx_n1': n1,
+                            'idx_n2': n2,
+                        }
+    else:
+        Nx = n_part[0]
+        for func in range(n_funcs):
+            offset = func * Nx
+            if west_bd[func].lower() == 'dirichlet':
+                dirichlet_constraints[offset] = {
+                    'expr': west_func_bd[func],
+                    'x': 0.0,
+                    'y': 0.0,
+                }
+            elif west_bd[func].lower() == 'neumann':
+                if Nx < 3:
+                    raise ValueError("Neumann 1D exige Nx >= 3.")
+                neumann_constraints[offset] = {
+                    'expr': west_func_bd[func],
+                    'x': 0.0,
+                    'y': 0.0,
+                    'side': 'west',
+                    'idx_n1': offset + 1,
+                    'idx_n2': offset + 2,
+                }
+            if east_bd[func].lower() == 'dirichlet':
+                dirichlet_constraints[offset + Nx - 1] = {
+                    'expr': east_func_bd[func],
+                    'x': (Nx - 1) * hx,
+                    'y': 0.0,
+                }
+            elif east_bd[func].lower() == 'neumann':
+                if Nx < 3:
+                    raise ValueError("Neumann 1D exige Nx >= 3.")
+                neumann_constraints[offset + Nx - 1] = {
+                    'expr': east_func_bd[func],
+                    'x': (Nx - 1) * hx,
+                    'y': 0.0,
+                    'side': 'east',
+                    'idx_n1': offset + Nx - 2,
+                    'idx_n2': offset + Nx - 3,
+                }
+
+    return flat_list_positions, d_vars, dirichlet_constraints, neumann_constraints

pdesolver/Disc/__init__.py

@@ -0,0 +1 @@
+from .Disc import df