Lcapy is a Python library for symbolic linear circuit analysis and signal processing. It enables analysis of circuits in multiple domains (time, s-domain, frequency, discrete-time) using SymPy for symbolic mathematics. The library supports netlist-based circuit description, circuit solving via modified nodal analysis, transfer function analysis, noise analysis, state-space representation, and schematic generation using Circuitikz. It is designed for educational, research, and engineering applications in electrical engineering, providing both symbolic and numeric analysis capabilities.
ExprTk is a header-only C++ library for runtime mathematical expression parsing and evaluation. It provides a complete system for defining mathematical expressions as strings, compiling them into an internal AST representation, and evaluating them with variable values. The library supports scalar, vector, and string types, arithmetic operations, trigonometric functions, logarithms, control structures (if, for, while, switch), user-defined functions, and assignment operations within expressions. It employs sophisticated parsing techniques including constant folding, strength reduction optimizations, and runtime safety checks for vector bounds and loop execution time. The architecture consists of three main components: symbol table (for variables/constants/functions), expression (holding the parsed AST), and parser (compiling expression strings).
SymEngine.jl is a Julia wrapper for the SymEngine C++ symbolic mathematics library. It provides symbolic types (`Basic`), algebraic operations, calculus (differentiation, series expansion), substitution, numeric evaluation, and matrix operations (LU decomposition, determinants). The package uses C library calls via Julia's `ccall` and `SymEngine_jll` binaries, managing memory with finalizers. It extends Julia's generic interfaces (`+`, `*`, `diff`, etc.) for symbolic expressions and offers macros (`@vars`, `@funs`) for convenient variable and function declarations. The extension module for `TermInterface` allows integration with generic symbolic manipulation frameworks. The codebase is well-structured, with separate files for types, math operations, simplification, display, and dense matrix handling. It is production-ready, with CI testing across Julia versions and platforms, and is actively maintained with regular dependency updates via Dependabot. The primary use case is as a library for symbolic mathematics in Julia, suitable for research, education, and applications requiring algebraic manipulation.
Kalker is a multi-platform mathematical calculator implemented primarily in Rust. It provides a CLI with a REPL, a web component compiled to WebAssembly, and an Android mobile app via Capacitor. The core library (`kalk`) supports user-defined variables and functions, units, differentiation, integration, root finding, equation systems, matrices/vectors, complex numbers, and multiple number bases. The codebase is well-structured with a clear separation between parsing (lexer/parser), evaluation (interpreter), and a custom value system. It features extensive test files and integration tests for numerical methods. While the core numerical routines (tanh-sinh quadrature, Newton's method, Gaussian elimination) are tightly coupled to the interpreter, they are implemented with care and demonstrate non-trivial numerical analysis. The repository also includes build scripts for multiple targets and CI/CD pipelines.
This repository is the NumWorks Epsilon operating system and firmware for a graphing calculator. It is a complete software stack including a custom GUI framework (Escher), a symbolic math engine (Poincaré), a MicroPython interpreter, numerous educational apps (calculation, graphing, statistics, inference, finance, sequences, etc.), and low-level hardware drivers (Ion) for real devices and a cross-platform SDL-based simulator. The architecture is monolithic: all components share a custom memory pool, a responder-based UI framework, and a common record-based persistent storage system. Key entry points are the bootloader, the Ion::Main function, and an app container that launches snapshots of each app. The system handles user input through keyboard events, renders via a 2D graphics library (Kandinsky), and persists data (scripts, preferences, calculations) in a file-system-like record store. External dependencies include a vendored SDL 2.0 (for simulation), a bespoke MicroPython port, OpenBSD math functions, and an embedded SQLite memory allocator. While the math engine and many apps are well-crafted, the large third-party code and numerous platform backends introduce moderate technical drift risk.
Algebrite is a symbolic mathematics library (Computer Algebra System) written in TypeScript. It provides a comprehensive set of operations including symbolic differentiation, integration, polynomial factorization, root finding, matrix/tensor algebra, arbitrary-precision arithmetic, and expression simplification. Internally, it uses an S-expression representation (Cons cells) and a recursive-descent parser to convert string expressions into algebraic trees. The library exposes both a string-based `run()` API for evaluating expressions and direct method calls (e.g., `Algebrite.factor`). It was originally forked from EigenMath and retains some CoffeeScript legacy in test files and debug logging. The codebase is large and monolithic, with many modules tightly coupled through shared global state (the `defs` object). Despite this, the implementation is functional and covers a wide range of mathematical operations, making it suitable for embedding in interactive notebooks or computational tools.