TinyExpr++

Notepad3 includes TinyExpr++, a math expression parser and evaluator. It is used in several places throughout the application to let you write and evaluate math formulas directly.

Where Expressions Are Used

1. Inline Expression Evaluation (=?)

Type a math expression followed by =? (or = then press Enter) to evaluate it in-place.

Enable: Menu → Settings → Evaluate TinyExpr on Selection

Example:

(3+4)*5=?

The =? and the expression are replaced with the result: 35

This also works with selected text — select a math expression, and its result appears in the status bar.

2. Status Bar Expression Display

When Evaluate TinyExpr on Selection is enabled, selecting any text containing a valid expression shows its computed value in the status bar's TinyExpr field.

Multi-selection / rectangular selection is supported — selected values are concatenated and evaluated as a single expression.

Output modes — decimal · hexadecimal · binary

The TinyExpr status field can display the result in three integer-result formats. The active mode applies to every subsequent evaluation, and is process-local — it resets to decimal on the next Notepad3 launch.

Mode	Example output	Notes
Decimal (default)	15, 3.14, Inf	Existing format; integers use up to 21 significant digits, floats %.8G.
Hexadecimal	0xF, 0xFF, 0xFFFFFFFF	Uppercase, no padding.
Binary	0b1111, 0b11111111	Lowercase b prefix, no padding.

In hex / binary, fractional results are rounded to the nearest integer (round-half-away-from-zero). Negative values are shown in two's-complement (-1 → 0xFFFFFFFF / 32 ones). Values outside the supported integer range, NaN, and Inf fall back to the decimal %.8G representation for that single evaluation.

Effective bit width is chosen at runtime via te_supports_64bit() — currently 32 bits on the standard MSVC build (where the parser's double has a 53-bit mantissa). The display widens automatically to 64 bits if the parser is ever rebuilt with a 64-bit-precise numeric type.

Empty selection placeholder also reflects the active mode: --, 0x--, or 0b--.

Parse error indicator carries the same prefix: a syntax error at column N is shown as ^[N] (decimal), 0x^[N] (hex), or 0b^[N] (binary).

Status-bar gestures on the TinyExpr field

Gesture	Action
Single left-click	Copies the currently displayed result (in the active mode) to the clipboard. The copy is debounced by the system double-click interval, so a follow-up double-click cancels the copy.
Double-click	Cycles output mode: Decimal → Hexadecimal → Binary → Decimal … The status field refreshes immediately.
Right-click	Standard status-bar context menu (unchanged).

Binary input

Expressions may also use binary literals 0b… (or 0B…), in addition to the always-supported decimal, scientific, and hex (0x…) literals. They round-trip the binary output mode:

0b101010=?            → 42
0xFF + 0b1=?          → 256
BITAND(0b1100, 0b1010)=?  → 8

Binary literals are recognized only at token-start positions, so identifiers like var0b1 are not affected.

3. Go to Line / Column Dialog

The Go to Line dialog (Ctrl+G) accepts expressions, not just numbers:

Input	Result
100	Goes to line 100
50+25	Goes to line 75
2^10	Goes to line 1024

The same applies to the Column field.

4. Line Number Expressions (Modify Lines)

The Modify Lines dialog (Alt+M) supports expressions in its prefix/append patterns using the ${expression} syntax. Three variables are available:

Variable	Description
L	Current 1-based line number in the file
I	Zero-based iteration index (0, 1, 2, …)
N	One-based iteration counter (1, 2, 3, …)

Examples:

Pattern	Lines 5–8 produce
${N}	1, 2, 3, 4
${L}	5, 6, 7, 8
${N*10}	10, 20, 30, 40
${L^2}	25, 36, 49, 64
${0N}	1, 2, 3, 4 (zero-padded)

5. Auto-Save Interval

The auto-save interval field in Settings accepts expressions (e.g., 60*5 for 5 minutes).

6. Dark Mode Contrast Setting

The Dark Mode highlight contrast value in the Customize Schemes dialog accepts expressions.

---

Expression Syntax

Numbers

Format	Example	Value
Integer	42	42
Decimal	3.14	3.14
Leading dot	.5	0.5
Hexadecimal	0x1F	31
Binary	0b101010	42
Scientific	1e3	1000
Negative scientific	2.5e-2	0.025

Binary literals (0b… / 0B…) are a Notepad3 extension on top of TinyExpr++ — they are rewritten to decimal before the parser sees them.

Operators (by Precedence)

From highest to lowest precedence:

Precedence	Operators	Description
1	( )	Grouping
2	+ - ~	Unary plus, minus, bitwise NOT
3	^ **	Exponentiation
4	* / %	Multiply, divide, modulus
5	+ -	Add, subtract
6	<< >> <<< >>>	Bit shift, bit rotate
7	< > <= >=	Relational comparison
8	= == <> !=	Equality / inequality
9	&&	Logical AND
10	||	Logical OR

Note: % is the modulus operator (remainder), not a percentage sign.

Examples:

5+5+5/2       → 12.5   (division before addition)
(5+5+5)/2     → 7.5    (parentheses override precedence)
2+$5^{2}$         → 27     (exponentiation before addition)
(2+5)^2       → 49
10 % 3        → 1      (remainder of 10÷3)

Important — a single = inside an expression means equality, not assignment. TinyExpr++ has no assignment operator, so within an expression a lone = is treated exactly like ==. That means:

1+1=2+2    → 0     (parses as (1+1) == (2+2), i.e. 2 == 4 → false)
1+1=2      → 1     (parses as (1+1) == 2,     i.e. 2 == 2 → true)

Use == explicitly when you want the equality intent to be obvious, and parenthesize freely. Note the distinction from the inline-evaluation suffix =? and the "type = then press Enter" trigger described above — those are UI markers that ask Notepad3 to evaluate the expression, not part of the expression itself. A leading = at the very start is stripped by the parser to tolerate spreadsheet-style input like =SUM(1,2); equality semantics only apply to a = that appears between two operands.

Constants

Constant	Value
PI	3.14159265358979…
E	2.71828182845905…
TRUE	1
FALSE	0
NAN	Not-a-Number (invalid)

Comments

C/C++ style comments are supported inside expressions:

(3 + 4) /* this is a comment */ * 2    → 14
5 + 3   // rest of line is ignored     → 8

---

Function Reference

All function names are case-insensitive (sin, SIN, Sin all work).

Basic Math

Function	Description	Example
ABS(x)	Absolute value	ABS(-5) → 5
CEIL(x)	Round up to integer	CEIL(2.3) → 3
FLOOR(x)	Round down to integer	FLOOR(2.7) → 2
ROUND(x, n)	Round to n decimal places	ROUND(3.456, 2) → 3.46
TRUNC(x)	Discard fractional part	TRUNC(3.7) → 3
SIGN(x)	Sign: 1, 0, or −1	SIGN(-7) → -1
CLAMP(x, lo, hi)	Constrain to range	CLAMP(15, 0, 10) → 10
EVEN(x)	Round up to nearest even	EVEN(3) → 4
ODD(x)	Round up to nearest odd	ODD(4) → 5

Powers & Roots

Function	Description	Example
SQRT(x)	Square root	SQRT(16) → 4
POW(x, y)	x raised to y	POW(2, 10) → 1024
POWER(x, y)	Alias for POW
EXP(x)	e raised to x	EXP(1) → 2.71828…

Logarithms

Function	Description	Example
LN(x)	Natural log (base e)	LN(E) → 1
LOG10(x)	Common log (base 10)	LOG10(1000) → 3
LOG(x)	Same as LOG10 (compatibility)	LOG(100) → 2

Trigonometry

Function	Description
SIN(x)	Sine (radians)
COS(x)	Cosine (radians)
TAN(x)	Tangent
COT(x)	Cotangent
ASIN(x)	Arcsine → radians
ACOS(x)	Arccosine → radians
ATAN(x)	Arctangent → radians
ATAN2(y, x)	Arctangent of y/x → radians
SINH(x)	Hyperbolic sine
COSH(x)	Hyperbolic cosine

Statistics

Function	Description	Example
SUM(a, b, …)	Sum of values (up to 24 args)	SUM(1,2,3) → 6
AVERAGE(a, b, …)	Mean of values (up to 24 args)	AVERAGE(2,4,6) → 4
MIN(a, b, …)	Smallest value (up to 24 args)	MIN(3,1,2) → 1
MAX(a, b, …)	Largest value (up to 24 args)	MAX(3,1,2) → 3

Combinatorics

Function	Description	Example
FAC(n) / FACT(n)	Factorial (n!)	FAC(5) → 120
COMBIN(n, k) / NCR(n, k)	Combinations	COMBIN(5,2) → 10
PERMUT(n, k) / NPR(n, k)	Permutations	PERMUT(5,2) → 20
TGAMMA(x) / GAMMA(x)	Gamma function

Logic

Function	Description	Example
IF(cond, yes, no)	Conditional	IF(1>2, 10, 20) → 20
IFS(c1,v1, c2,v2, …)	Multi-condition (up to 12 pairs)	IFS(0,1, 1,2) → 2
AND(a, b, …)	All true? (up to 24 args)	AND(1,1,0) → 0
OR(a, b, …)	Any true? (up to 24 args)	OR(0,0,1) → 1
NOT(x)	Logical negation	NOT(0) → 1

Error Checking

Function	Description
NA() / NAN	Returns NaN (invalid value)
ISERR(x) / ISERROR(x)	1 if x is NaN, else 0
ISNA(x) / ISNAN(x)	Alias for ISERR
ISEVEN(x)	1 if x is even
ISODD(x)	1 if x is odd

Bitwise Operations

Function	Description
BITAND(a, b)	Bitwise AND
BITOR(a, b)	Bitwise OR
BITXOR(a, b)	Bitwise XOR
BITNOT(x)	Bitwise NOT (auto-selects 32 or 64 bit)
BITLSHIFT(x, n)	Left shift by n
BITRSHIFT(x, n)	Right shift by n
RAND()	Random number between 0 and 1

Financial Functions

Function	Description
FV(rate, nper, pmt, [pv], [type])	Future value
PV(rate, nper, pmt, [fv], [type])	Present value
PMT(rate, nper, pv, [fv], [type])	Periodic payment
NPER(rate, pmt, pv, [fv], [type])	Number of periods
IPMT(rate, per, nper, pv, [fv], [type])	Interest portion
PPMT(rate, per, nper, pv, [fv], [type])	Principal portion

Optional parameters […] default to 0. The type parameter: 0 = end of period, 1 = beginning.

---

Practical Examples

Quick Calculations

256*1024=?                → 262144
SQRT($3^{2}$ + $4^{2}$)=?        → 5
2*PI*6.371e6=?            → 40030173.592…  (Earth's circumference in meters)

Unit Conversions

72 * 0.0254=?             → 1.8288             (72 inches to meters)
100 / 2.54=?              → 39.3700787401575   (100 cm to inches)
(98.6 - 32) * 5/9=?      → 37                  (Fahrenheit to Celsius)

Programming Helpers

0xFF=?                    → 255
0b101010=?                → 42
$2^{16}$ - 1=?               → 65535
BITLSHIFT(1, 20)=?       → 1048576  (1 MB in bytes)
BITAND(0xF0, 0x3C)=?     → 48
BITAND(0b1100, 0b1010)=? → 8

Line Numbering (Modify Lines Dialog)

Goal	Prefix pattern
Simple line numbers	${N}.
Multiples of 10	${N*10}:
Even numbers only	${N*2}:
Squared sequence	${N^2}
Zero-padded (001, 002…)	${0N}.
Reverse from 100	${100-I}
Starting from line number	${L}:

Conditional Logic

IF(5>3, 100, 200)=?                         → 100
IF(AND(10>=5, 10<=15), 1, 0)=?              → 1   (range check)
IFS(90>=90, 4, 90>=80, 3, 90>=70, 2, 1,1)=? → 4   (grading)

---

Locale-Aware Number Formatting

TinyExpr++ in Notepad3 automatically adapts to the decimal separator of the active UI language. When Notepad3 is set to a locale that uses a comma as the decimal mark (e.g., German, French, Spanish), the expression engine switches accordingly:

	English (en-US)	German (de-DE)
Decimal separator	. (dot)	, (comma)
Function argument separator	, (comma)	; (semicolon)
Number example	3.14	3,14
Function call	SUM(1.5, 2)	SUM(1,5; 2)
Inline evaluation	1/3=? → 0.333333333333333	1/3=? → 0,333333333333333

Examples by Locale

English (dot decimal):

ROUND(PI, 4)=?           → 3.1416
SUM(1.5, 2.5, 3)=?       → 7
IF(2.5 > 1, 10, 20)=?    → 10

German / French / Spanish (comma decimal):

ROUND(PI; 4)=?            → 3,1416
SUM(1,5; 2,5; 3)=?        → 7
IF(2,5 > 1; 10; 20)=?     → 10

Tip: The separator style follows the Notepad3 UI language, which is set in Settings → Preferred Language. It does not change when editing files in different encodings.

---

C API: Boolean-Aware Evaluation (developer reference)

The C wrapper around TinyExpr++ exposes an evaluator that renders results of boolean-looking expressions as the words true / false, so callers don't have to invent their own classification scheme:

#include "tinyexpr_cif.h"

const char *te_interp_str(const char *expression, te_int_t *error);

The function evaluates the expression once and returns a thread-local internal buffer. The returned pointer remains valid until the next call from the same thread; *error follows the same convention as te_interp() (0 on success, 1-based parse-error position on failure).

Returned string	When
"true" / "false"	Expression is lexically logical and evaluates to exactly 1.0 / 0.0.
"nan", "inf", "-inf"	Result is non-finite (e.g., 0/0, LN(0), comparison involving NaN).
Integer-like (%.21g)	Finite value whose fractional part is below 1e-15 and whose magnitude is below 1e21.
Decimal (%.15g)	All other finite results.

The numeric formatting mirrors Notepad3's TinyExprToStringA exactly, so values returned by te_interp_str() match what the status bar / =? inline-replacement would render. Hex / binary output modes are UI-level concerns and remain in TinyExprToStringA proper.

When is an expression classified as logical?

Classification requires both of the following to hold:

1. Lexical hit at parenthesis depth 0 (one fully-enclosing outer pair is stripped first, so (1==1) is treated like 1==1):
   • a relational / equality / logical operator: ==, =, !=, <>, <=, >=, <, >, &&, ||, leading !
   • the bare keywords true / false
   • an outermost call to AND, OR, NOT, ISERR, ISERROR, ISNA, ISNAN, ISEVEN, or ISODD (case-insensitive)
2. Value hit: the finite evaluation result is exactly 0.0 or 1.0.

Bit-shift (<<, >>) and bit-rotate (<<<, >>>) are consumed by the scanner without triggering classification. Block comments (/* … */) and line comments (// …) are skipped, mirroring the parser.

IF / IFS are intentionally not in the predicate list — they return arbitrary user-supplied values, so IF(a>b, 5, 10) is numeric, not boolean.

Examples

Expression	Returns	Reason
1+1=2+2	"false"	Parses as (1+1) == (2+2); lone = is equality.
1+1=2	"true"	Same path; 2 == 2 is true.
(1==1)	"true"	Outer parens stripped before the lexical scan.
ISEVEN(4)	"true"	Top-level call to a predicate function.
1 && 0	"false"	Logical AND at depth 0.
!0	"true"	Unary logical-NOT.
IF(1>2, 100, 200)	"200"	IF is not a predicate; > is inside parens.
1 + (1==1)	"2"	== is inside parens, and the result isn't 0/1.
(1==1) * (2==2)	"1"	No comparison at depth 0; result is arithmetic.
0/0 == 1	"nan"	Non-finite result bypasses classification.
2*PI	"6.28318530717959"	No logical operator; %.15g format.

Why both checks? A purely value-based test would mis-label 1+0 as a boolean. A purely lexical test would mis-label IF(a>b, 5, 10) (which evaluates to 5 or 10, not 0/1). The intersection is much closer to user intent. te_interp() and te_compile() remain unchanged for callers that prefer to handle classification themselves.

---

Notes

• All function names are case-insensitive.
• LOG(x) is provided for backward compatibility and evaluates as LOG10(x).
• The % operator computes the modulus (remainder), not a percentage.
• Expressions support C/C++ style comments (/* … */ and // …).
• Invalid operations (division by zero, SQRT(-1)) return NaN.

For the full TinyExpr++ reference, see the TinyExpr++ documentation.