log1p — Accurate element-wise computation of log(1 + x) for scalars, vectors, matrices, or N-D tensors.

Y = log1p(X) evaluates log(1 + X) element-wise with high accuracy for values of X close to zero. It mirrors MATLAB semantics across scalars, vectors, matrices, logical arrays, character arrays, and complex inputs.

Syntax

Y = log1p(X)

• X is a numeric array of any shape — scalars, vectors, matrices, or N-D tensors. Real and complex inputs are both supported; logical and character inputs are promoted to double before evaluation.
• Y has the same shape as X and equals log(1 + X) computed element-wise with high accuracy for small |X|. For X = -1 the result is -Inf; for real X < -1 the output promotes to complex (principal branch).
• Use log1p instead of log(1 + x) whenever x can be close to zero. Forming 1 + x in double precision drops bits of x (catastrophic cancellation), so log(1 + 1e-15) is wrong by nearly 10%, while log1p(1e-15) is correct to the last bit.

How log1p works

• Logical inputs are promoted to double precision (true -> 1.0, false -> 0.0) before execution.
• Character arrays are interpreted as their numeric code points and return dense double tensors.
• Values equal to -1 yield -Inf, matching MATLAB's handling of log(0).
• Inputs smaller than -1 promote to complex outputs: log1p(-2) returns 0 + iπ.
• Complex inputs follow MATLAB's definition by computing the natural logarithm of 1 + z.
• Existing GPU tensors remain on the device when the registered provider implements unary_log1p alongside reduce_min. RunMat queries the device-side minimum to confirm the data stays within the real-valued domain; otherwise it gathers to the host, computes the exact result, and preserves residency metadata.

How RunMat runs log1p on the GPU

RunMat Accelerate keeps tensors resident on the GPU whenever the provider exposes the unary_log1p hook together with reduce_min. The runtime uses the device-side minimum to ensure that 1 + X stays non-negative; when complex outputs are required or either hook is missing, RunMat automatically gathers the tensor, computes on the CPU using double precision, and returns the result with the expected MATLAB semantics.

GPU memory and residency

G = gpuArray(linspace(-0.5, 0.5, 5));
out = log1p(G);
realResult = gather(out);

Expected output:

realResult = [-0.6931 -0.2877 0 0.2231 0.4055];

Examples

Protecting precision when adding tiny percentages

delta = 1e-12;
value = log1p(delta)

Expected output:

value = 9.999999999995e-13

Computing log-growth factors from percentage changes

rates = [-0.25 -0.10 0 0.10 0.25];
growth = log1p(rates)

Expected output:

growth = [-0.2877 -0.1054 0 0.0953 0.2231]

Handling the branch cut at x = -1

y = log1p(-1)

Expected output:

y = -Inf

Obtaining complex results for inputs less than -1

data = [-2 -3 -5];
result = log1p(data)

Expected output:

result = [0.0000 + 3.1416i, 0.6931 + 3.1416i, 1.3863 + 3.1416i]

Executing log1p on GPU arrays with automatic residency

G = gpuArray(linspace(-0.5, 0.5, 5));
out = log1p(G);
realResult = gather(out)

Expected output:

realResult = [-0.6931 -0.2877 0 0.2231 0.4055]

FAQ

Related Math functions

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how log1p works, line by line, in Rust.

• View log1p.rs on GitHub
• Learn how the runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code — faster, on any GPU, with no license required.

• Simulations that took hours now take minutes. RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed.
• Start running code in seconds. Open the browser sandbox or download a single binary. No license server, no IT ticket, no setup.
• A full development environment. GPU-accelerated 2D and 3D plotting, automatic versioning on every save, and a browser IDE you can share with a link.

Getting started · Benchmarks · Pricing