handy-diffusion 1.0.0

package/ADI.js

@@ -0,0 +1,264 @@
+import { thomasAlgorithm } from "./thomasAlgorithm.js";
+import { initADIArrays } from "./initArrays.js";
+
+let WIDTH;
+let HEIGHT;
+let modifiedUpperDiagonal1, modifiedRightHandSide1, solution1;
+let modifiedUpperDiagonal2, modifiedRightHandSide2, solution2;
+let intermediateConcentration;
+let a1, b1, c1, d1;
+let a2, b2, c2, d2;
+let alpha, halfDeltaT, oneMinus2AlphaMinusGamma, scaledSources;
+
+export const setADIProperties = (
+    width,
+    height,
+    diffusionCoefficient,
+    deltaX,
+    deltaT,
+    decayRate = 0
+) => {
+    WIDTH = width;
+    HEIGHT = height;
+    ({
+        modifiedUpperDiagonal1,
+        modifiedRightHandSide1,
+        solution1,
+        modifiedUpperDiagonal2,
+        modifiedRightHandSide2,
+        solution2,
+        intermediateConcentration,
+        a1,
+        b1,
+        c1,
+        d1,
+        a2,
+        b2,
+        c2,
+        d2,
+        alpha,
+        halfDeltaT,
+        oneMinus2AlphaMinusGamma,
+        scaledSources,
+    } = initADIArrays(WIDTH, HEIGHT, diffusionCoefficient, deltaX, deltaT, decayRate));
+};
+
+export const ADI = (
+    concentrationData,
+    sources,
+    totalNumberOfIterations,
+    allowNegativeValues = false
+) => {
+    let reachedNegativeValue = false;
+
+    for (let idx = 0; idx < WIDTH * HEIGHT; idx++) {
+        scaledSources[idx] = sources[idx] * halfDeltaT;
+    }
+
+    const currentConcentrationData = concentrationData;
+
+    for (let iteration = 0; iteration < totalNumberOfIterations; iteration++) {
+        /////////////-----  FIRST HALF-STEP  -----/////////////
+
+        // INTERIOR POINTS
+        for (let j = 1; j < HEIGHT - 1; j++) {
+            const rowOffset = j * WIDTH;
+            for (let i = 0; i < WIDTH; i++) {
+                const idx = rowOffset + i;
+
+                const center = currentConcentrationData[idx];
+                const bottom = currentConcentrationData[(j - 1) * WIDTH + i];
+                const top = currentConcentrationData[(j + 1) * WIDTH + i];
+
+                d1[i] =
+                    alpha * bottom +
+                    oneMinus2AlphaMinusGamma * center +
+                    alpha * top +
+                    scaledSources[idx];
+            }
+
+            thomasAlgorithm(
+                a1,
+                b1,
+                c1,
+                d1,
+                WIDTH,
+                modifiedUpperDiagonal1,
+                modifiedRightHandSide1,
+                solution1
+            );
+
+            for (let i = 0; i < WIDTH; i++) {
+                intermediateConcentration[rowOffset + i] = solution1[i];
+            }
+        }
+
+        // BOTTOM POINTS j = 0
+        const rowOffsetBot = 0 * WIDTH;
+        for (let i = 0; i < WIDTH; i++) {
+            const idx = rowOffsetBot + i;
+
+            const center = currentConcentrationData[idx];
+            const bottom = center;
+            const top = currentConcentrationData[1 * WIDTH + i];
+
+            d1[i] =
+                alpha * bottom +
+                oneMinus2AlphaMinusGamma * center +
+                alpha * top +
+                scaledSources[idx];
+        }
+        thomasAlgorithm(
+            a1,
+            b1,
+            c1,
+            d1,
+            WIDTH,
+            modifiedUpperDiagonal1,
+            modifiedRightHandSide1,
+            solution1
+        );
+        for (let i = 0; i < WIDTH; i++) {
+            intermediateConcentration[rowOffsetBot + i] = solution1[i];
+        }
+
+        // TOP POINTS j = HEIGHT-1
+        const rowOffsetTop = (HEIGHT - 1) * WIDTH;
+        for (let i = 0; i < WIDTH; i++) {
+            const idx = rowOffsetTop + i;
+
+            const center = currentConcentrationData[idx];
+            const bottom = currentConcentrationData[(HEIGHT - 2) * WIDTH + i];
+            const top = center;
+
+            d1[i] =
+                alpha * bottom +
+                oneMinus2AlphaMinusGamma * center +
+                alpha * top +
+                scaledSources[idx];
+        }
+        thomasAlgorithm(
+            a1,
+            b1,
+            c1,
+            d1,
+            WIDTH,
+            modifiedUpperDiagonal1,
+            modifiedRightHandSide1,
+            solution1
+        );
+        for (let i = 0; i < WIDTH; i++) {
+            intermediateConcentration[rowOffsetTop + i] = solution1[i];
+        }
+
+        /////////////-----  SECOND HALF-STEP  -----/////////////
+        // INTERIOR POINTS
+        for (let i = 1; i < WIDTH - 1; i++) {
+            for (let j = 0; j < HEIGHT; j++) {
+                const rowOffset = j * WIDTH;
+                const idx = rowOffset + i;
+
+                const center = intermediateConcentration[idx];
+        const right = intermediateConcentration[rowOffset + (i + 1)];
+        const left = intermediateConcentration[rowOffset + (i - 1)];
+
+
+                d2[j] =
+                    alpha * left +
+                    oneMinus2AlphaMinusGamma * center +
+                    alpha * right +
+                    scaledSources[idx];
+            }
+
+            thomasAlgorithm(
+                a2,
+                b2,
+                c2,
+                d2,
+                HEIGHT,
+                modifiedUpperDiagonal2,
+                modifiedRightHandSide2,
+                solution2
+            );
+
+            for (let j = 0; j < HEIGHT; j++) {
+                const pos = j * WIDTH + i;
+                if (solution2[j] < 0) {
+                    reachedNegativeValue = true;
+                }
+                currentConcentrationData[pos] = solution2[j];
+            }
+        }
+
+        // LEFT POINTS i = 0
+        for (let j = 0; j < HEIGHT; j++) {
+            const rowOffset = j * WIDTH;
+            const idx = rowOffset;
+
+            const center = intermediateConcentration[idx];
+            const right = intermediateConcentration[j * WIDTH + 1];
+            const left = center;
+
+            d2[j] =
+                alpha * left +
+                oneMinus2AlphaMinusGamma * center +
+                alpha * right +
+                scaledSources[idx];
+        }
+        thomasAlgorithm(
+            a2,
+            b2,
+            c2,
+            d2,
+            HEIGHT,
+            modifiedUpperDiagonal2,
+            modifiedRightHandSide2,
+            solution2
+        );
+
+        for (let j = 0; j < HEIGHT; j++) {
+            if (solution2[j] < 0) {
+                reachedNegativeValue = true;
+            }
+            currentConcentrationData[j * WIDTH] = solution2[j];
+        }
+
+        // RIGHT POINTS i = WIDTH-1
+        for (let j = 0; j < HEIGHT; j++) {
+            const rowOffset = j * WIDTH;
+            const idx = rowOffset + (WIDTH - 1);
+
+            const center = intermediateConcentration[idx];
+            const right = center;
+            const left = intermediateConcentration[j * WIDTH + (WIDTH - 2)];
+
+            d2[j] =
+                alpha * left +
+                oneMinus2AlphaMinusGamma * center +
+                alpha * right +
+                scaledSources[idx];
+        }
+        thomasAlgorithm(
+            a2,
+            b2,
+            c2,
+            d2,
+            HEIGHT,
+            modifiedUpperDiagonal2,
+            modifiedRightHandSide2,
+            solution2
+        );
+        for (let j = 0; j < HEIGHT; j++) {
+            if (solution2[j] < 0) {
+                reachedNegativeValue = true;
+            }
+            currentConcentrationData[j * WIDTH + (WIDTH - 1)] = solution2[j];
+        }
+    }
+
+    if (reachedNegativeValue && !allowNegativeValues) {
+        console.warn("Concentration went negative at ADI");
+        return null;
+    }
+    return currentConcentrationData;
+};

package/CrankNicolson.js

@@ -0,0 +1,181 @@
+import { thomasAlgorithm } from "./thomasAlgorithm.js";
+
+// Module-level variables for Crank-Nicolson
+let LENGTH;
+let lowerDiagonal, mainDiagonal, upperDiagonal;
+let modifiedUpper, modifiedRHS, solution;
+let u, uNext;
+let lambda, beta, halfLambda, centerCoeff;
+let dt;
+
+/**
+ * Initialize properties for Crank-Nicolson method
+ * @param {number} length - Number of grid points
+ * @param {number} diffusionCoefficient - Diffusion coefficient (alpha)
+ * @param {number} deltaX - Spatial step size
+ * @param {number} deltaT - Time step size
+ * @param {number} decayRate - Decay rate constant (k)
+ */
+export const setCNProperties = (
+    length,
+    diffusionCoefficient,
+    deltaX,
+    deltaT,
+    decayRate = 0
+) => {
+    LENGTH = length;
+    dt = deltaT;
+
+    // Calculate coefficients
+    lambda = (diffusionCoefficient * deltaT) / (deltaX * deltaX);
+    beta = (decayRate * deltaT) / 2.0;
+    halfLambda = 0.5 * lambda;
+    centerCoeff = 1.0 + lambda + beta;
+
+    // Tridiagonal coefficients for A (left-hand side)
+    lowerDiagonal = new Float64Array(LENGTH);
+    mainDiagonal = new Float64Array(LENGTH);
+    upperDiagonal = new Float64Array(LENGTH);
+
+    // Interior coefficients
+    for (let i = 1; i < LENGTH - 1; i++) {
+        lowerDiagonal[i] = -halfLambda;
+        mainDiagonal[i] = centerCoeff;
+        upperDiagonal[i] = -halfLambda;
+    }
+
+    // Neumann (reflective) boundaries using centered differences with ghost cells
+    // u_{-1} = u_1 and u_n = u_{n-2} for zero flux
+    // Left boundary i = 0: stencil becomes (1+λ+β)u_0 - λu_1
+    lowerDiagonal[0] = 0.0;
+    mainDiagonal[0] = centerCoeff;
+    upperDiagonal[0] = -lambda;
+
+    // Right boundary i = LENGTH-1: stencil becomes -λu_{n-2} + (1+λ+β)u_{n-1}
+    lowerDiagonal[LENGTH - 1] = -lambda;
+    mainDiagonal[LENGTH - 1] = centerCoeff;
+    upperDiagonal[LENGTH - 1] = 0.0;
+
+    // Work arrays for Thomas algorithm
+    modifiedUpper = new Float64Array(LENGTH);
+    modifiedRHS = new Float64Array(LENGTH);
+    solution = new Float64Array(LENGTH);
+
+    // Solution arrays
+    u = new Float64Array(LENGTH);
+    uNext = new Float64Array(LENGTH);
+};
+
+/**
+ * Solve 1D diffusion equation using Crank-Nicolson method
+ * @param {Float64Array} concentrationData - Initial concentration values
+ * @param {Float64Array} sources - Source terms
+ * @param {number} totalNumberOfIterations - Number of time steps
+ * @param {boolean} allowNegativeValues - Whether to allow negative concentrations
+ */
+export const CrankNicolson = (
+    concentrationData,
+    sources,
+    totalNumberOfIterations,
+    allowNegativeValues = false
+) => {
+  
+
+    // Copy initial condition
+    for (let i = 0; i < LENGTH; i++) {
+        u[i] = concentrationData[i];
+    }
+
+    // Time-stepping loop
+    for (let step = 0; step < totalNumberOfIterations; step++) {
+        // Build right-hand side d = B*u^n + dt*S, with Neumann BC via mirroring.
+        const d = modifiedRHS;
+
+        // Left boundary i = 0, using ghost cell u_{-1} = u_1 for zero flux
+        // B coefficients: (λ/2) u_{i-1}^n + (1 - λ - β) u_i^n + (λ/2) u_{i+1}^n
+        // Substituting u_{-1} = u_1: (λ/2) u_1 + (1 - λ - β) u_0 + (λ/2) u_1
+        {
+            const i = 0;
+            const u_im1 = u[1];       // ghost cell: u_{-1} = u_1
+            const u_i   = u[0];
+            const u_ip1 = u[1];
+
+            const rhsVal =
+                halfLambda * u_im1 +
+                (1.0 - lambda - beta) * u_i +
+                halfLambda * u_ip1 +
+                dt * sources[i];
+
+            d[i] = rhsVal;
+        }
+
+        // Interior points 1..LENGTH-2
+        for (let i = 1; i < LENGTH - 1; i++) {
+            const u_im1 = u[i - 1];
+            const u_i   = u[i];
+            const u_ip1 = u[i + 1];
+
+            const rhsVal =
+                halfLambda * u_im1 +
+                (1.0 - lambda - beta) * u_i +
+                halfLambda * u_ip1 +
+                dt * sources[i];
+
+            d[i] = rhsVal;
+        }
+
+        // Right boundary i = LENGTH-1, using ghost cell u_n = u_{n-2} for zero flux
+        // Substituting u_n = u_{n-2}: (λ/2) u_{n-2} + (1 - λ - β) u_{n-1} + (λ/2) u_{n-2}
+        {
+            const i = LENGTH - 1;
+            const u_im1 = u[LENGTH - 2];
+            const u_i   = u[LENGTH - 1];
+            const u_ip1 = u[LENGTH - 2];   // ghost cell: u_n = u_{n-2}
+
+            const rhsVal =
+                halfLambda * u_im1 +
+                (1.0 - lambda - beta) * u_i +
+                halfLambda * u_ip1 +
+                dt * sources[i];
+
+            d[i] = rhsVal;
+        }
+
+        // Solve A u^{n+1} = d
+        thomasAlgorithm(
+            lowerDiagonal,
+            mainDiagonal,
+            upperDiagonal,
+            d,
+            LENGTH,
+            modifiedUpper,
+            modifiedRHS,
+            solution
+        );
+
+        // Copy solution and optionally check for negativity
+        let hasNegative = false;
+        for (let i = 0; i < LENGTH; i++) {
+            uNext[i] = solution[i];
+            if (!allowNegativeValues && uNext[i] < 0) {
+                hasNegative = true;
+            }
+        }
+
+        if (hasNegative && !allowNegativeValues) {
+            throw new Error(
+                "Negative concentrations encountered in CrankNicolson step " + step
+            );
+        }
+
+        // Swap u and uNext without reallocating
+        const tmp = u;
+        u = uNext;
+        uNext = tmp;
+    }
+
+    // Copy result back to concentrationData
+    for (let i = 0; i < LENGTH; i++) {
+        concentrationData[i] = u[i];
+    }
+};

package/README.md

@@ -0,0 +1 @@
+# diffusionForBacteria

package/analyticSolution.js

@@ -0,0 +1,113 @@
+
+
+function constantSourceTermOptimized(n, m, Lx, Ly, sources, activeSourceIndices, cosX, cosY, WIDTH, deltaX) {
+    const e_n = n === 0 ? 0.5 : 1;
+    const e_m = m === 0 ? 0.5 : 1;
+    const coefficient = (4 * e_n * e_m * deltaX * deltaX) / (Lx * Ly);
+    let sum = 0;
+
+    for (const idx of activeSourceIndices) {
+        const i = idx % WIDTH;
+        const j = Math.floor(idx / WIDTH);
+        sum += sources[idx] * cosX[n][i] * cosY[m][j];
+    }
+
+    return coefficient * sum;
+}
+
+export const analyticSteadyState = (
+    WIDTH,
+    HEIGHT,
+    DIFFUSION_RATE,
+    DECAY_RATE,
+    deltaX, 
+    sources, 
+    maxMode 
+) => {
+    const steadyStateConcentration = new Float64Array(WIDTH * HEIGHT).fill(0);
+
+    // Precompute non-zero source locations
+    const activeSourceIndices = [];
+    for (let idx = 0; idx < sources.length; idx++) {
+        if (sources[idx] !== 0) activeSourceIndices.push(idx);
+    }
+
+    // Early return if no sources
+    if (activeSourceIndices.length === 0) {
+        return steadyStateConcentration;
+    }
+
+    const Lx = WIDTH * deltaX;
+    const Ly = HEIGHT * deltaX;
+    const piSquared = Math.PI * Math.PI;
+    const LxSquared = Lx * Lx;
+    const LySquared = Ly * Ly;
+    const invLxSquared = 1 / LxSquared;
+    const invLySquared = 1 / LySquared;
+
+    // Precompute all x and y coordinates
+    const xCoords = new Float64Array(WIDTH);
+    const yCoords = new Float64Array(HEIGHT);
+    for (let i = 0; i < WIDTH; i++) xCoords[i] = (i + 0.5) * deltaX;
+    for (let j = 0; j < HEIGHT; j++) yCoords[j] = (j + 0.5) * deltaX;
+
+    // Precompute cosine values for all modes and positions
+    const cosX = Array(maxMode + 1);
+    const cosY = Array(maxMode + 1);
+
+    for (let n = 0; n <= maxMode; n++) {
+        const nPi_Lx = (Math.PI * n) / Lx;
+        cosX[n] = new Float64Array(WIDTH);
+        for (let i = 0; i < WIDTH; i++) {
+            cosX[n][i] = Math.cos(nPi_Lx * xCoords[i]);
+        }
+    }
+
+    for (let m = 0; m <= maxMode; m++) {
+        const mPi_Ly = (Math.PI * m) / Ly;
+        cosY[m] = new Float64Array(HEIGHT);
+        for (let j = 0; j < HEIGHT; j++) {
+            cosY[m][j] = Math.cos(mPi_Ly * yCoords[j]);
+        }
+    }
+
+    // Precompute squared mode numbers
+    const nSquared = new Float64Array(maxMode + 1);
+    const mSquared = new Float64Array(maxMode + 1);
+    for (let n = 0; n <= maxMode; n++) nSquared[n] = n * n;
+    for (let m = 0; m <= maxMode; m++) mSquared[m] = m * m;
+
+    // Compute steady-state solution
+    for (let m = 0; m <= maxMode; m++) {
+        for (let n = 0; n <= maxMode; n++) {
+            const eigenvalue = piSquared * (nSquared[n] * invLxSquared + mSquared[m] * invLySquared);
+            const K_mn = DIFFUSION_RATE * eigenvalue + DECAY_RATE;
+            const Q_mn = constantSourceTermOptimized(
+                n,
+                m,
+                Lx,
+                Ly,
+                sources,
+                activeSourceIndices,
+                cosX,
+                cosY,
+                WIDTH,
+                deltaX
+            );
+            const amplitude = Q_mn / K_mn;
+
+            // Skip modes with negligible contribution
+            if (Math.abs(amplitude) < 1e-15) continue;
+
+            // Compute and accumulate eigenfunction values directly
+            for (let j = 0; j < HEIGHT; j++) {
+                const cosYval = cosY[m][j];
+                for (let i = 0; i < WIDTH; i++) {
+                    steadyStateConcentration[j * WIDTH + i] += amplitude * cosX[n][i] * cosYval;
+                }
+            }
+        }
+    }
+
+    return steadyStateConcentration;
+};

package/effective.js

@@ -0,0 +1,64 @@
+
+export const efectiveInfluence = (width, height, sources, lambda, scale) => {
+    const effectiveInfluenceArray = new Float64Array(width * height).fill(0);
+    
+    // Precompute active sources once
+    const activeSources = [];
+    for (let idx = 0; idx < sources.length; idx++) {
+        if (sources[idx] !== 0) {
+            activeSources.push({
+                idx,
+                x: (idx % width) + 0.5,
+                y: Math.floor(idx / width) + 0.5,
+                strength: sources[idx]
+            });
+        }
+    }
+    
+    // Distance cutoff: beyond 5*lambda, exp(-5) ≈ 0.007 (negligible)
+    const cutoffDistance = lambda * 5;
+    const cutoffDistanceSq = cutoffDistance * cutoffDistance;
+    
+    // For each target cell
+    for (let j = 0; j < height; j++) {
+        for (let i = 0; i < width; i++) {
+            const targetX = i + 0.5;
+            const targetY = j + 0.5;
+            
+            let localInfluence = 0;
+            let totalInfluence = 0;
+            
+            // Single pass through all cells
+            for (let jj = 0; jj < height; jj++) {
+                for (let ii = 0; ii < width; ii++) {
+                    const cellX = ii + 0.5;
+                    const cellY = jj + 0.5;
+                    const dx = cellX - targetX;
+                    const dy = cellY - targetY;
+                    const distSq = dx * dx + dy * dy;
+                    
+                    // Apply distance cutoff
+                    if (distSq > cutoffDistanceSq) continue;
+                    
+                    const distance = Math.sqrt(distSq);
+                    const influence = Math.exp(-distance / lambda);
+                    
+                    totalInfluence += influence;
+                    
+                    // Check if this cell is a source
+                    const cellIdx = jj * width + ii;
+                    if (sources[cellIdx] !== 0) {
+                        localInfluence += sources[cellIdx] * influence;
+                    }
+                }
+            }
+            
+            const idx = j * width + i;
+            effectiveInfluenceArray[idx] = totalInfluence > 0 ? 
+                scale * localInfluence / totalInfluence : 0;
+        }
+    }
+    
+    return effectiveInfluenceArray;
+}
+

package/helpers.js

@@ -0,0 +1,48 @@
+
+export const createRandomSources = (width, height, probability) => {
+const sources = new Float64Array(width * height);
+for (let j = 0; j < height; j++) {
+    for (let i = 0; i < width; i++) {
+        const idx = j * width + i;
+        sources[idx] = Math.random() < probability ? 1.0 : 0.0;
+    }
+}
+return sources;
+}
+
+export const checkForSteadyState = (prev, current, tolerance = 1e-5) => {
+    let maxDiff = 0;
+    for (let i = 0; i < prev.length; i++) {
+        const diff = Math.abs(current[i] - prev[i]);
+        if (diff > maxDiff) {
+            maxDiff = diff;
+        }
+    }
+    return maxDiff < tolerance;
+};
+
+// Convert 1D arrays to 2D matrices for Plotly
+export const convertTo2D = (array, width, height) => {
+    const matrix = [];
+    for (let j = 0; j < height; j++) {
+        const row = [];
+        for (let i = 0; i < width; i++) {
+            row.push(array[j * width + i]);
+        }
+        matrix.push(row);
+    }
+    return matrix;
+};
+
+
+// Compute and display difference
+export const calculateDifference = (grid1, grid2) => {
+    const difference = new Float64Array(grid1.length);
+    for (let i = 0; i < grid1.length; i++) {
+        difference[i] = Math.abs(grid1[i] - grid2[i]);
+    }
+    return difference;
+};
+
+
+

package/initArrays.js

@@ -0,0 +1,63 @@
+// Utility functions for ADI method and diagonals generation
+
+const generateDiagonals = (length, alpha, gamma) => {
+    const lowerDiagonal = new Float64Array(length).fill(-alpha);
+    const mainDiagonal = new Float64Array(length).fill(1 + 2 * alpha + gamma);
+    const upperDiagonal = new Float64Array(length).fill(-alpha);
+    const rightHandSide = new Float64Array(length);
+    mainDiagonal[0] = 1 + alpha + gamma;
+    mainDiagonal[length - 1] = 1 + alpha + gamma;
+    lowerDiagonal[0] = 0;
+    upperDiagonal[length - 1] = 0;
+    return { lowerDiagonal, mainDiagonal, upperDiagonal, rightHandSide };
+};
+
+export const initADIArrays = (WIDTH, HEIGHT, DIFFUSION_RATE, deltaX, deltaT, decayRate) => {
+    const modifiedUpperDiagonal1 = new Float64Array(WIDTH);
+    const modifiedRightHandSide1 = new Float64Array(WIDTH);
+    const solution1 = new Float64Array(WIDTH);
+    const modifiedUpperDiagonal2 = new Float64Array(HEIGHT);
+    const modifiedRightHandSide2 = new Float64Array(HEIGHT);
+    const solution2 = new Float64Array(HEIGHT);
+    const intermediateConcentration = new Float64Array(WIDTH * HEIGHT);
+    const scaledSources = new Float64Array(WIDTH * HEIGHT);
+
+    const alpha = (DIFFUSION_RATE * deltaT) / (2 * deltaX * deltaX);
+    const gamma = (decayRate * deltaT) / 4;
+    const {
+        lowerDiagonal: a1,
+        mainDiagonal: b1,
+        upperDiagonal: c1,
+        rightHandSide: d1,
+    } = generateDiagonals(WIDTH, alpha, gamma);
+    const {
+        lowerDiagonal: a2,
+        mainDiagonal: b2,
+        upperDiagonal: c2,
+        rightHandSide: d2,
+    } = generateDiagonals(HEIGHT, alpha, gamma);
+    const halfDeltaT = deltaT / 2;
+    const oneMinus2AlphaMinusGamma = 1 - 2 * alpha - gamma;
+    return {
+        modifiedUpperDiagonal1,
+        modifiedRightHandSide1,
+        solution1,
+        modifiedUpperDiagonal2,
+        modifiedRightHandSide2,
+        solution2,
+        intermediateConcentration,
+        a1,
+        b1,
+        c1,
+        d1,
+        a2,
+        b2,
+        c2,
+        d2,
+        alpha,
+        halfDeltaT,
+        oneMinus2AlphaMinusGamma,
+        scaledSources,
+        deltaT,
+    };
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "handy-diffusion",
+  "version": "1.0.0",
+  "description": "algorithms to simulate diffusion",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CritalMediumBlue/diffusionForBacteria.git"
+  },
+  "keywords": [
+    "diffusion",
+    "ADI",
+    "Crank-Nicolson"
+  ],
+  "author": "Ricardo",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/CritalMediumBlue/diffusionForBacteria/issues"
+  },
+  "homepage": "https://github.com/CritalMediumBlue/diffusionForBacteria#readme"
+}

package/thomasAlgorithm.js

@@ -0,0 +1,132 @@
+/**
+ * Numerical tolerance for pivot detection to prevent division by zero.
+ * MATLAB and other solver documentation recommend tolerances around 1e-10.
+ * @constant {number}
+ */
+const tolerance = 1e-10;
+
+/**
+ * Solves a tridiagonal system of linear equations using the Thomas algorithm.
+ *
+ * The Thomas algorithm is a specialized form of Gaussian elimination for tridiagonal matrices
+ * that runs in O(n) time complexity. It's particularly useful for solving systems arising from
+ * finite difference discretizations of differential equations, such as diffusion equations.
+ *
+ * The algorithm solves systems of the form:
+ * ```
+ * [b₀ c₀  0  0 ...] [x₀]   [d₀]
+ * [a₁ b₁ c₁  0 ...] [x₁]   [d₁]
+ * [ 0 a₂ b₂ c₂ ...] [x₂] = [d₂]
+ * [ 0  0 a₃ b₃ ...] [x₃]   [d₃]
+ * [...            ] [..]   [..]
+ * ```
+ *
+ * @param {Float64Array|Array<number>} lowerDiagonal - Lower diagonal elements (a₁, a₂, ..., aₙ₋₁).
+ *                                        First element (index 0) is ignored as it doesn't exist.
+ * @param {Float64Array|Array<number>} mainDiagonal - Main diagonal elements (b₀, b₁, ..., bₙ₋₁).
+ * @param {Float64Array|Array<number>} upperDiagonal - Upper diagonal elements (c₀, c₁, ..., cₙ₋₂).
+ *                                        Last element (index n-1) is ignored as it doesn't exist.
+ * @param {Float64Array|Array<number>} rightHandSide - Right-hand side vector (d₀, d₁, ..., dₙ₋₁).
+ * @param {number} n - Size of the system (number of equations/unknowns).
+ * @param {Float64Array|Array<number>} modifiedUpperDiagonal - Pre-allocated array to store modified upper diagonal
+ *                                                during forward elimination. Must have length n.
+ * @param {Float64Array|Array<number>} modifiedRightHandSide - Pre-allocated array to store modified right-hand side
+ *                                                during forward elimination. Must have length n.
+ * @param {Float64Array|Array<number>} solution - Pre-allocated array where the solution vector will be stored.
+ *                                   Must have length n. Contains (x₀, x₁, ..., xₙ₋₁) after execution.
+ *
+ * @returns {void} The function modifies the `solution` array in-place.
+ *
+ * @note The algorithm handles near-singular matrices by replacing pivots smaller than
+ * 1e-10 with the tolerance value to prevent division by zero. For truly singular matrices,
+ * results may be numerically unstable.
+ *
+ * @complexity Time: O(n), Space: O(1) additional (uses pre-allocated arrays)
+ *
+ * @example
+ * // Solve a simple 3x3 tridiagonal system
+ * const n = 3;
+ * const lower = [0, 1, 1];          // First element unused
+ * const main = [2, 2, 2];
+ * const upper = [1, 1, 0];          // Last element unused
+ * const rhs = [3, 4, 3];
+ *
+ * // Pre-allocate working arrays
+ * const modUpper = new Float64Array(n);
+ * const modRHS = new Float64Array(n);
+ * const solution = new Float64Array(n);
+ *
+ * thomasAlgorithm(lower, main, upper, rhs, n, modUpper, modRHS, solution);
+ * console.log(solution); // [1, 1, 1]
+ *
+ * @see {@link ADI} Uses this algorithm for implicit solving
+ * @see {@link initADIArrays} Pre-allocates working arrays
+ *
+ */
+export function thomasAlgorithm(
+    lowerDiagonal,
+    mainDiagonal,
+    upperDiagonal,
+    rightHandSide,
+    n,
+    modifiedUpperDiagonal,
+    modifiedRightHandSide,
+    solution
+) {
+    // =====================================================================
+    // FORWARD ELIMINATION PHASE
+    // =====================================================================
+    // Transform the tridiagonal matrix to upper triangular form by eliminating
+    // the lower diagonal elements. This modifies the upper diagonal and RHS.
+
+    // Handle the first row (i = 0)
+    // Check for near-zero pivot to prevent numerical instability
+    let pivot = mainDiagonal[0];
+    if (Math.abs(pivot) < tolerance) {
+        // Replace near-zero pivot with tolerance to avoid division by zero
+        pivot = pivot >= 0 ? tolerance : -tolerance;
+    }
+    const invPivot = 1.0 / pivot;
+
+    // Normalize first row: divide upper diagonal and RHS by pivot
+    modifiedUpperDiagonal[0] = upperDiagonal[0] * invPivot;
+    modifiedRightHandSide[0] = rightHandSide[0] * invPivot;
+
+    // Process remaining rows (i = 1 to n-1)
+    for (let i = 1; i < n; i++) {
+        const l_i = lowerDiagonal[i]; // Lower diagonal element at row i
+        const u_prime_prev = modifiedUpperDiagonal[i - 1]; // Modified upper diagonal from previous row
+        const d_prime_prev = modifiedRightHandSide[i - 1]; // Modified RHS from previous row
+
+        // Calculate the new diagonal element after eliminating lower diagonal
+        // This is: b_i - a_i * c'_{i-1}
+        let currentDenominator = mainDiagonal[i] - l_i * u_prime_prev;
+
+        // Check for near-zero denominator to prevent numerical instability
+        if (Math.abs(currentDenominator) < tolerance) {
+            // Replace near-zero denominator with tolerance to avoid division by zero
+            currentDenominator = currentDenominator >= 0 ? tolerance : -tolerance;
+        }
+        const invDenominator = 1.0 / currentDenominator;
+
+        // Update modified arrays for current row
+        // Modified upper diagonal: c_i / (b_i - a_i * c'_{i-1})
+        modifiedUpperDiagonal[i] = upperDiagonal[i] * invDenominator;
+        // Modified RHS: (d_i - a_i * d'_{i-1}) / (b_i - a_i * c'_{i-1})
+        modifiedRightHandSide[i] = (rightHandSide[i] - l_i * d_prime_prev) * invDenominator;
+    }
+
+    // =====================================================================
+    // BACKWARD SUBSTITUTION PHASE
+    // =====================================================================
+    // Solve the upper triangular system by working backwards from the last equation.
+
+    // Last equation is already solved: x_{n-1} = d'_{n-1}
+    solution[n - 1] = modifiedRightHandSide[n - 1];
+
+    // Solve remaining equations working backwards
+    for (let i = n - 2; i >= 0; i--) {
+        // x_i = d'_i - c'_i * x_{i+1}
+        solution[i] = modifiedRightHandSide[i] - modifiedUpperDiagonal[i] * solution[i + 1];
+    }
+}