✓ Stable v1.0.1

🧮 fortbite

High-precision mathematical calculator written in modern Fortran

FORTBITE (Fortran-based Operations on Real-Time Backend for Interactive Technical Expression) is a scientific calculator featuring arbitrary precision arithmetic, complex number support, matrix operations, and a comprehensive mathematical function library. Native Fortran 2008+ implementation with a clean REPL interface.

View on GitHub Download RPM

🎯 RPM Available

Installation

fortbite is available for Fedora/RHEL as an RPM package, and can be built from source using Make or the Fortran Package Manager (fpm).

Fedora / RHEL 9

# Add the musicsian repository (first time only) sudo dnf config-manager --add-repo https://repos.musicsian.com/musicsian.repo # Install fortbite sudo dnf install fortbite

From Source

# Prerequisites: gfortran >= 4.8 sudo dnf install gcc-gfortran make # Clone and build git clone https://github.com/FortranGoingOnForty/fortbite.git cd fortbite make make install # Install to /usr/local/bin

Quick Start

Launch fortbite to enter the interactive REPL (Read-Eval-Print Loop):

$ fortbite ====================================== FORTBITE High-Precision Calculator Modern Fortran Edition ====================================== Type "help" for commands or "exit" to quit. Use :: for precision (e.g., 3.14159::100) Use := for assignment (e.g., x := 42) fortbite>

Features

Arbitrary Precision Output: Display results with up to 100+ decimal digits
Complex Numbers: Full support for complex arithmetic and functions
Matrix Operations: Linear algebra, determinants, inverses, system solving
50+ Functions: Trigonometric, exponential, special, and statistical functions
Variable Storage: Assign and reuse values across calculations
Clean REPL: Interactive prompt with help and error handling

Dependencies

Build: gfortran ≥ 4.8, GNU Make
Runtime: gcc-gfortran-runtime, glibc

Configuration

fortbite has no configuration files. All settings are controlled at runtime through commands and expression syntax. This keeps the tool simple and portable.

Precision Settings

Default precision is double precision (15-16 significant digits). Output precision can be customized per-expression using the :: operator.

# Default precision (15-16 digits) fortbite> pi 3.1415926535897931 # Custom precision (50 digits) fortbite> pi::50 3.1415926535897932384626433832795028841971693993751 # Precision info command fortbite> precision Current precision: Double Precision Decimal digits: 15 Exponent range: ±307

Build Configuration

When building from source, compiler flags can be modified in the Makefile:

# Default compiler flags FC = gfortran FFLAGS = -Wall -Wextra -fcheck=all -g -O2 -std=f2008 # Flag explanations: # -Wall -Wextra : Enable all warnings # -fcheck=all : Runtime bounds/allocation checking # -g : Include debug symbols # -O2 : Level 2 optimization # -std=f2008 : Enforce Fortran 2008 standard

Constants

Option	Type	Default	Description
`pi`	constant	3.14159...	Circle constant (4 * atan(1))
`e`	constant	2.71828...	Euler's number (exp(1))
`i`	constant	sqrt(-1)	Imaginary unit

Overview

fortbite is a high-precision mathematical calculator designed for scientific computing, engineering calculations, and mathematical education. It provides a clean interactive interface with support for complex numbers, matrices, and a comprehensive function library.

Key Capabilities

Scalar Arithmetic: Standard math with proper operator precedence
Complex Numbers: Full arithmetic and function support
Matrix Algebra: Linear algebra operations and system solving
Special Functions: Gamma, error function, factorials, etc.
Variable Management: Store and reuse computed values
Custom Precision: Display results with arbitrary decimal places

Trigonometric

All trigonometric functions use radians:

Option	Type	Default	Description
`sin(x)`	function	-	Sine (radians)
`cos(x)`	function	-	Cosine (radians)
`tan(x)`	function	-	Tangent (radians)
`asin(x)`	function	-	Inverse sine (alias: arcsin)
`acos(x)`	function	-	Inverse cosine (alias: arccos)
`atan(x)`	function	-	Inverse tangent (alias: arctan)
`sec(x)`	function	-	Secant
`csc(x)`	function	-	Cosecant
`cot(x)`	function	-	Cotangent

fortbite> sin(pi/2) 1.0000000000000000 fortbite> cos(0) 1.0000000000000000 fortbite> asin(1) 1.5707963267948966 # = pi/2

Hyperbolic Functions

Option	Type	Default	Description
`sinh(x)`	function	-	Hyperbolic sine
`cosh(x)`	function	-	Hyperbolic cosine
`tanh(x)`	function	-	Hyperbolic tangent
`asinh(x)`	function	-	Inverse hyperbolic sine
`acosh(x)`	function	-	Inverse hyperbolic cosine
`atanh(x)`	function	-	Inverse hyperbolic tangent

Exponential & Logarithmic

Option	Type	Default	Description
`exp(x)`	function	-	e^x
`exp2(x)`	function	-	2^x
`exp10(x)`	function	-	10^x
`log(x)`	function	-	Natural logarithm (alias: ln)
`log10(x)`	function	-	Base-10 logarithm (alias: lg)
`log2(x)`	function	-	Base-2 logarithm
`expm1(x)`	function	-	exp(x) - 1 (accurate for small x)

fortbite> exp(1) 2.7182818284590451 fortbite> log(e) 1.0000000000000000 fortbite> log10(1000) 3.0000000000000000 fortbite> log2(256) 8.0000000000000000

Special Functions

Option	Type	Default	Description
`sqrt(x)`	function	-	Square root
`abs(x)`	function	-	Absolute value / magnitude
`factorial(n)`	function	-	n! (alias: fact)
`gamma(x)`	function	-	Gamma function
`lgamma(x)`	function	-	Log-gamma (alias: loggamma)
`erf(x)`	function	-	Error function
`erfc(x)`	function	-	Complementary error function
`floor(x)`	function	-	Floor (round down)
`ceil(x)`	function	-	Ceiling (round up)
`round(x)`	function	-	Nearest integer (alias: nint)
`frac(x)`	function	-	Fractional part (alias: fraction)

fortbite> factorial(10) 3628800.0000000000 fortbite> gamma(5) 24.000000000000000 # = 4! fortbite> erf(1) 0.84270079294971489 fortbite> floor(3.7) 3.0000000000000000 fortbite> frac(3.7) 0.69999999999999996

Complex Operations

Option	Type	Default	Description
`real(z)`	function	-	Real part (alias: re)
`imag(z)`	function	-	Imaginary part (alias: im)
`conj(z)`	function	-	Complex conjugate (alias: conjugate)
`abs(z)`	function	-	Magnitude (aliases: cabs, modulus)
`arg(z)`	function	-	Phase angle (aliases: phase, angle)
`cmplx(a,b)`	function	-	Create complex from real parts

fortbite> z := 3 + 4i 3.0000000000000000+4.0000000000000000i fortbite> abs(z) 5.0000000000000000 fortbite> conj(z) 3.0000000000000000-4.0000000000000000i fortbite> z * conj(z) 25.000000000000000+0.0000000000000000i # Euler's formula fortbite> exp(i*pi) + 1 1.2246467991473532e-16+0.0000000000000000i # ≈ 0

Linear Algebra

Option	Type	Default	Description
`zeros(m,n)`	function	-	m x n zero matrix
`ones(m,n)`	function	-	m x n ones matrix
`eye(n)`	function	-	n x n identity matrix
`diag(v)`	function	-	Diagonal matrix from vector
`transpose(A)`	function	-	Matrix transpose
`det(A)`	function	-	Determinant
`inv(A)`	function	-	Matrix inverse
`trace(A)`	function	-	Sum of diagonal elements
`rank(A)`	function	-	Matrix rank
`solve(A,b)`	function	-	Solve Ax = b
`sum(M)`	function	-	Sum all elements
`mean(M)`	function	-	Mean (alias: average)
`std(M)`	function	-	Standard deviation (alias: stddev)

fortbite> A := [2,3;1,-1] [2x2 matrix] 2.0 3.0 1.0 -1.0 fortbite> det(A) -5.0000000000000000 fortbite> inv(A) [2x2 matrix] 0.2 0.6 0.2 -0.4 # Solve Ax = b fortbite> b := [8;1] fortbite> solve(A, b) [2x1 matrix] 2.2 1.2

System Overview

fortbite is implemented in approximately 28,000 lines of modern Fortran (2008+) across 11 modules plus the main program. The architecture follows a classic compiler design pattern: lexer → parser → evaluator.

Codebase Statistics

Total: ~28,000 lines of Fortran
Modules: 11 specialized modules
Build System: Makefile + fpm.toml
Standard: Fortran 2008

Module Structure

fortbite/
├── src/
│   ├── fortbite.f90              # Main program (REPL entry)
│   ├── fortbite_precision_m.f90  # Precision management
│   ├── fortbite_types_m.f90      # Core data types
│   ├── fortbite_lexer_m.f90      # Tokenization
│   ├── fortbite_ast_m.f90        # Abstract Syntax Tree
│   ├── fortbite_parser_m.f90     # Parsing
│   ├── fortbite_evaluator_m.f90  # Expression evaluation
│   ├── fortbite_arithmetic_m.f90 # Arithmetic operations
│   ├── fortbite_functions_m.f90  # Math function library
│   ├── fortbite_matrix_m.f90     # Linear algebra
│   └── fortbite_io_m.f90         # REPL interface
└── test/                         # Test suite

Lexer

The lexer (fortbite_lexer_m.f90) converts input strings into token streams. It recognizes:

Numbers (integers, decimals, scientific notation)
Identifiers (variable and function names)
Operators: +, -, *, /, ^, **, %
Special tokens: (, ), [, ], ;, ,, :=, ::
Imaginary suffix: i

Parser

The parser (fortbite_parser_m.f90) builds Abstract Syntax Trees from token streams using recursive descent with precedence climbing.

AST Node Types

AST_LITERAL - Constant values
AST_IDENTIFIER - Variable/constant names
AST_BINARY_OP - Binary operations
AST_UNARY_OP - Unary operations
AST_FUNCTION_CALL - Function invocations
AST_ASSIGNMENT - Variable assignment
AST_PRECISION_SPEC - Precision specification
AST_MATRIX_LITERAL - Matrix notation

Evaluator

The evaluator (fortbite_evaluator_m.f90) executes ASTs with automatic type promotion:

Scalar + Scalar → Scalar
Scalar + Complex → Complex
Scalar + Matrix → Element-wise operation
Matrix + Matrix → Matrix (dimension-checked)

The evaluator maintains a symbol table (linked list) for variable storage and dispatches function calls to specialized evaluation routines.

Type System

The value_t type is the universal value container:

type :: value_t
    integer :: value_type      ! SCALAR, COMPLEX, MATRIX

    ! Union-like storage
    real(real64) :: scalar_val
    complex(real64) :: complex_val
    real(real64), allocatable :: matrix_val(:,:)
    complex(real64), allocatable :: complex_matrix_val(:,:)

    ! Matrix metadata
    integer :: rows, cols
    logical :: is_complex_matrix
end type value_t

Data Flow

User Input
    ↓
┌─────────────────────┐
│ I/O (fortbite_io_m) │ ← Read input, check if command
└──────────┬──────────┘
           ↓
  ┌────────────────────┐
  │ Lexer (lexer_m)    │ ← Tokenize input string
  └─────────┬──────────┘
            ↓
┌───────────────────────┐
│ Parser (parser_m)     │ ← Build AST from tokens
└──────────┬────────────┘
           ↓
┌──────────────────────────────────┐
│ Evaluator (evaluator_m)          │
│  ├─ Arithmetic (arithmetic_m)    │
│  ├─ Functions (functions_m)      │
│  ├─ Matrix ops (matrix_m)        │
│  └─ Variables (symbol table)     │
└──────────┬───────────────────────┘
           ↓
┌──────────────────────┐
│ Result (value_t)     │ ← Scalar, Complex, or Matrix
└──────────┬───────────┘
           ↓
       Display

Commands

Option	Type	Default	Description
`help`	command	-	Display help information (aliases: h, ?)
`exit`	command	-	Exit the calculator (aliases: quit, q)
`clear`	command	-	Clear the screen (alias: cls)
`precision`	command	-	Show current precision settings
`info`	command	-	Display system information
`vars`	command	-	List all defined variables (alias: variables)

Operators

Option	Type	Default	Description
`+`	operator	-	Addition
`-`	operator	-	Subtraction / Unary negation
`*`	operator	-	Multiplication / Matrix multiplication
`/`	operator	-	Division
`^`	operator	-	Exponentiation (right-associative)
`**`	operator	-	Exponentiation (alias for ^)
`%`	operator	-	Modulo (remainder)
`:=`	operator	-	Variable assignment
`::`	operator	-	Precision specification

Trigonometric Functions

Option	Type	Default	Description
`sin(x)`	function	-	Sine (radians)
`cos(x)`	function	-	Cosine (radians)
`tan(x)`	function	-	Tangent (radians)
`asin(x)`	function	-	Inverse sine (alias: arcsin)
`acos(x)`	function	-	Inverse cosine (alias: arccos)
`atan(x)`	function	-	Inverse tangent (alias: arctan)
`sec(x)`	function	-	Secant
`csc(x)`	function	-	Cosecant
`cot(x)`	function	-	Cotangent

Exponential & Logarithmic Functions

Option	Type	Default	Description
`exp(x)`	function	-	e^x
`exp2(x)`	function	-	2^x
`exp10(x)`	function	-	10^x
`log(x)`	function	-	Natural logarithm (alias: ln)
`log10(x)`	function	-	Base-10 logarithm (alias: lg)
`log2(x)`	function	-	Base-2 logarithm
`expm1(x)`	function	-	exp(x) - 1 (accurate for small x)

Special Functions

Option	Type	Default	Description
`sqrt(x)`	function	-	Square root
`abs(x)`	function	-	Absolute value / magnitude
`factorial(n)`	function	-	n! (alias: fact)
`gamma(x)`	function	-	Gamma function
`lgamma(x)`	function	-	Log-gamma (alias: loggamma)
`erf(x)`	function	-	Error function
`erfc(x)`	function	-	Complementary error function
`floor(x)`	function	-	Floor (round down)
`ceil(x)`	function	-	Ceiling (round up)
`round(x)`	function	-	Nearest integer (alias: nint)
`frac(x)`	function	-	Fractional part (alias: fraction)

Complex Number Functions

Option	Type	Default	Description
`real(z)`	function	-	Real part (alias: re)
`imag(z)`	function	-	Imaginary part (alias: im)
`conj(z)`	function	-	Complex conjugate (alias: conjugate)
`abs(z)`	function	-	Magnitude (aliases: cabs, modulus)
`arg(z)`	function	-	Phase angle (aliases: phase, angle)
`cmplx(a,b)`	function	-	Create complex from real parts

Matrix Functions

Option	Type	Default	Description
`zeros(m,n)`	function	-	m x n zero matrix
`ones(m,n)`	function	-	m x n ones matrix
`eye(n)`	function	-	n x n identity matrix
`diag(v)`	function	-	Diagonal matrix from vector
`transpose(A)`	function	-	Matrix transpose
`det(A)`	function	-	Determinant
`inv(A)`	function	-	Matrix inverse
`trace(A)`	function	-	Sum of diagonal elements
`rank(A)`	function	-	Matrix rank
`solve(A,b)`	function	-	Solve Ax = b
`sum(M)`	function	-	Sum all elements
`mean(M)`	function	-	Mean (alias: average)
`std(M)`	function	-	Standard deviation (alias: stddev)

Constants

Option	Type	Default	Description
`pi`	constant	3.14159...	Circle constant (4 * atan(1))
`e`	constant	2.71828...	Euler's number (exp(1))
`i`	constant	sqrt(-1)	Imaginary unit

Build Issues

gfortran: command not found

Cause: GCC Fortran compiler not installed.

# Fedora / RHEL sudo dnf install gcc-gfortran # Verify installation gfortran --version

Module not found errors

Cause: Modules compiled out of order or parallel build race condition.

# Clean and rebuild sequentially make clean make -j1 # Force single-threaded build

Runtime Issues

Division by zero

fortbite> 1/0 Error: Division by zero # Solution: Ensure denominator is non-zero fortbite> x := 0.001 fortbite> 1/x 1000.0000000000000

Matrix dimensions incompatible

fortbite> [1,2] * [3,4] Error: Matrix dimensions incompatible for this operation # Matrix multiplication requires (m×n) × (n×p) # [1,2] is 1×2, [3,4] is 1×2 - can't multiply # Solution: Use proper dimensions fortbite> [1,2] * [3;4] [1x1 matrix] 11.0 # 1*3 + 2*4 = 11

Undefined variable

fortbite> x + 5 Error: Undefined variable: x # Solution: Define the variable first fortbite> x := 10 10.000000000000000 fortbite> x + 5 15.000000000000000 # List all defined variables fortbite> vars

Complex number notation not recognized

# Incorrect: 'i' alone is undefined fortbite> i*4 + 3 Error: Undefined variable: i # Correct: Use literal notation fortbite> 3 + 4i 3.0000000000000000+4.0000000000000000i # Or use the cmplx function fortbite> cmplx(3, 4) 3.0000000000000000+4.0000000000000000i

Performance

Large matrix operations are slow

Matrix inversion is O(n³). For very large matrices, operations become slow.

Use solve(A,b) instead of inv(A)*b (more efficient)
Break problems into smaller matrices if possible
10000×10000 matrices require ~800MB RAM

High-precision output is slow

Very high precision (1000+ digits) takes longer to compute:

Use reasonable precision (50-100 digits typically sufficient)
Default precision (15 digits) is fastest

Comparison with Other Calculators

fortbite vs bc

bc: POSIX standard, arbitrary precision by default
fortbite: Native complex/matrix support, richer function library
fortbite: More intuitive syntax for scientific computing

fortbite vs Python/NumPy

Python: Larger ecosystem, plotting, scripting
fortbite: Faster startup, no dependencies, single binary
fortbite: Better for quick calculations and education

Getting Help

# Display help fortbite> help # Show precision info fortbite> precision # List variables fortbite> vars # System information fortbite> info

🧮 fortbite

Installation

Fedora / RHEL 9

From Source

Quick Start

Features

Dependencies

Configuration

Precision Settings

Build Configuration

Constants

Overview

Key Capabilities

Expressions

Arithmetic

Operators & Precedence

Variables

Functions

Trigonometric

Hyperbolic Functions

Exponential & Logarithmic

Special Functions

Complex Numbers

Creating Complex Numbers

Complex Operations

Matrix Operations

Creating Matrices

Linear Algebra

Matrix Statistics

Precision Control

System Overview

Codebase Statistics

Module Structure

Lexer

Parser

AST Node Types

Evaluator

Type System

Data Flow

Commands

Operators

Trigonometric Functions

Exponential & Logarithmic Functions

Special Functions

Complex Number Functions

Matrix Functions

Constants

Build Issues

gfortran: command not found

Module not found errors

Runtime Issues

Division by zero

Matrix dimensions incompatible

Undefined variable

Complex number notation not recognized

Performance

Large matrix operations are slow

High-precision output is slow

Comparison with Other Calculators

fortbite vs bc

fortbite vs Python/NumPy

Getting Help