DEV Community: Alan Matthew

Punnett Square Simulator: Modeling Mendelian Inheritance and Hardy-Weinberg Equilibrium in JavaScript

Alan Matthew — Thu, 10 Sep 2026 10:04:07 +0000

Visualizing genetic allele distributions beyond simple single-gene traits can quickly become tedious when computing multi-gene combinatorial trees and phenotype ratios.

To make genetics intuitive and interactive, I built a pure JavaScript inheritance simulator that models both cross variations and population dynamics.

How It Works

Cartesian Combinatorics: The engine takes parental genotypes, determines all possible gamete configurations, and builds the full Cartesian product matrix (monohybrid $2 \times 2$, dihybrid $4 \times 4$).
Dominance Mapping: Evaluates complete, incomplete, and codominance allele interactions to output precise genotype and phenotype probability breakdowns.
Hardy-Weinberg Verification: Runs chi-square goodness-of-fit testing against population genetics distributions ($p^2 + 2pq + q^2 = 1$) to verify theoretical equilibrium states.

Test out the simulator: Punnett Square Simulator

What algorithmic models have you used to visualize biological simulations on the web? Discuss below!

Financial Amortization & NPV Calculator

Alan Matthew — Thu, 10 Sep 2026 09:54:53 +0000

Calculating financial metrics like Net Present Value (NPV) and dynamic loan amortization schedules is straightforward. Calculating the Internal Rate of Return (IRR) across irregular cash flow intervals, however, requires numerical approximation.

Here is how I implemented a fast, dependency-free financial modeling engine directly in the browser.

The IRR Convergence Algorithm

Because IRR represents the discount rate where $NPV = 0$, solving for it cannot be done via simple algebraic rearrangement. The engine implements the Newton-Raphson method:

$$r_{n+1} = r_n - \frac{f(r_n)}{f'(r_n)}$$

Where $f(r)$ represents the NPV function and $f'(r)$ is its first derivative with respect to the discount rate $r$. The loop iterates until the difference drops below an error tolerance ($\epsilon < 10^{-7}$), converging reliably in milliseconds without blocking UI threads.

Built-in Capabilities

Full month-by-month and year-by-year loan amortization schedules.
Principal vs. interest repayment curves.
Dynamic NPV and cash flow internal rate of return computations.

Run your financial models live: Financial Amortization & NPV Calculator

What numerical methods do you rely on for browser-based financial calculations? Drop your thoughts below!

Building an AST-Driven Propositional Truth Table Generator in JavaScript

Alan Matthew — Thu, 10 Sep 2026 09:50:14 +0000

Writing a simple boolean parser using JavaScript's built-in eval() is risky, error-prone, and doesn't support structured mathematical logic operators like material implication or biconditionals.

I built a lightweight, client-side discrete logic generator that constructs an Abstract Syntax Tree (AST) to evaluate expressions step by step.

How the Parser Works

Lexical Analysis: The scanner tokenizes raw input strings, recognizing variables ($p, q, r$), parentheses, and logical operators (AND, OR, NOT, XOR, IMPLIES, EQUIV).
Operator Precedence: Using the Shunting-Yard algorithm, infix notation is converted to an evaluation-ready syntax tree that preserves mathematical order of operations.
Exhaustive Evaluation: The engine iterates across all $2^n$ binary permutations, evaluating truth values across intermediate subexpression branches.

Features

Step-by-step intermediate truth table columns for verification.
Automated detection of tautologies, contradictions, and contingencies.
Fully client-side computation with zero latency.

Try the logic generator here: Truth Table Generator

What's your preferred approach for parsing nested logical grammar in JavaScript? Let me know in the comments!

Balancing Chemical Equations with Linear Algebra in Pure JavaScript

Alan Matthew — Thu, 10 Sep 2026 09:46:01 +0000

Balancing complex multi-phase chemical equations by inspection works for simple reactions, but it falls apart quickly when dealing with redox reactions and polyatomic complexes.

To solve this deterministically in the browser without server calls, I built a client-side linear algebra solver tailored for chemistry.

The Algorithm: Null-Space Vector Reduction
Instead of using trial-and-error recursive search trees, the engine represents chemical conservation as an augmented system of linear equations:

Atomic Matrix Construction: Every chemical formula is parsed into an element-frequency vector. Reactants carry negative values, while products carry positive values.
Matrix Normalization: Using IUPAC 2021 standard atomic weights, molecular masses are compiled dynamically.
Null-Space Kernel: The balanced coefficients represent the non-trivial integer null space (kernel) of the composition matrix, solved via Gaussian elimination over rational numbers to prevent floating-point rounding issues.

What the Engine Handles

Instant balancing for arbitrary chemical formulas.
Limiting reactant determination based on input gram weights.
Precise theoretical yield and excess reagent percentages.

Test the balancer live: Stoichiometry & Equation Balancer

Have you tackled chemical formula tokenization in JavaScript before? Share your approach below!