<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="color-scheme" content="dark light">
<meta name="description" content="stryke full reference — every builtin, keyword, alias, and extension with its LSP hover doc rendered as a static page.">
<title>stryke — Reference</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@400;600;700;900&family=Share+Tech+Mono&display=swap" rel="stylesheet">
<link rel="stylesheet" href="hud-static.css">
<link rel="stylesheet" href="tutorial.css">
<style>
.tutorial-main { max-width: 72rem; }
.docs-build-line {
margin: 0.35rem 0 0;
font-family: 'Share Tech Mono', ui-monospace, monospace;
font-size: 11px; color: var(--text-dim);
letter-spacing: 0.03em; max-width: 42rem; opacity: 0.75;
}
.hub-scheme-strip {
border-bottom: 1px dashed var(--border);
background: color-mix(in srgb, var(--bg-secondary) 85%, transparent);
padding: 0.55rem 1.5rem 0.65rem; position: relative;
}
.hub-scheme-strip-inner {
max-width: 72rem; margin: 0 auto;
display: flex; align-items: center; gap: 0.85rem;
}
.hub-scheme-strip .hud-scheme-label {
flex: 0 0 auto;
font-family: 'Orbitron', sans-serif; font-size: 9px; font-weight: 700;
letter-spacing: 2px; text-transform: uppercase; color: var(--accent);
}
.hub-scheme-strip .scheme-grid {
flex: 1 1 auto;
display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 6px;
}
@media (max-width: 720px) {
.hub-scheme-strip-inner { flex-direction: column; align-items: stretch; }
.hub-scheme-strip .scheme-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
}
.chapter-index {
list-style: none; padding: 0; margin: 0;
display: grid; grid-template-columns: repeat(auto-fill, minmax(18rem, 1fr));
gap: 0.3rem;
}
.chapter-index li {
border: 1px solid var(--border); padding: 0.45rem 0.65rem; border-radius: 2px;
background: color-mix(in srgb, var(--bg-card) 92%, transparent);
display: flex; justify-content: space-between; align-items: baseline;
}
.chapter-index li a {
color: var(--cyan); text-decoration: none; font-size: 13px;
font-family: 'Share Tech Mono', ui-monospace, monospace;
}
.chapter-index li a:hover { color: var(--accent-light); }
.chapter-count {
font-size: 10px; color: var(--text-muted);
font-family: 'Share Tech Mono', ui-monospace, monospace;
}
.chapter-meta {
font-size: 11px; color: var(--text-muted); margin: -0.3rem 0 0.8rem;
font-family: 'Share Tech Mono', ui-monospace, monospace;
}
.doc-entry {
margin: 1rem 0 1.4rem;
padding: 0.75rem 0.9rem 0.5rem;
border-left: 2px solid var(--cyan);
background: color-mix(in srgb, var(--bg) 94%, transparent);
border-radius: 2px;
}
.doc-entry h3 {
margin: 0 0 0.45rem;
font-family: 'Orbitron', sans-serif;
font-size: 13px; font-weight: 700; letter-spacing: 1.5px;
text-transform: uppercase; color: var(--cyan);
}
.doc-entry h3 code {
color: var(--accent-light); background: transparent; border: none;
padding: 0; font-size: 1em; letter-spacing: 0.5px;
}
.doc-entry .doc-anchor {
color: var(--text-muted); font-size: 0.85em; margin-right: 0.25rem;
text-decoration: none;
}
.doc-entry .doc-anchor:hover { color: var(--accent); }
.doc-entry h4 {
font-family: 'Orbitron', sans-serif;
font-size: 11px; font-weight: 700; letter-spacing: 1.5px;
text-transform: uppercase; color: var(--accent-light);
margin: 0.8rem 0 0.3rem;
}
.doc-entry p {
font-size: 13px; line-height: 1.6; color: var(--text-dim);
margin: 0.35rem 0;
}
.doc-entry p code, .doc-entry li code {
color: var(--accent-light); font-size: 12px;
}
.doc-entry ul { margin: 0.3rem 0 0.5rem; padding-left: 1.25rem; }
.doc-entry li { font-size: 13px; color: var(--text-dim); line-height: 1.55; margin: 0.2rem 0; }
.doc-entry pre {
font-family: 'Share Tech Mono', ui-monospace, monospace;
font-size: 12px;
background: var(--bg); border: 1px solid var(--border);
border-radius: 2px;
padding: 0.7rem 0.9rem; overflow-x: auto;
color: var(--text); margin: 0.5rem 0;
box-shadow: inset 0 0 18px rgba(0, 0, 0, 0.35);
}
.doc-entry pre code { color: var(--text); background: transparent; border: none; padding: 0; }
[data-theme="light"] .doc-entry pre { box-shadow: inset 0 0 10px rgba(0, 0, 0, 0.05); }
kbd {
font-family: 'Share Tech Mono', ui-monospace, monospace;
font-size: 11px;
padding: 1px 6px;
background: var(--bg-secondary);
border: 1px solid var(--border);
border-bottom-width: 2px;
border-radius: 3px;
color: var(--cyan);
}
</style>
</head>
<body>
<div class="app tutorial-app" id="docsApp">
<div class="crt-scanline" id="crtH" aria-hidden="true"></div>
<div class="crt-scanline-v" id="crtV" aria-hidden="true"></div>
<header class="tutorial-header">
<div class="tutorial-header-inner">
<div>
<h1 class="tutorial-brand">// STRYKE — FULL REFERENCE</h1>
<nav class="tutorial-crumbs" aria-label="Breadcrumb">
<a href="index.html">Docs</a>
<span class="sep">/</span>
<span class="current">Reference</span>
<span class="sep">/</span>
<a href="https://github.com/MenkeTechnologies/stryke" target="_blank" rel="noopener noreferrer">GitHub</a>
</nav>
<p class="docs-build-line">stryke v0.13.0 · 8320 topics · 162 chapters · generated from <code>src/lsp.rs</code></p>
</div>
<div class="tutorial-toolbar">
<button type="button" class="btn btn-secondary" id="btnTheme" title="Toggle light/dark">Theme</button>
<button type="button" class="btn btn-secondary active" id="btnCrt" title="CRT scanline overlay">CRT</button>
<button type="button" class="btn btn-secondary active" id="btnNeon" title="Neon border pulse">Neon</button>
<a class="btn btn-secondary" href="index.html">Hub</a>
<a class="btn btn-secondary" href="https://github.com/MenkeTechnologies/stryke" target="_blank" rel="noopener noreferrer">GitHub</a>
</div>
</div>
</header>
<div class="hub-scheme-strip">
<div class="hub-scheme-strip-inner">
<span class="hud-scheme-label">// Color scheme</span>
<div class="scheme-grid" id="hudSchemeGrid"></div>
</div>
</div>
<main class="tutorial-main">
<h2 class="tutorial-title"><span class="step-hash">>_</span>LANGUAGE REFERENCE</h2>
<p class="tutorial-subtitle">Every builtin, keyword, alias, and extension with an LSP hover doc — rendered from the exact markdown that `stryke docs` shows in the terminal. Jump via the chapter index, or <kbd>Ctrl+F</kbd> for a specific name.</p>
<section class="tutorial-section">
<h2>Chapters</h2>
<ul class="chapter-index">
<li><a href="#ch-parallel-primitives">Parallel Primitives</a> <span class="chapter-count">18</span></li>
<li><a href="#ch-shared-state-concurrency">Shared State & Concurrency</a> <span class="chapter-count">11</span></li>
<li><a href="#ch-pipeline-pipe-forward">Pipeline & Pipe-Forward</a> <span class="chapter-count">12</span></li>
<li><a href="#ch-streaming-iterators">Streaming Iterators</a> <span class="chapter-count">24</span></li>
<li><a href="#ch-list-operations">List Operations</a> <span class="chapter-count">62</span></li>
<li><a href="#ch-stryke-extensions">stryke Extensions</a> <span class="chapter-count">19</span></li>
<li><a href="#ch-data-serialization">Data & Serialization</a> <span class="chapter-count">45</span></li>
<li><a href="#ch-http-networking">HTTP & Networking</a> <span class="chapter-count">23</span></li>
<li><a href="#ch-crypto-encoding">Crypto & Encoding</a> <span class="chapter-count">133</span></li>
<li><a href="#ch-special-math-functions">Special Math Functions</a> <span class="chapter-count">12</span></li>
<li><a href="#ch-bessel-airy-hankel-struve-kelvin">Bessel / Airy / Hankel / Struve / Kelvin</a> <span class="chapter-count">19</span></li>
<li><a href="#ch-orthogonal-polynomials">Orthogonal Polynomials</a> <span class="chapter-count">13</span></li>
<li><a href="#ch-elliptic-integrals-functions">Elliptic Integrals & Functions</a> <span class="chapter-count">18</span></li>
<li><a href="#ch-zeta-polylog-lerch">Zeta / Polylog / Lerch</a> <span class="chapter-count">9</span></li>
<li><a href="#ch-hypergeometric">Hypergeometric</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-modular-forms">Modular Forms</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-si-ci-ei-li-fresnel-integrals">Si / Ci / Ei / Li / Fresnel Integrals</a> <span class="chapter-count">9</span></li>
<li><a href="#ch-number-theory-wolfram-parity">Number Theory (Wolfram Parity)</a> <span class="chapter-count">13</span></li>
<li><a href="#ch-combinatorics-wolfram-parity">Combinatorics (Wolfram Parity)</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-q-series-mittag-leffler-coulomb">q-Series, Mittag-Leffler, Coulomb</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-inverse-special-functions">Inverse Special Functions</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-piecewise-symbolic-primitives">Piecewise & Symbolic Primitives</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-number-theory-wolfram-parity-ii">Number Theory (Wolfram Parity II)</a> <span class="chapter-count">14</span></li>
<li><a href="#ch-combinatorial-sequences">Combinatorial Sequences</a> <span class="chapter-count">12</span></li>
<li><a href="#ch-linear-algebra-extended">Linear Algebra (Extended)</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-polynomial-algebra">Polynomial Algebra</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-distributions-extended">Distributions (Extended)</a> <span class="chapter-count">18</span></li>
<li><a href="#ch-mathieu-heun">Mathieu / Heun</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-wavelets">Wavelets</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-graph-algorithms-extended">Graph Algorithms (Extended)</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-number-theoretic-sums-constants">Number-Theoretic Sums & Constants</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-vector-calculus">Vector Calculus</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-optimization">Optimization</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-numerical-integration">Numerical Integration</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-linear-algebra-numeric">Linear Algebra (Numeric)</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-polynomial-helpers">Polynomial Helpers</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-quaternions-3d-rotations">Quaternions & 3D Rotations</a> <span class="chapter-count">12</span></li>
<li><a href="#ch-information-theory">Information Theory</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-quantum-primitives">Quantum Primitives</a> <span class="chapter-count">11</span></li>
<li><a href="#ch-statistical-mechanics">Statistical Mechanics</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-optics">Optics</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-astrodynamics">Astrodynamics</a> <span class="chapter-count">9</span></li>
<li><a href="#ch-time-series">Time Series</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-graph-centrality">Graph Centrality</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-random-samplers-extended">Random Samplers (Extended)</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-2-d-geometry">2-D Geometry</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-auto-differentiation">Auto-Differentiation</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-statistical-tests-r-parity">Statistical Tests (R parity)</a> <span class="chapter-count">12</span></li>
<li><a href="#ch-distance-metrics-distances-jl-parity">Distance Metrics (Distances.jl parity)</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-multivariate-non-central-distributions">Multivariate / Non-Central Distributions</a> <span class="chapter-count">9</span></li>
<li><a href="#ch-matrix-functions">Matrix Functions</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-adaptive-ode-solvers">Adaptive ODE Solvers</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-generalized-linear-models">Generalized Linear Models</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-bootstrap-resampling">Bootstrap & Resampling</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-time-series-operators">Time Series Operators</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-combinatorial-generators">Combinatorial Generators</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-dynamic-programming">Dynamic Programming</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-ml-metrics">ML Metrics</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-dsp-image-filters">DSP / Image Filters</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-stochastic-processes">Stochastic Processes</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-compression-information-complexity">Compression / Information Complexity</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-physics-quantum-extended">Physics & Quantum (Extended)</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-number-theory-algebra-extended">Number Theory & Algebra (Extended)</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-cas-lite">CAS-Lite</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-quadrature-specialised">Quadrature (Specialised)</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-optimization-heuristic">Optimization (Heuristic)</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-distributions-tail-mixture-categorical">Distributions (Tail / Mixture / Categorical)</a> <span class="chapter-count">14</span></li>
<li><a href="#ch-clustering-dimensionality-reduction">Clustering & Dimensionality Reduction</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-neural-net-primitives">Neural-Net Primitives</a> <span class="chapter-count">11</span></li>
<li><a href="#ch-time-series-spectral">Time Series (Spectral)</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-image-processing">Image Processing</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-loss-functions">Loss Functions</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-spatial-geographic">Spatial / Geographic</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-integer-sequences">Integer Sequences</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-graph-link-cluster-metrics">Graph Link & Cluster Metrics</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-3-d-geometry">3-D Geometry</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-iterative-solvers">Iterative Solvers</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-crypto-modular-algebra">Crypto / Modular Algebra</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-physics-chemistry">Physics & Chemistry</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-mcmc-sdes">MCMC & SDEs</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-hidden-markov-models">Hidden Markov Models</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-survival-analysis">Survival Analysis</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-sequence-alignment">Sequence Alignment</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-chemistry">Chemistry</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-control-theory">Control Theory</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-game-theory">Game Theory</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-operations-research">Operations Research</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-numerical-pde">Numerical PDE</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-bayesian-conjugate-updates">Bayesian Conjugate Updates</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-quantum-computing-gates">Quantum Computing Gates</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-splines-curves">Splines & Curves</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-music-audio">Music & Audio</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-astronomy-cosmology">Astronomy & Cosmology</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-fluid-dynamics">Fluid Dynamics</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-distributions-discrete-circular">Distributions (Discrete / Circular)</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-random-graph-generators">Random Graph Generators</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-color-science">Color Science</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-integer-sequences-combinatorial">Integer Sequences (Combinatorial)</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-multiple-testing-corrections">Multiple-Testing Corrections</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-probabilistic-distances">Probabilistic Distances</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-distributions-tail-inflated">Distributions (Tail / Inflated)</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-astrophysics-radiation">Astrophysics & Radiation</a> <span class="chapter-count">9</span></li>
<li><a href="#ch-chemistry-beer-rate-colligative">Chemistry (Beer / Rate / Colligative)</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-mixed-strategy-game-theory">Mixed-Strategy Game Theory</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-computer-graphics">Computer Graphics</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-dsp-hilbert-cepstrum-filter-design">DSP (Hilbert / Cepstrum / Filter Design)</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-image-processing-edges-bilateral">Image Processing (Edges / Bilateral)</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-clustering-helpers">Clustering Helpers</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-combinatorics-tableaux-boustrophedon">Combinatorics (Tableaux / Boustrophedon)</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-number-theory-tetration-smoothness">Number Theory (Tetration / Smoothness)</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-network-coreness-structure">Network Coreness & Structure</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-crypto-helpers">Crypto Helpers</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-quantum-entanglement">Quantum Entanglement</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-2-d-geometry-polygons-circles">2-D Geometry (Polygons & Circles)</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-time-series-smoothing">Time-Series Smoothing</a> <span class="chapter-count">1</span></li>
<li><a href="#ch-bioinformatics">Bioinformatics</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-geographic-map-projection">Geographic / Map Projection</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-fixed-income-finance">Fixed-Income Finance</a> <span class="chapter-count">5</span></li>
<li><a href="#ch-image-quality-metrics">Image Quality Metrics</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-acoustics">Acoustics</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-population-genetics">Population Genetics</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-epidemiology">Epidemiology</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-inequality-measures">Inequality Measures</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-apl-j-array-primitives">APL / J Array Primitives</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-plasma-physics">Plasma Physics</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-string-similarity">String Similarity</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-rating-systems">Rating Systems</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-effect-sizes">Effect Sizes</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-control-transient-response">Control Transient Response</a> <span class="chapter-count">2</span></li>
<li><a href="#ch-matrix-norms">Matrix Norms</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-network-triad-analysis">Network Triad Analysis</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-misc-inverses">Misc Inverses</a> <span class="chapter-count">1</span></li>
<li><a href="#ch-parallel-i-o">Parallel I/O</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-file-i-o">File I/O</a> <span class="chapter-count">35</span></li>
<li><a href="#ch-strings">Strings</a> <span class="chapter-count">26</span></li>
<li><a href="#ch-arrays-hashes">Arrays & Hashes</a> <span class="chapter-count">20</span></li>
<li><a href="#ch-control-flow">Control Flow</a> <span class="chapter-count">17</span></li>
<li><a href="#ch-error-handling">Error Handling</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-aop-advice">AOP / Advice</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-declarations">Declarations</a> <span class="chapter-count">10</span></li>
<li><a href="#ch-cluster-distributed">Cluster / Distributed</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-datetime">Datetime</a> <span class="chapter-count">15</span></li>
<li><a href="#ch-math">Math</a> <span class="chapter-count">13</span></li>
<li><a href="#ch-file-system">File System</a> <span class="chapter-count">34</span></li>
<li><a href="#ch-process">Process</a> <span class="chapter-count">21</span></li>
<li><a href="#ch-pack-binary">Pack / Binary</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-logging">Logging</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-charts-svg">Charts (SVG)</a> <span class="chapter-count">19</span></li>
<li><a href="#ch-audio">Audio</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-network-utilities">Network Utilities</a> <span class="chapter-count">18</span></li>
<li><a href="#ch-markup-web-scraping">Markup / Web Scraping</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-date-utilities">Date Utilities</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-git">Git</a> <span class="chapter-count">10</span></li>
<li><a href="#ch-system">System</a> <span class="chapter-count">13</span></li>
<li><a href="#ch-testing">Testing</a> <span class="chapter-count">15</span></li>
<li><a href="#ch-test-runner-worker-pool">Test Runner (worker pool)</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-ai-primitives-docs-ai-primitives-md">AI primitives (docs/AI_PRIMITIVES.md)</a> <span class="chapter-count">79</span></li>
<li><a href="#ch-mcp-model-context-protocol">MCP (Model Context Protocol)</a> <span class="chapter-count">13</span></li>
<li><a href="#ch-web-framework-stryke-web-readme-md">Web framework (stryke_web/README.md)</a> <span class="chapter-count">112</span></li>
<li><a href="#ch-stress-telemetry-docs-stress-testing-md">Stress / telemetry (docs/STRESS_TESTING.md)</a> <span class="chapter-count">42</span></li>
<li><a href="#ch-pty-expect-docs-expect-feature-idea-md">PTY / expect (docs/expect-feature-idea.md)</a> <span class="chapter-count">13</span></li>
<li><a href="#ch-other">Other</a> <span class="chapter-count">6716</span></li>
</ul>
</section>
<section class="tutorial-section" id="ch-parallel-primitives">
<h2>Parallel Primitives</h2>
<p class="chapter-meta">18 topics</p>
<article class="doc-entry" id="doc-pmap">
<h3><a class="doc-anchor" href="#doc-pmap">#</a> <code>pmap</code></h3>
<p>Parallel <code>map</code> powered by rayon's work-stealing thread pool. Every element of the input list is processed concurrently across all available CPU cores, and the output order is guaranteed to match the input order. This is the primary workhorse for CPU-bound transforms in stryke — use it whenever you have a pure function and a large list. Pass <code>progress => 1</code> to get a live progress bar on STDERR for long-running jobs.</p>
<p>Two equivalent surface syntaxes: • Block form — <code>pmap BLOCK LIST</code> — element bound to <code>_</code> • Bare-fn form — <code>pmap FUNC, LIST</code> — single-arg function name as first argument</p>
<pre><code class="lang-perl"># Block form
my @out = pmap { _ * 2 } 1:1_000_000
my @hashes = pmap sha256 @blobs, progress => 1
1:100 |> pmap { fetch("https://api.example.com/item/$_") } |> e p
# Bare-fn form (works for builtins and user-defined subs)
my @hashes = pmap sha256, @blobs, progress => 1
fn dbl = _ * 2
my @r = pmap dbl, (1:1_000_000)
</code></pre>
</article>
<article class="doc-entry" id="doc-pmaps">
<h3><a class="doc-anchor" href="#doc-pmaps">#</a> <code>pmaps</code></h3>
<p>Streaming parallel <code>map</code> — returns a lazy iterator that processes items across all CPU cores using a persistent worker-thread pool. Unlike <code>pmap</code> which eagerly collects all results into an array, <code>pmaps</code> yields results as they complete through a bounded channel, so downstream consumers see output immediately. Output order is non-deterministic (completion order). Each worker thread reuses a single interpreter instance, making it faster than <code>pmap</code> for large inputs.</p>
<p>Best for: • Pipelines with <code>take</code>/<code>head</code> — avoids processing the full list • Very large inputs where holding all results in memory is impractical • Streaming pipelines where you want progressive output</p>
<pre><code class="lang-perl">range(0, 1e9) |> pmaps { _ * 2 } |> take 10 |> ep
t 1:1e6 pmaps { expensive(_) } ep
range(0, 1e6) |> pmaps { fetch("https://api/item/$_") } |> pgreps { _->{ok} } |> ep
</code></pre>
</article>
<article class="doc-entry" id="doc-pmap-chunked">
<h3><a class="doc-anchor" href="#doc-pmap-chunked">#</a> <code>pmap_chunked</code></h3>
<p>Parallel map that groups input into contiguous batches of N elements before distributing to threads. This reduces per-item scheduling overhead when the per-element work is very cheap (e.g. a few arithmetic ops). Each thread receives a slice of N consecutive items, processes them sequentially within the batch, then returns the batch result. Use this instead of <code>pmap</code> when profiling shows rayon overhead dominates the actual computation.</p>
<pre><code class="lang-perl">my @out = pmap_chunked 100, { _ ** 2 } 1:1_000_000
my @parsed = pmap_chunked 50, { json_decode } @json_strings
</code></pre>
</article>
<article class="doc-entry" id="doc-pgrep">
<h3><a class="doc-anchor" href="#doc-pgrep">#</a> <code>pgrep</code></h3>
<p>Parallel <code>grep</code> that evaluates the filter predicate concurrently across all CPU cores using rayon. The result preserves the original input order, so it is a drop-in replacement for <code>grep</code> on large lists. Best suited for predicates that do meaningful work per element — if the predicate is trivial (e.g. a single regex on short strings), sequential <code>grep</code> may be faster due to lower scheduling overhead.</p>
<p>Two equivalent surface syntaxes: <code>pgrep { BLOCK } LIST</code> or <code>pgrep FUNC, LIST</code>.</p>
<pre><code class="lang-perl"># Block form
my @matches = pgrep { /complex_pattern/ } @big_list
my @primes = pgrep { is_prime } 2:1_000_000
@files |> pgrep { -s _ > 1024 } |> e p
# Bare-fn form
fn Demo::even = _ % 2 == 0
my @e = pgrep Demo::even, 1:10 # (2,4,6,8,10)
</code></pre>
</article>
<article class="doc-entry" id="doc-pgreps">
<h3><a class="doc-anchor" href="#doc-pgreps">#</a> <code>pgreps</code></h3>
<p>Streaming parallel <code>grep</code> — returns a lazy iterator that filters items across all CPU cores. Unlike <code>pgrep</code> which eagerly collects all matching items, <code>pgreps</code> yields matches as they are found through a bounded channel. Output order is non-deterministic (completion order). Each worker thread reuses a single interpreter instance.</p>
<pre><code class="lang-perl">range(0, 1e6) |> pgreps { is_prime(_) } |> take 100 |> ep
t 1:1e9 pgreps { _ % 7 == 0 } take 10 ep
</code></pre>
</article>
<article class="doc-entry" id="doc-pfor">
<h3><a class="doc-anchor" href="#doc-pfor">#</a> <code>pfor</code></h3>
<p>Parallel <code>foreach</code> that executes a side-effecting block across all CPU cores with no return value. Use this when you need to perform work for each element (writing files, sending requests, updating shared state) but don't need to collect results. The block receives each element as <code>_</code>. Iteration order is non-deterministic, so the block must be safe to run concurrently.</p>
<p>Two equivalent surface syntaxes: <code>pfor { BLOCK } LIST</code> or <code>pfor FUNC, LIST</code>.</p>
<pre><code class="lang-perl"># Block form
pfor { write_report } @records
pfor { compress_file } glob("*.log")
@urls |> pfor { fetch
p "done: $_" }
# Bare-fn form
fn task = ep "did $_"
pfor task, (1, 2, 3)
</code></pre>
</article>
<article class="doc-entry" id="doc-psort">
<h3><a class="doc-anchor" href="#doc-psort">#</a> <code>psort</code></h3>
<p>Parallel sort that uses rayon's parallel merge-sort algorithm. Accepts an optional comparator block using <code>$_0</code>/<code>$_1</code> (or <code>$a</code>/<code>$b</code>). For large lists (10k+ elements), this significantly outperforms the sequential <code>sort</code> by splitting the array, sorting partitions in parallel, and merging. The sort is stable — equal elements retain their relative order.</p>
<pre><code class="lang-perl">my @sorted = psort { $_0 <=> $_1 } @big_list
my @by_name = psort { $_0->{name} cmp $_1->{name} } @records
@nums |> psort { $a <=> $b } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-pcache">
<h3><a class="doc-anchor" href="#doc-pcache">#</a> <code>pcache</code></h3>
<p>Parallel memoized map — each element is processed concurrently, but results are cached by the stringified value of <code>_</code> so duplicate inputs are computed only once. This is ideal when your input list contains many repeated values and the computation is expensive. The cache is a concurrent hash map shared across all threads, so there is no lock contention on reads after the first computation.</p>
<p>Two equivalent surface syntaxes: <code>pcache { BLOCK } LIST</code> or <code>pcache FUNC, LIST</code>.</p>
<pre><code class="lang-perl"># Block form
my @out = pcache { expensive_lookup } @list_with_dupes
my @resolved = pcache { dns_resolve } @hostnames
# Bare-fn form
my @resolved = pcache dns_resolve, @hostnames
</code></pre>
</article>
<article class="doc-entry" id="doc-preduce">
<h3><a class="doc-anchor" href="#doc-preduce">#</a> <code>preduce</code></h3>
<p>Parallel tree-fold using rayon's <code>reduce</code> — splits the list into chunks, reduces each chunk independently, then merges partial results. The combining operation <strong>must be associative</strong> (e.g. <code>+</code>, <code>*</code>, <code>max</code>); non-associative ops will produce incorrect results. Much faster than sequential <code>reduce</code> on large numeric lists because the tree structure allows O(log n) merge depth across cores.</p>
<pre><code class="lang-perl">my $total = preduce { $_0 + $_1 } @nums
my $biggest = preduce { $_0 > $_1 ? $_0 : $_1 } @vals
my $product = preduce { $a * $b } 1:100
</code></pre>
</article>
<article class="doc-entry" id="doc-preduce-init">
<h3><a class="doc-anchor" href="#doc-preduce-init">#</a> <code>preduce_init</code></h3>
<p>Parallel fold with identity value.</p>
<pre><code class="lang-perl">my $total = preduce_init 0, { $_0 + $_1 } @list
</code></pre>
</article>
<article class="doc-entry" id="doc-pmap-reduce">
<h3><a class="doc-anchor" href="#doc-pmap-reduce">#</a> <code>pmap_reduce</code></h3>
<p>Fused parallel map + tree reduce.</p>
<pre><code class="lang-perl">my $sum = pmap_reduce { _*2 } { $_0 + $_1 } @list
</code></pre>
</article>
<article class="doc-entry" id="doc-pany">
<h3><a class="doc-anchor" href="#doc-pany">#</a> <code>pany</code></h3>
<p><code>pany { COND } @list</code> — parallel short-circuit <code>any</code>.</p>
</article>
<article class="doc-entry" id="doc-pfirst">
<h3><a class="doc-anchor" href="#doc-pfirst">#</a> <code>pfirst</code></h3>
<p><code>pfirst { COND } @list</code> — parallel first matching element.</p>
</article>
<article class="doc-entry" id="doc-puniq">
<h3><a class="doc-anchor" href="#doc-puniq">#</a> <code>puniq</code></h3>
<p><code>puniq @list</code> — parallel unique elements.</p>
</article>
<article class="doc-entry" id="doc-pflat-map">
<h3><a class="doc-anchor" href="#doc-pflat-map">#</a> <code>pflat_map</code></h3>
<p>Parallel flat-map: map + flatten results. Each element produces zero or more output values via the block/function, and the outputs are concatenated in input order.</p>
<p>Two equivalent surface syntaxes: <code>pflat_map BLOCK LIST</code> or <code>pflat_map FUNC, LIST</code>.</p>
<pre><code class="lang-perl"># Block form
my @out = pflat_map expand @list
# Bare-fn form
fn expand = (_, _ * 10)
my @r = pflat_map expand, (1, 2, 3) # (1, 10, 2, 20, 3, 30)
</code></pre>
</article>
<article class="doc-entry" id="doc-pflat-maps">
<h3><a class="doc-anchor" href="#doc-pflat-maps">#</a> <code>pflat_maps</code></h3>
<p>Streaming parallel flat-map — like <code>pmaps</code> but flattens array results. Returns a lazy iterator.</p>
<pre><code class="lang-perl">range(0, 1e6) |> pflat_maps { [_, _ * 10] } |> ep
</code></pre>
</article>
<article class="doc-entry" id="doc-fan">
<h3><a class="doc-anchor" href="#doc-fan">#</a> <code>fan</code></h3>
<p>Execute BLOCK or FUNC N times in parallel (<code>_</code> = index 0..N-1). With no count, defaults to the rayon pool size (<code>stryke -j</code>).</p>
<p>Two equivalent surface syntaxes: • Block form — <code>fan N { BLOCK }</code> or <code>fan { BLOCK }</code> • Bare-fn form — <code>fan N, FUNC</code> or <code>fan FUNC</code></p>
<pre><code class="lang-perl"># Block form
fan 8 { work(_) }
fan { work(_) } progress => 1
# Bare-fn form
fn tick = ep "tick $_"
fan 8, tick
fan tick, progress => 1 # uses pool size
</code></pre>
</article>
<article class="doc-entry" id="doc-fan-cap">
<h3><a class="doc-anchor" href="#doc-fan-cap">#</a> <code>fan_cap</code></h3>
<p>Like <code>fan</code> but captures return values in index order. Two surface syntaxes: <code>fan_cap N { BLOCK }</code> or <code>fan_cap N, FUNC</code>.</p>
<pre><code class="lang-perl"># Block form
my @results = fan_cap 8 { compute(_) }
# Bare-fn form
fn compute = _ * _
my @squares = fan_cap 8, compute
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-shared-state-concurrency">
<h2>Shared State & Concurrency</h2>
<p class="chapter-meta">11 topics</p>
<article class="doc-entry" id="doc-mysync">
<h3><a class="doc-anchor" href="#doc-mysync">#</a> <code>mysync</code></h3>
<p>Declare shared variables for parallel blocks (<code>Arc<Mutex></code>).</p>
<pre><code class="lang-perl">mysync $counter = 0
fan 10000 { $counter++ } # always exactly 10000
mysync @results
mysync %histogram$1
Compound ops (`++`, `+=`, `.=`, `|=`, `&=`) are fully atomic.
</code></pre>
</article>
<article class="doc-entry" id="doc-async">
<h3><a class="doc-anchor" href="#doc-async">#</a> <code>async</code></h3>
<p><code>async { BLOCK }</code> — schedule a block for execution on a background worker thread and return a task handle immediately.</p>
<p>The block begins executing as soon as a thread is available in stryke's global rayon thread pool, while the calling code continues without blocking. To retrieve the result, pass the task handle to <code>await</code>, which blocks until the task completes and returns its value. If the block panics, the panic is captured and re-raised at the <code>await</code> call site. Use <code>async</code> for fire-and-forget background work, overlapping I/O with computation, or launching multiple independent tasks that you later join. For structured fan-out with index-based parallelism, prefer <code>fan</code> or <code>fan_cap</code> instead.</p>
<pre><code class="lang-perl">my $task = async { long_compute() }
do_other_work()
my $val = await $task
# Overlapping multiple fetches:
my @tasks = map { async { fetch("https://api.example.com/$_") } } 1:10;
my @results = map { await _ } @tasks
</code></pre>
</article>
<article class="doc-entry" id="doc-spawn">
<h3><a class="doc-anchor" href="#doc-spawn">#</a> <code>spawn</code></h3>
<p><code>spawn { BLOCK }</code> — Rust-style alias for <code>async</code>; schedules a block on a background thread and returns a joinable task handle.</p>
<p>This is identical to <code>async</code> in every respect — same thread pool, same semantics, same <code>await</code> for joining. The name exists for developers coming from Rust's <code>tokio::spawn</code> or <code>std::thread::spawn</code> who find <code>spawn</code> more natural. Use whichever reads better in your code; mixing <code>async</code> and <code>spawn</code> in the same program is perfectly fine since they share the same underlying pool.</p>
<pre><code class="lang-perl">my $task = spawn { expensive_io() }
my $val = await $task
my @handles = map { spawn { process } } @items;
my @out = map { await _ } @handles
</code></pre>
</article>
<article class="doc-entry" id="doc-await">
<h3><a class="doc-anchor" href="#doc-await">#</a> <code>await</code></h3>
<p><code>await $task</code> — block the current thread until an async/spawn task completes and return its result value.</p>
<p>If the background task has already finished by the time <code>await</code> is called, the result is returned immediately with no scheduling overhead. If the task panicked, <code>await</code> re-raises the panic as a die in the calling thread, preserving the original error message and backtrace. You can <code>await</code> a task exactly once; calling <code>await</code> on an already-joined handle is a fatal error. For waiting on multiple tasks, simply map over the handles — stryke does not yet provide a <code>join_all</code> primitive, but <code>map await @tasks</code> achieves the same effect.</p>
<pre><code class="lang-perl">my $task = async { 42 }
my $result = await $task # 42
# Await with error handling:
my $t = spawn { die "oops" }
eval { await $t } # $@ eq "oops"
</code></pre>
</article>
<article class="doc-entry" id="doc-pchannel">
<h3><a class="doc-anchor" href="#doc-pchannel">#</a> <code>pchannel</code></h3>
<p><code>pchannel(N)</code> — create a bounded multi-producer multi-consumer (MPMC) channel with capacity N, returning a <code>($tx, $rx)</code> pair.</p>
<p>The transmitter <code>$tx</code> supports <code>->send($val)</code> which blocks if the channel is full (backpressure). The receiver <code>$rx</code> supports <code>->recv</code> which blocks until a value is available, and <code>->try_recv</code> which returns <code>undef</code> immediately if the channel is empty. Both ends can be cloned and shared across threads — clone <code>$tx</code> with <code>$tx->clone</code> to create additional producers, or clone <code>$rx</code> for additional consumers. When all transmitters are dropped, <code>->recv</code> on the receiver returns <code>undef</code> to signal completion. Use <code>pchannel</code> to build producer-consumer pipelines, rate-limited work queues, or to communicate between <code>async</code>/<code>spawn</code> tasks.</p>
<pre><code class="lang-perl">my ($tx, $rx) = pchannel(100)
async { $tx->send(_) for 1:1000
undef $tx }
while (defined(my $val = $rx->recv)) {
p $val
}
# Multiple producers:
my ($tx, $rx) = pchannel(50)
for my $i (1:4) {
my $t = $tx->clone
spawn { $t->send("from worker $i: _") for 1:100 }
}
undef $tx # drop original so channel closes when workers finish
</code></pre>
</article>
<article class="doc-entry" id="doc-pselect">
<h3><a class="doc-anchor" href="#doc-pselect">#</a> <code>pselect</code></h3>
<p><code>pselect(@channels)</code> — wait on multiple <code>pchannel</code> receivers.</p>
</article>
<article class="doc-entry" id="doc-barrier">
<h3><a class="doc-anchor" href="#doc-barrier">#</a> <code>barrier</code></h3>
<p><code>barrier(N)</code> — create a synchronization barrier that blocks until exactly N threads have arrived at the wait point.</p>
<p>Each thread calls <code>$b->wait</code> and is suspended until all N participants have reached the barrier, at which point all are released simultaneously. This is useful for coordinating phased parallel algorithms where all workers must complete step K before any worker begins step K+1. The barrier is reusable — after all threads are released, it resets and can be waited on again. Internally backed by a Rust <code>std::sync::Barrier</code> for zero-overhead synchronization.</p>
<pre><code class="lang-perl">my $b = barrier(4)
for my $i (0:3) {
spawn {
setup_phase($i)
$b->wait # all 4 threads sync here
compute_phase($i)
}
}
</code></pre>
</article>
<article class="doc-entry" id="doc-ppool">
<h3><a class="doc-anchor" href="#doc-ppool">#</a> <code>ppool</code></h3>
<p><code>ppool(N, fn { ... })</code> — create a persistent thread pool of N worker threads, each running the provided subroutine in a loop.</p>
<p>The pool is typically paired with a <code>pchannel</code>: workers pull items from the channel's receiver, process them, and optionally send results to an output channel. Unlike <code>pmap</code> which is a one-shot parallel transform, <code>ppool</code> keeps threads alive for the lifetime of the pool, making it ideal for long-running server-style workloads, background drain loops, or scenarios where thread startup cost would dominate short-lived <code>pmap</code> calls. Workers exit when their input channel is closed (all transmitters dropped). The pool object supports <code>->join</code> to block until all workers have finished.</p>
<pre><code class="lang-perl">my ($tx, $rx) = pchannel(100)
my $pool = ppool 4, fn {
while (defined(my $job = $rx->recv)) {
process($job)
}
}
$tx->send(_) for @work_items
undef $tx # signal completion
$pool->join # wait for drain
</code></pre>
</article>
<article class="doc-entry" id="doc-deque">
<h3><a class="doc-anchor" href="#doc-deque">#</a> <code>deque</code></h3>
<p><code>deque LIST</code> — create a double-ended queue initialized with the given elements.</p>
<p>A deque supports efficient O(1) insertion and removal at both ends via <code>->push_front($val)</code>, <code>->push_back($val)</code>, <code>->pop_front</code>, and <code>->pop_back</code>. It also supports <code>->len</code> and iteration. Internally backed by a Rust <code>VecDeque</code>, it is ideal for sliding window algorithms, BFS traversals, or any scenario where you need fast access to both ends of a sequence.</p>
<pre><code class="lang-perl">my $dq = deque(1, 2, 3)
$dq->push_front(0)
$dq->push_back(4)
p $dq->pop_front # 0
</code></pre>
</article>
<article class="doc-entry" id="doc-heap">
<h3><a class="doc-anchor" href="#doc-heap">#</a> <code>heap</code></h3>
<p><code>heap LIST</code> — create a min-heap (priority queue) from the given elements.</p>
<p>Elements are heapified on construction so that <code>->pop</code> always returns the smallest element in O(log n) time. <code>->push($val)</code> inserts a new element, also in O(log n). The heap supports <code>->peek</code> to inspect the minimum without removing it, and <code>->len</code> for the current size. Internally backed by a Rust <code>BinaryHeap</code> (inverted for min-heap semantics), it is the go-to structure for top-K queries, Dijkstra, and merge-K-sorted-lists problems.</p>
<pre><code class="lang-perl">my $h = heap(5, 3, 8, 1)
p $h->pop # 1 (smallest first)
p $h->peek # 3 (next smallest)
$h->push(0)
</code></pre>
</article>
<article class="doc-entry" id="doc-set">
<h3><a class="doc-anchor" href="#doc-set">#</a> <code>set</code></h3>
<p><code>set LIST</code> — create a set (unique unordered collection) from the given elements.</p>
<p>Duplicate values are collapsed on construction so the set contains each value exactly once. The set object provides <code>->contains($val)</code> for O(1) membership testing, plus <code>->union($s)</code>, <code>->intersection($s)</code>, <code>->difference($s)</code>, and <code>->len</code> methods. Internally backed by a Rust <code>HashSet</code> for performance. Use <code>to_set</code> to convert an existing iterator into a set.</p>
<pre><code class="lang-perl">my $s = set(1, 2, 3, 2, 1)
p $s->contains(2) # 1
p $s->len # 3
my $both = $s->union(set(3, 4, 5))
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-pipeline-pipe-forward">
<h2>Pipeline & Pipe-Forward</h2>
<p class="chapter-meta">12 topics</p>
<article class="doc-entry" id="doc-">
<h3><a class="doc-anchor" href="#doc-">#</a> <code>|></code></h3>
<p>Pipe-forward operator — threads LHS as first argument of RHS call.</p>
<pre><code class="lang-perl">"hello" |> uc |> rev |> p # OLLEH
1:10 |> grep _ > 5 |> map _ * 2 |> e p
$url |> fetch_json |> json_jq '.name' |> p
"hello world" |> s/world/perl/ |> p # hello perl
</code></pre>
<p>Zero runtime cost (parse-time desugaring). Binds looser than <code>||</code>, tighter than <code>?:</code>.</p>
</article>
<article class="doc-entry" id="doc-thread">
<h3><a class="doc-anchor" href="#doc-thread">#</a> <code>thread</code></h3>
<p>Thread-first macro — chain stages where the threaded value is injected as the <strong>first</strong> argument (like Clojure's <code>-></code>).</p>
<pre><code class="lang-perl">~> @data grep { _ > 5 } map { _ * 2 } sort { $_0 <=> $_1 } |> join "," |> p
~> " hello " tm uc rv lc ufc sc cc kc tj p # short aliases
fn div = _0 / _1
~> 10 div(2) p # div(10, 2) = 5
~> 10 div(_, 2) p # explicit _ position: div(10, 2) = 5
</code></pre>
<p>Spellings: <code>~></code>, <code>thread</code>, <code>t</code>. Stages: bare function (<code>uc</code>, <code>tm</code>, …), function with block (<code>map { … }</code>, <code>grep { … }</code>), <code>name(args)</code> call where <code>_</code> is the threaded-value placeholder, or <code>>{}</code> anonymous block. <code>|></code> terminates the macro.</p>
</article>
<article class="doc-entry" id="doc-">
<h3><a class="doc-anchor" href="#doc-">#</a> <code>->></code></h3>
<p>Thread-last macro — chain stages where the threaded value is injected as the <strong>last</strong> argument (like Clojure's <code>->></code>).</p>
<pre><code class="lang-perl">fn div = _0 / _1
~>> 10 div(2) p # div(2, 10) = 0.2
->> 10 div(_, 2) p # explicit _ overrides: div(10, 2) = 5
# Thread-last is useful for list-consuming functions:
fn first_n { @_[0..$_[-1]-1] } # first_n(list, n)
~>> (1,2,3,4,5) first_n(3) p # first_n(1,2,3,4,5, 3) = (1,2,3)
</code></pre>
<p>Spellings: <code>~>></code>, <code>->></code>. The explicit <code>_</code> placeholder always takes precedence.</p>
</article>
<article class="doc-entry" id="doc-s">
<h3><a class="doc-anchor" href="#doc-s">#</a> <code>~s></code></h3>
<p>Per-item streaming thread macro — each stage runs as an independent worker thread connected to the next via a bounded channel, so items flow through the pipeline concurrently without materializing intermediate arrays.</p>
<pre><code class="lang-perl">~s> [1, 2, 3, 4, 5] map { _ * 10 } map { _ + 1 }
~s> @lines map { json_decode } grep { _->{ok} } map { _->{val} }
~s> gen { yield_lines "huge.log" } map { parse } grep { /ERROR/ }
</code></pre>
<p>Use <code>~s></code> when stages have differing latencies (I/O + CPU mix) so faster workers can pull ahead. Output order is non-deterministic. The macro's final value is the count of items the last stage emitted. <code>~s>></code> is the thread-last variant.</p>
<p>See <code>~p></code> for chunk-parallel (vs per-item) execution and <code>par_pipeline</code> for the verbose builder form.</p>
</article>
<article class="doc-entry" id="doc-p">
<h3><a class="doc-anchor" href="#doc-p">#</a> <code>~p></code></h3>
<p>Chunk-parallel thread macro — splits the input into chunks, runs the entire pipeline on each chunk in parallel via rayon, and auto-merges chunk results. Equivalent to <code>par_reduce { stage1 |> stage2 |> ... } SRC</code>.</p>
<pre><code class="lang-perl">~p> c("**.rs") letters freq # histogram across all .rs
~p> @big map { _ * 2 } sum # parallel map+sum
~p> $huge letters freq ||> values |> sum # boundary: terse
~p> $huge letters freq |then| values |> sum # boundary: english
</code></pre>
<p>The auto-merger picks a strategy by inspecting the first chunk's result type: hash-of-numbers merges key-wise with <code>+</code> (canonical histogram), numeric scalars sum, arrays concat, strings concat. Use <code>||></code> or <code>|then|</code> to switch back to sequential <code>~></code> mode for stages that operate on the merged whole. <code>|></code> also terminates a <code>~p></code> macro. <code>~p>></code> is the thread-last variant.</p>
</article>
<article class="doc-entry" id="doc-par">
<h3><a class="doc-anchor" href="#doc-par">#</a> <code>par</code></h3>
<p>Generic parallel-chunk thread-stage — only valid inside <code>~></code>/<code>~>></code>. Splits the threaded value into chunks, runs <code>BLOCK</code> on each chunk in parallel, and flattens chunk outputs into a single list.</p>
<pre><code class="lang-perl">my @a = ~> "Hello, World 123" par { letters } # H e l l o W o r l d
~> @huge par { map { _ ** 2 } |> sum } |> sum p # parallel sum-of-squares
</code></pre>
<p>Each chunk gets a fresh sub-VM with the chunk bound to <code>_</code> and <code>$_[0]</code>. List-returning ops keep their values; the runtime auto-flattens. Use <code>par_reduce</code> when you need a final merge step rather than flat concat. <code>par { … }</code> is *only* a thread-stage; calling it as a top-level expression is an undefined-sub error.</p>
</article>
<article class="doc-entry" id="doc-par-reduce">
<h3><a class="doc-anchor" href="#doc-par-reduce">#</a> <code>par_reduce</code></h3>
<p>Chunk-extract-merge thread-stage. The single-block form runs <code>extract</code> per chunk and auto-merges results by type (hash<num>→key-wise add, number→sum, array→concat, string→concat). The two-block form binds <code>$a</code>/<code>$b</code> in the explicit reducer.</p>
<pre><code class="lang-perl">~> "abc def abc" par_reduce { letters |> freq } # canonical histogram merge
~> @nums par_reduce { sum } # parallel sum
~> "abcdefgh" par_reduce { length(_) } { $a + $b } # explicit pairwise reducer
</code></pre>
<p>Below the chunk threshold the runtime falls back to single-chunk eval; the result must still match the bare extract block's output. Multi-chunk paths require the merger (auto or explicit) to be associative and commutative for correct results.</p>
</article>
<article class="doc-entry" id="doc-">
<h3><a class="doc-anchor" href="#doc-">#</a> <code>||></code></h3>
<p>Boundary marker that terminates the chunk-parallel section of a <code>~p></code> macro and switches the merged result into a sequential <code>~></code> continuation.</p>
<pre><code class="lang-perl">~p> "abc def abc" letters freq ||> values |> sum # 9
~p> "abc def abc" letters freq |then| values |> sum # 9 — readable form
~p> @data map { _ * 2 } sum ||> sqrt p # parallel sum, sequential sqrt
</code></pre>
<p>Both spellings are byte-equivalent; <code>||></code> is terse, <code>|then|</code> reads in English. Use either when you need a post-merge stage that operates on the whole reduced value rather than per-chunk. <code>|></code> also terminates a <code>~p></code> macro.</p>
</article>
<article class="doc-entry" id="doc-pipeline">
<h3><a class="doc-anchor" href="#doc-pipeline">#</a> <code>pipeline</code></h3>
<p><code>pipeline(@list)</code> — wrap a list (or iterator) in a lazy pipeline object supporting chained <code>->map</code>, <code>->filter</code>, <code>->take</code>, <code>->skip</code>, <code>->flat_map</code>, <code>->tap</code>, and other transforms that execute zero work until a terminal method is called.</p>
<p>No intermediate lists are allocated between stages — each element flows through the full chain one at a time, making pipelines memory-efficient even on very large or infinite inputs. Terminal methods include <code>->collect</code> (materialize to list), <code>->reduce { ... }</code> (fold), <code>->for_each { ... }</code> (side-effect iteration), and <code>->count</code>. Pipelines compose naturally with stryke's <code>|></code> operator: you can feed <code>pipeline(...)</code> output into further <code>|></code> stages or vice versa. Use <code>pipeline</code> when you want explicit method-chaining style rather than the flat <code>|></code> pipe syntax — both compile to the same lazy evaluation engine.</p>
<pre><code class="lang-perl">my @out = pipeline(@data)
->filter { _ > 0 }
->map { _ * 2 }
->take(10)
->collect
pipeline(1:1_000_000)
->filter { _ % 3 == 0 }
->map { _ ** 2 }
->take(5)
->for_each { p _ } # 9 36 81 144 225
my $sum = pipeline(@scores)
->filter { _ >= 60 }
->reduce { $_0 + $_1 }
</code></pre>
</article>
<article class="doc-entry" id="doc-par-pipeline">
<h3><a class="doc-anchor" href="#doc-par-pipeline">#</a> <code>par_pipeline</code></h3>
<p><code>par_pipeline(source => \@data, stages => [...], workers => N)</code> — build a multi-stage parallel pipeline where each stage's map/filter block runs concurrently across N worker threads.</p>
<p>Unlike <code>pmap</code> which parallelizes a single transform, <code>par_pipeline</code> lets you define a sequence of named stages — each with its own block — that execute in parallel while preserving input order in the final output. Internally, stryke partitions the source into chunks, distributes them across workers, and pipelines the stages so that stage 2 can begin processing a chunk as soon as stage 1 finishes it, overlapping computation across stages. This is ideal for multi-step ETL workloads where each step is CPU-bound and the data volume is large. The <code>workers</code> parameter defaults to the number of logical CPUs.</p>
<pre><code class="lang-perl">my @results = par_pipeline(
source => \@raw_records,
stages => [
{ name => "parse", map => fn { json_decode } },
{ name => "transform", map => fn { enrich } },
{ name => "validate", filter => fn { _->{valid} } },
],
workers => 8,
)
</code></pre>
</article>
<article class="doc-entry" id="doc-par-pipeline-stream">
<h3><a class="doc-anchor" href="#doc-par-pipeline-stream">#</a> <code>par_pipeline_stream</code></h3>
<p><code>par_pipeline_stream(source => ..., stages => [...], workers => N)</code> — streaming variant of <code>par_pipeline</code> that connects stages via bounded <code>pchannel</code> queues instead of materializing intermediate arrays.</p>
<p>Each stage runs as an independent pool of workers, pulling from an input channel and pushing to an output channel. This gives true pipelined parallelism: stage 1 workers produce items while stage 2 workers consume them concurrently, bounded by channel capacity to prevent memory blowup. The streaming design makes this suitable for infinite or very large data sources (file streams, network feeds) where materializing the full dataset between stages is impractical. Results are emitted in arrival order by default; pass <code>ordered => 1</code> to reorder them to match input order at the cost of buffering.</p>
<pre><code class="lang-perl">par_pipeline_stream(
source => fn { while (my $line = <STDIN>) { yield $line } },
stages => [
{ name => "parse", map => fn { json_decode } },
{ name => "score", map => fn { compute_score } },
],
workers => 4,
on_item => fn { p _ }, # process results as they arrive
)
</code></pre>
</article>
<article class="doc-entry" id="doc-collect">
<h3><a class="doc-anchor" href="#doc-collect">#</a> <code>collect</code></h3>
<p><code>collect ITERATOR</code> — materialize a lazy iterator or pipeline into a concrete list.</p>
<p>Pipeline stages in stryke are lazy: chaining <code>|> map {...} |> grep {...}</code> builds up a deferred computation without consuming any elements. Calling <code>collect</code> forces evaluation and returns all results as a regular Perl list. This is the standard way to terminate a lazy chain when you need the full result in an array. Without <code>collect</code>, the iterator is consumed element-by-element by <code>e</code>, <code>take</code>, or other streaming sinks.</p>
<pre><code class="lang-perl">my @out = range(1,5) |> map { _ * 2 } |> collect
gen { yield _ for 1:3 } |> collect |> e p
my @data = stdin |> grep /INFO/ |> collect
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-streaming-iterators">
<h2>Streaming Iterators</h2>
<p class="chapter-meta">24 topics</p>
<article class="doc-entry" id="doc-maps">
<h3><a class="doc-anchor" href="#doc-maps">#</a> <code>maps</code></h3>
<p><code>maps { BLOCK } LIST</code> — the lazy, streaming counterpart of <code>map</code>. Instead of materializing the entire output list, <code>maps</code> returns a pull iterator that evaluates the block on demand as downstream consumers request values. This makes it ideal for <code>|></code> pipeline chains, especially when combined with <code>take</code>, <code>greps</code>, or <code>collect</code>. Use <code>maps</code> over <code>map</code> when working with large ranges, infinite sequences, or when you want to short-circuit processing early with <code>take</code>. Memory usage is constant regardless of input size.</p>
<pre><code class="lang-perl">1:10 |> maps { _ * 3 } |> take 4 |> e p
# 3 6 9 12
1:1_000_000 |> maps { _ ** 2 } |> greps { _ > 100 } |> take 3 |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-greps">
<h3><a class="doc-anchor" href="#doc-greps">#</a> <code>greps</code></h3>
<p><code>greps { BLOCK } LIST</code> — the lazy, streaming counterpart of <code>grep</code>. Returns a pull iterator that only evaluates the predicate as elements are requested downstream. This is the preferred filtering function in <code>|></code> pipelines because it avoids materializing intermediate lists. Combine with <code>take</code> to short-circuit early, or with <code>maps</code> and <code>collect</code> for full lazy pipelines. The block receives <code>_</code> just like <code>grep</code>.</p>
<pre><code class="lang-perl">1:100 |> greps { _ % 7 == 0 } |> take 3 |> e p
# 7 14 21
@lines |> greps { /ERROR/ } |> maps { tm } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter">
<h3><a class="doc-anchor" href="#doc-filter">#</a> <code>filter</code></h3>
<p><code>filter</code> (alias <code>fi</code>) <code>{ BLOCK } LIST</code> — stryke-native lazy filter that returns a pull iterator, functionally identical to <code>greps</code> but named for familiarity with Rust/Ruby/JS conventions. Use <code>filter</code> or <code>greps</code> interchangeably in <code>|></code> chains; both are streaming and both set <code>_</code> in the block. The result must be consumed with <code>collect</code>, <code>e p</code>, <code>foreach</code>, or another terminal. Prefer <code>filter</code> when writing stryke-idiomatic code; prefer <code>grep</code>/<code>greps</code> when porting from Perl.</p>
<pre><code class="lang-perl">my @big = 1:1000 |> filter { _ > 990 } |> collect
@big |> e p # 991 992 993 994 995 996 997 998 999 1000
1:50 |> fi { _ % 2 } |> take 5 |> e p # 1 3 5 7 9
</code></pre>
</article>
<article class="doc-entry" id="doc-tap">
<h3><a class="doc-anchor" href="#doc-tap">#</a> <code>tap</code></h3>
<p><code>tap { BLOCK } LIST</code> — execute a side-effecting block for each element, then pass the element through unchanged.</p>
<p>The return value of the block is ignored; the original element is always forwarded to the next pipeline stage. This makes <code>tap</code> ideal for injecting logging, debugging, or metrics collection into the middle of a pipeline without altering the data flow. It is fully streaming and preserves element order.</p>
<pre><code class="lang-perl">1:5 |> tap { log_debug "saw: $_" } |> map { _ * 2 } |> e p
@files |> tap { p "processing: $_" } |> map slurp |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-peek">
<h3><a class="doc-anchor" href="#doc-peek">#</a> <code>peek</code></h3>
<p><code>peek ITERATOR</code> — inspect the next element of an iterator without consuming it.</p>
<p>The peeked value is buffered internally so that the next call to <code>->next</code> or pipeline pull returns the same element. This is useful for lookahead parsing, conditional branching on the next value, or implementing <code>take_while</code>-style logic manually. Calling <code>peek</code> multiple times without advancing the iterator returns the same value each time. Works with any stryke iterator including <code>gen</code>, <code>range</code>, <code>stdin</code>, and pipeline results.</p>
<pre><code class="lang-perl">my $g = gen { yield _ for 1:5 }
p peek $g # 1 (not consumed)
p $g->next # 1
p peek $g # 2
</code></pre>
</article>
<article class="doc-entry" id="doc-tee">
<h3><a class="doc-anchor" href="#doc-tee">#</a> <code>tee</code></h3>
<p><code>tee FILE, ITERATOR</code> — write each element to a file as a side effect while passing it through the pipeline.</p>
<p>Every element that flows through <code>tee</code> is appended as a line to the specified file, and the element itself continues downstream unchanged. The file is opened once on first element and closed when the iterator is exhausted. This is the stryke equivalent of the Unix <code>tee</code> command, useful for auditing or logging intermediate pipeline results to disk.</p>
<pre><code class="lang-perl">1:10 |> tee "/tmp/log.txt" |> map { _ * 2 } |> e p
stdin |> tee "/tmp/raw.log" |> grep /ERROR/ |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-take">
<h3><a class="doc-anchor" href="#doc-take">#</a> <code>take</code></h3>
<p><code>take N, LIST</code> / <code>head N, LIST</code> / <code>hd N, LIST</code> — return at most the first N elements.</p>
<p>In streaming mode, <code>take</code> pulls exactly N elements from the upstream iterator and then stops, so it short-circuits infinite or very large sources efficiently. This makes it safe to write <code>range(1, 1_000_000) |> take 5</code> without allocating a million-element list. If the source has fewer than N elements, all of them are returned. The <code>head</code> and <code>hd</code> aliases mirror Unix <code>head</code> semantics.</p>
<pre><code class="lang-perl">1:100 |> take 5 |> e p # 1 2 3 4 5
my @top = hd 3, @sorted
stdin |> hd 10 |> e p # first 10 lines
</code></pre>
</article>
<article class="doc-entry" id="doc-tail">
<h3><a class="doc-anchor" href="#doc-tail">#</a> <code>tail</code></h3>
<p><code>tail N, @list</code> — returns the last N elements of the list. If N exceeds the list length, the entire list is returned. The alias <code>tl</code> is also available. This is the complement of <code>head</code>/<code>take</code>. In stryke, it works both as a function call and in <code>|></code> pipelines.</p>
<pre><code class="lang-perl">my @t = tail 2, 1:5
@t |> e p # 4 5
1:100 |> tl 3 |> e p # 98 99 100
</code></pre>
</article>
<article class="doc-entry" id="doc-drop">
<h3><a class="doc-anchor" href="#doc-drop">#</a> <code>drop</code></h3>
<p><code>drop N, LIST</code> / <code>skip N, LIST</code> / <code>drp N, LIST</code> — skip the first N elements and return the rest.</p>
<p>This operation is fully streaming: when used in a pipeline, the first N elements are consumed and discarded without buffering, and all subsequent elements flow through to the next stage. If the list contains fewer than N elements, the result is empty. The <code>skip</code> and <code>drp</code> aliases exist for readability in different contexts — all three compile to the same internal op.</p>
<pre><code class="lang-perl">1:10 |> drop 3 |> e p # 4 5 6 7 8 9 10
my @rest = drp 2, @data
stdin |> skip 1 |> e p # skip header line
</code></pre>
</article>
<article class="doc-entry" id="doc-take-while">
<h3><a class="doc-anchor" href="#doc-take-while">#</a> <code>take_while</code></h3>
<p><code>take_while { COND } LIST</code> — emit leading elements while the predicate returns true, then stop.</p>
<p>The block receives each element as <code>_</code>. Elements are emitted as long as the predicate holds; the moment it returns false, the pipeline terminates immediately without consuming further input. This short-circuit behavior makes <code>take_while</code> efficient on infinite iterators and large streams. It is the complement of <code>drop_while</code>.</p>
<pre><code class="lang-perl">1:10 |> take_while { _ < 5 } |> e p # 1 2 3 4
stdin |> take_while { !/^END/ } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-while">
<h3><a class="doc-anchor" href="#doc-drop-while">#</a> <code>drop_while</code></h3>
<p><code>drop_while { COND } LIST</code> — skip leading elements while the predicate returns true, then emit everything after.</p>
<p>The block receives each element as <code>_</code>. Once the predicate returns false for the first time, that element and all remaining elements pass through unconditionally — the predicate is never consulted again. This is streaming: elements are tested one at a time without buffering. Useful for skipping headers, preamble, or sorted prefixes in data streams.</p>
<pre><code class="lang-perl">1:10 |> drop_while { _ < 5 } |> e p # 5 6 7 8 9 10
@log |> drop_while { /^ #/ } |> e p # skip comment header
</code></pre>
</article>
<article class="doc-entry" id="doc-reject">
<h3><a class="doc-anchor" href="#doc-reject">#</a> <code>reject</code></h3>
<p><code>reject { BLOCK } LIST</code> — stryke-native streaming inverse of <code>filter</code>/<code>greps</code>. It keeps only the elements for which the block returns false. This reads more naturally than <code>filter { !(...) }</code> when the condition describes what you want to exclude rather than what you want to keep. Like <code>filter</code> and <code>greps</code>, it returns a lazy iterator suitable for <code>|></code> chains. The block receives <code>_</code> as the current element.</p>
<pre><code class="lang-perl">1:10 |> reject { _ % 3 == 0 } |> e p
# 1 2 4 5 7 8 10
@files |> reject { /\.bak$/ } |> e p # skip backups
</code></pre>
</article>
<article class="doc-entry" id="doc-compact">
<h3><a class="doc-anchor" href="#doc-compact">#</a> <code>compact</code></h3>
<p><code>compact</code> (alias <code>cpt</code>) — stryke-native streaming operator that removes <code>undef</code> and empty-string values from a list or iterator. This is a common data-cleaning step when dealing with parsed input, optional fields, or split results that produce empty segments. It is equivalent to <code>greps { defined(_) && _ ne "" }</code> but more concise and faster because the check is inlined in Rust. Numeric zero and the string <code>"0"</code> are preserved since they are defined and non-empty.</p>
<pre><code class="lang-perl">my @raw = (1, undef, "", 2, undef, 3)
@raw |> compact |> e p # 1 2 3
split(/,/, "a,,b,,,c") |> cpt |> e p # a b c
</code></pre>
</article>
<article class="doc-entry" id="doc-concat">
<h3><a class="doc-anchor" href="#doc-concat">#</a> <code>concat</code></h3>
<p><code>concat</code> (alias <code>chain</code>) — stryke-native streaming operator that concatenates multiple lists or iterators into a single sequential iterator. Pass array references and they will be yielded in order without copying. This is useful for merging data from multiple sources into a unified pipeline. The operation is lazy: each source is drained in turn, so memory usage stays proportional to the largest single element, not the total.</p>
<pre><code class="lang-perl">my @a = 1:3
my @b = 7:9
concat(\@a, \@b) |> e p # 1 2 3 7 8 9
my @c = ("x")
concat(\@a, \@b, \@c) |> maps { uc } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-enumerate">
<h3><a class="doc-anchor" href="#doc-enumerate">#</a> <code>enumerate</code></h3>
<p><code>enumerate ITERATOR</code> / <code>en ITERATOR</code> — yield <code>[$index, $item]</code> pairs from a streaming iterator.</p>
<p>Each element is wrapped as <code>[$index, $item]</code> where the index starts at 0 and increments for each element. Unlike <code>with_index</code> which returns <code>[item, index]</code>, <code>enumerate</code> uses the Rust/Python convention of <code>[index, item]</code>. This is a streaming operation: the index counter is maintained lazily as elements flow through the pipeline.</p>
<pre><code class="lang-perl">stdin |> en |> e { p "_->[0]: _->[1]" }
1:5 |> en |> e { p "_->[0]: _->[1]" }
@lines |> en |> grep { _->[0] < 10 } |> e { p _->[1] }
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk">
<h3><a class="doc-anchor" href="#doc-chunk">#</a> <code>chunk</code></h3>
<p><code>chunk N, ITERATOR</code> / <code>chk N, ITERATOR</code> — group elements into N-sized arrayrefs as they stream through.</p>
<p>Elements are buffered until N are collected, then the group is emitted as a single arrayref. The final chunk may contain fewer than N elements if the source is not evenly divisible. This is fully streaming: only one chunk is held in memory at a time, making it safe for large or infinite iterators. Use <code>chunk</code> for batching work (e.g., bulk database inserts) or formatting output into rows.</p>
<pre><code class="lang-perl">1:9 |> chk 3 |> e { p join ",", @_ }
# 1,2,3 4,5,6 7,8,9
stdin |> chk 100 |> e { bulk_insert(@_) }
</code></pre>
</article>
<article class="doc-entry" id="doc-dedup">
<h3><a class="doc-anchor" href="#doc-dedup">#</a> <code>dedup</code></h3>
<p><code>dedup ITERATOR</code> / <code>dup ITERATOR</code> — drop consecutive duplicate elements from a stream.</p>
<p>Only adjacent duplicates are removed: if the same value appears later after an intervening different value, it is emitted again. Comparison is string-based by default. This is a streaming operation that holds only the previous element in memory, so it works on infinite iterators. For global deduplication across the entire stream, use <code>distinct</code> instead.</p>
<pre><code class="lang-perl">1,1,2,2,3,1,1 |> dedup |> e p # 1 2 3 1
@sorted |> dedup |> e p # like uniq(1)
stdin |> dedup |> e p # collapse repeated lines
</code></pre>
</article>
<article class="doc-entry" id="doc-distinct">
<h3><a class="doc-anchor" href="#doc-distinct">#</a> <code>distinct</code></h3>
<p><code>distinct LIST</code> — remove duplicate elements, preserving first-occurrence order (alias for <code>uniq</code>).</p>
<p>Each element is compared as a string; the first time a value is seen it is emitted, and all subsequent occurrences are silently dropped. When used in a pipeline the deduplication state is maintained across streamed chunks, so <code>distinct</code> works correctly on lazy iterators and generators. This is a stryke built-in backed by a hash set internally, so it runs in O(n) time regardless of list size.</p>
<pre><code class="lang-perl">my @u = distinct(3,1,2,1,3) # (3,1,2)
1,2,2,3,3,3 |> distinct |> e p # 1 2 3
stdin |> distinct |> e p # unique lines
</code></pre>
</article>
<article class="doc-entry" id="doc-flatten">
<h3><a class="doc-anchor" href="#doc-flatten">#</a> <code>flatten</code></h3>
<p><code>flatten LIST</code> / <code>fl LIST</code> — recursively flatten nested arrayrefs into a single flat list.</p>
<p>Flatten walks every element: scalars pass through unchanged, arrayrefs are opened and their contents are recursively flattened, so arbitrarily deep nesting is handled in one call. In pipeline mode (<code>|> fl</code>) it streams element-by-element, so you can chain it with <code>map</code>, <code>grep</code>, or <code>take</code> without materializing the entire intermediate list. The <code>fl</code> alias keeps pipeline chains concise.</p>
<pre><code class="lang-perl">my @flat = flatten([1,[2,3]],[4]) # (1,2,3,4)
[1,[2,[3,4]]] |> fl |> e p # 1 2 3 4
@nested |> fl |> grep { _ > 0 } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-with-index">
<h3><a class="doc-anchor" href="#doc-with-index">#</a> <code>with_index</code></h3>
<p><code>with_index LIST</code> / <code>wi LIST</code> — pair each element with its 0-based index as <code>[$item, $index]</code>.</p>
<p>Each element is wrapped in a two-element arrayref where <code>_->[0]</code> is the original value and <code>_->[1]</code> is its position. This is useful when you need positional information during a map or grep without maintaining a manual counter. Note the order is <code>[item, index]</code>, which differs from <code>enumerate</code> which yields <code>[index, item]</code>.</p>
<pre><code class="lang-perl">qw(a b c) |> wi |> e { p "_->[1]: _->[0]" }
# 0: a 1: b 2: c
@data |> wi |> grep { _->[1] % 2 == 0 } |> e { p _->[0] }
</code></pre>
</article>
<article class="doc-entry" id="doc-first-or">
<h3><a class="doc-anchor" href="#doc-first-or">#</a> <code>first_or</code></h3>
<p><code>first_or DEFAULT, LIST</code> — return the first element of the list, or DEFAULT if the list is empty.</p>
<p>This is a streaming terminal: it pulls exactly one element from the upstream iterator and returns it, or returns the default value if the iterator is exhausted. It never buffers the entire list. This is especially useful at the end of a <code>grep</code> or <code>map</code> pipeline where you need a safe fallback instead of <code>undef</code> when no match is found.</p>
<pre><code class="lang-perl">my $v = first_or 0, @maybe_empty
my $x = grep { _ > 99 } @nums |> first_or -1
stdin |> grep /^ERROR/ |> first_or "(none)" |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range">
<h3><a class="doc-anchor" href="#doc-range">#</a> <code>range</code></h3>
<p><code>range(START, END [, STEP])</code> — create a lazy integer iterator from START to END with an optional step.</p>
<p>The range is inclusive on both ends. When START > END and no step is given, stryke automatically counts downward. An explicit STEP controls the increment and must be negative when counting down, or the range will be empty. The iterator is fully lazy: no list is allocated, and elements are generated on demand, making <code>range(1, 1_000_000)</code> as cheap to create as <code>range(1, 5)</code>. Combine with <code>|></code> to feed into streaming pipelines.</p>
<pre><code class="lang-perl">range(1, 5) |> e p # 1 2 3 4 5
range(5, 1) |> e p # 5 4 3 2 1
range(0, 10, 2) |> e p # 0 2 4 6 8 10
range(10, 0, -2) |> e p # 10 8 6 4 2 0
</code></pre>
</article>
<article class="doc-entry" id="doc-stdin">
<h3><a class="doc-anchor" href="#doc-stdin">#</a> <code>stdin</code></h3>
<p><code>stdin</code> — return a streaming iterator over lines read from standard input.</p>
<p>Each call to the iterator reads one line from STDIN, strips the trailing newline, and yields it. The iterator terminates at EOF. Because it is lazy, combining <code>stdin</code> with <code>take</code>, <code>grep</code>, or <code>first_or</code> processes only as many lines as needed — the rest of STDIN is left unconsumed. This is the idiomatic stryke way to build Unix-style filters.</p>
<pre><code class="lang-perl">stdin |> grep /error/i |> e p
stdin |> take 5 |> e p
stdin |> en |> e { p "_->[0]: _->[1]" }
</code></pre>
</article>
<article class="doc-entry" id="doc-nth">
<h3><a class="doc-anchor" href="#doc-nth">#</a> <code>nth</code></h3>
<p><code>nth N, LIST</code> — return the Nth element using 0-based indexing.</p>
<p>When used in a pipeline, <code>nth</code> consumes and discards the first N elements, returns the next one, and stops — so it short-circuits on infinite iterators. On a plain list, it is equivalent to <code>$list[N]</code> but works as a function call for pipeline composition. Returns <code>undef</code> if the list has fewer than N+1 elements.</p>
<pre><code class="lang-perl">my $third = nth 2, @data
1:10 |> nth 4 |> p # 5
stdin |> nth 0 |> p # first line
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-list-operations">
<h2>List Operations</h2>
<p class="chapter-meta">62 topics</p>
<article class="doc-entry" id="doc-map">
<h3><a class="doc-anchor" href="#doc-map">#</a> <code>map</code></h3>
<p><code>map BLOCK LIST</code> — evaluates the block for each element of the list, setting <code>_</code> to the current element, and returns a new list of all the block's return values. This is the eager version: it consumes the entire input list and produces the entire output list before returning. Use <code>map</code> when you need the full result array or when the input is small. For large or infinite sequences, prefer <code>maps</code> (the streaming variant). The block can return zero, one, or multiple values per element, making <code>map</code> useful for both transformation and flattening. Use <code>{ |$var| body }</code> to name the block parameter instead of <code>_</code>.</p>
<pre><code class="lang-perl">my @sq = map { _ ** 2 } 1:5
@sq |> e p # 1 4 9 16 25
map { |$n| $n * $n }, 1:5 # named param
my @pairs = map { (_, _ * 10) } 1:3
@pairs |> e p # 1 10 2 20 3 30
</code></pre>
</article>
<article class="doc-entry" id="doc-grep">
<h3><a class="doc-anchor" href="#doc-grep">#</a> <code>grep</code></h3>
<p><code>grep { BLOCK } LIST</code> — filters the list, returning only elements for which the block evaluates to true. The current element is available as <code>_</code>. This is the eager version: it processes the entire list and returns a new list. It is Perl-compatible and works exactly like Perl's builtin <code>grep</code>. For streaming/lazy filtering in <code>|></code> pipelines, use <code>greps</code> or <code>filter</code> instead. Use <code>{ |$var| body }</code> to name the block parameter instead of <code>_</code>.</p>
<pre><code class="lang-perl">my @evens = grep { _ % 2 == 0 } 1:10
@evens |> e p # 2 4 6 8 10
grep { |$x| $x > 3 }, 1:6 # named param
my @long = grep { length(_) > 3 } @words
</code></pre>
</article>
<article class="doc-entry" id="doc-sort">
<h3><a class="doc-anchor" href="#doc-sort">#</a> <code>sort</code></h3>
<p><code>sort [BLOCK] LIST</code> — returns a new list sorted in ascending order. Without a block, <code>sort</code> compares elements as strings (lexicographic). Pass a comparator block using <code>$_0</code> and <code>$_1</code> (stryke style) or <code>$a</code> and <code>$b</code> (classic Perl) to control ordering: use <code><=></code> for numeric and <code>cmp</code> for string comparison. The sort is stable in stryke, meaning equal elements preserve their original relative order. For descending order, reverse the operands in the comparator. Use <code>{ |$x, $y| body }</code> to name the two comparator params. Works naturally in <code>|></code> pipelines.</p>
<pre><code class="lang-perl">my @nums = (3, 1, 4, 1, 5)
my @asc = sort { $_0 <=> $_1 } @nums
@asc |> e p # 1 1 3 4 5
sort { |$x, $y| $y <=> $x }, @nums # named params
my @desc = sort { $_1 <=> $_0 } @nums
@desc |> e p # 5 4 3 1 1
@nums |> sort |> e p # string sort in pipeline
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse">
<h3><a class="doc-anchor" href="#doc-reverse">#</a> <code>reverse</code></h3>
<p><code>reverse LIST</code> — in list context, return the elements in reverse order; in scalar context, reverse the characters of a string.</p>
<p>The dual nature of <code>reverse</code> is context-dependent: <code>reverse @array</code> flips element order, while <code>scalar reverse $string</code> (or just <code>reverse $string</code> in scalar context) reverses character order. In stryke, the string form is Unicode-aware, correctly reversing multi-byte characters rather than individual bytes. In <code>|></code> pipelines, use the <code>t rev</code> shorthand for a concise streaming string reverse. <code>reverse</code> does not modify the original — it always returns a new list or string.</p>
<pre><code class="lang-perl">p reverse "hello" # olleh
my @r = reverse 1:5 # (5,4,3,2,1)
@r |> e p # 5 4 3 2 1
"abc" |> t rev |> p # cba
</code></pre>
</article>
<article class="doc-entry" id="doc-reduce">
<h3><a class="doc-anchor" href="#doc-reduce">#</a> <code>reduce</code></h3>
<p><code>reduce { $_0 OP $_1 } @list</code> — performs a sequential left fold over the list. The first two elements are passed as <code>$_0</code> and <code>$_1</code> to the block; the result becomes <code>$_0</code> for the next iteration. The traditional <code>$a</code>/<code>$b</code> names are also supported for Perl compatibility. Use <code>{ |$acc, $val| body }</code> to name the two params. Returns <code>undef</code> for an empty list and the single element for a one-element list. For a fold with an explicit initial value, see <code>fold</code>.</p>
<pre><code class="lang-perl">my $fac = reduce { $_0 * $_1 } 1:6
p $fac # 720
reduce { |$acc, $val| $acc + $val }, 1:10 # 55 (named params)
my $longest = reduce { length($_0) > length($_1) ? $_0 : $_1 } @words
</code></pre>
</article>
<article class="doc-entry" id="doc-fold">
<h3><a class="doc-anchor" href="#doc-fold">#</a> <code>fold</code></h3>
<p><code>fold { $_0 OP $_1 } INIT, @list</code> — left fold with an explicit initial accumulator value. The initial value is passed as the first <code>$_0</code>, and each list element arrives as <code>$_1</code>. Unlike <code>reduce</code>, <code>fold</code> never returns <code>undef</code> for an empty list — it returns the initial value instead. Both <code>$a</code>/<code>$b</code> and <code>$_0</code>/<code>$_1</code> are supported in the block. Use <code>fold</code> when you need a guaranteed starting point for the accumulation.</p>
<pre><code class="lang-perl">my $total = fold { $_0 + $_1 } 100, 1:5
p $total # 115
my $csv = fold { "$_0,$_1" } "", @fields
</code></pre>
</article>
<article class="doc-entry" id="doc-reductions">
<h3><a class="doc-anchor" href="#doc-reductions">#</a> <code>reductions</code></h3>
<p><code>reductions { $_0 OP $_1 } @list</code> — returns the running (cumulative) results of a left fold, also known as a scan or prefix-sum. Each element of the output is the accumulator state after processing the corresponding input element. The output list has the same length as the input. Both <code>$_0</code>/<code>$_1</code> and <code>$a</code>/<code>$b</code> naming conventions are supported.</p>
<pre><code class="lang-perl">my @pfx = reductions { $_0 + $_1 } 1:4
@pfx |> e p # 1 3 6 10
1:5 |> reductions { $_0 * $_1 } |> e p # 1 2 6 24 120
</code></pre>
</article>
<article class="doc-entry" id="doc-all">
<h3><a class="doc-anchor" href="#doc-all">#</a> <code>all</code></h3>
<p><code>all { COND } @list</code> — returns true (1) if every element in the list satisfies the predicate, false ("") otherwise. The block receives each element as <code>_</code> and should return a boolean. Short-circuits on the first failing element, so it never evaluates more than necessary. Works with <code>|></code> pipelines and accepts bare lists or array variables.</p>
<pre><code class="lang-perl">my @nums = 2, 4, 6, 8
p all { _ % 2 == 0 } @nums # 1
1:100 |> all { _ > 0 } |> p # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-any">
<h3><a class="doc-anchor" href="#doc-any">#</a> <code>any</code></h3>
<p><code>any { COND } @list</code> — returns true (1) if at least one element satisfies the predicate, false ("") if none do. The block receives each element as <code>_</code>. Short-circuits on the first match, making it efficient even on large lists. <code>any</code> is a stryke global builtin and can be used in <code>|></code> pipelines.</p>
<pre><code class="lang-perl">my @vals = 1, 3, 5, 8
p any { _ > 7 } @vals # 1
1:1000 |> any { _ == 42 } |> p # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-none">
<h3><a class="doc-anchor" href="#doc-none">#</a> <code>none</code></h3>
<p><code>none { COND } @list</code> — returns true (1) if no element satisfies the predicate, false ("") if any element matches. Logically equivalent to <code>!any { COND } @list</code> but reads more naturally in guard clauses. Short-circuits on the first match. Useful for validation checks where you want to assert the absence of a condition.</p>
<pre><code class="lang-perl">my @words = ("cat", "dog", "bird")
p none { /z/ } @words # 1
p "all non-negative" if none { _ < 0 } @vals
</code></pre>
</article>
<article class="doc-entry" id="doc-first">
<h3><a class="doc-anchor" href="#doc-first">#</a> <code>first</code></h3>
<p><code>first { COND } @list</code> — returns the first element for which the block returns true, or <code>undef</code> if no element matches. The alias <code>fst</code> is also available. Short-circuits immediately upon finding a match, so only the minimum number of elements are tested. Ideal for searching sorted or unsorted lists when you need a single result.</p>
<pre><code class="lang-perl">my $f = first { _ > 10 } 3, 7, 12, 20
p $f # 12
1:1_000_000 |> first { _ % 9999 == 0 } |> p # 9999
</code></pre>
</article>
<article class="doc-entry" id="doc-min">
<h3><a class="doc-anchor" href="#doc-min">#</a> <code>min</code></h3>
<p><code>min @list</code> — returns the numerically smallest value from a list. Compares all elements using numeric (<code><=></code>) comparison, so stringy values are coerced to numbers. Returns <code>undef</code> for an empty list. In stryke, <code>min</code> is a global built-in (no import needed) and works directly in <code>|></code> pipelines.</p>
<pre><code class="lang-perl">p min(5, 3, 9, 1) # 1
my @temps = (72.1, 68.5, 74.3)
@temps |> min |> p # 68.5
</code></pre>
</article>
<article class="doc-entry" id="doc-max">
<h3><a class="doc-anchor" href="#doc-max">#</a> <code>max</code></h3>
<p><code>max @list</code> — returns the numerically largest value from a list. Compares all elements using numeric (<code><=></code>) comparison. Returns <code>undef</code> for an empty list. Like <code>min</code>, this is a stryke built-in available without imports and works in <code>|></code> pipelines. Combine with <code>map</code> to extract max values from complex structures.</p>
<pre><code class="lang-perl">p max(5, 3, 9, 1) # 9
1:100 |> map { _ ** 2 } |> max |> p # 10000
</code></pre>
</article>
<article class="doc-entry" id="doc-sum">
<h3><a class="doc-anchor" href="#doc-sum">#</a> <code>sum</code></h3>
<p><code>sum @list</code> returns the numeric sum of all elements. Returns <code>undef</code> for an empty list. <code>sum0</code> is identical except it returns <code>0</code> for an empty list, which avoids the need for a fallback <code>// 0</code> guard. Both are stryke built-ins that work in <code>|></code> pipelines. Use <code>sum0</code> in contexts where an empty input is expected and you need a safe numeric default.</p>
<pre><code class="lang-perl">p sum(1:100) # 5050
p sum0() # 0
@prices |> map { _->{amount} } |> sum0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-product">
<h3><a class="doc-anchor" href="#doc-product">#</a> <code>product</code></h3>
<p><code>product @list</code> — returns the product of all numeric elements in the list. Returns <code>undef</code> for an empty list. Useful for computing factorials, combinatoric products, and compound multipliers. In stryke this is a built-in that composes naturally with <code>|></code> pipelines and <code>range</code>.</p>
<pre><code class="lang-perl">p product(1:5) # 120
range(1, 10) |> product |> p # 3628800
</code></pre>
</article>
<article class="doc-entry" id="doc-mean">
<h3><a class="doc-anchor" href="#doc-mean">#</a> <code>mean</code></h3>
<p><code>mean @list</code> — returns the arithmetic mean (average) of a numeric list. Computed as <code>sum / count</code> in a single pass. Returns <code>undef</code> for an empty list. The result is always a floating-point value even if all inputs are integers. Combine with <code>map</code> to compute averages over extracted fields.</p>
<pre><code class="lang-perl">p mean(2, 4, 6, 8) # 5
@students |> map { _->{score} } |> mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-median">
<h3><a class="doc-anchor" href="#doc-median">#</a> <code>median</code></h3>
<p><code>median @list</code> — returns the median value of a numeric list. For odd-length lists, this is the middle element after sorting. For even-length lists, it is the arithmetic mean of the two middle elements. The input list does not need to be pre-sorted. Returns <code>undef</code> for an empty list.</p>
<pre><code class="lang-perl">p median(1, 3, 5, 7, 9) # 5
p median(1, 3, 5, 7) # 4
1:100 |> median |> p # 50.5
</code></pre>
</article>
<article class="doc-entry" id="doc-mode">
<h3><a class="doc-anchor" href="#doc-mode">#</a> <code>mode</code></h3>
<p><code>mode @list</code> — returns the most frequently occurring value in the list. If there is a tie, the value that appears first in the list wins. Returns <code>undef</code> for an empty list. Works with both numeric and string values — comparison is done by stringification. Useful for finding the dominant category in a dataset.</p>
<pre><code class="lang-perl">p mode(1, 2, 2, 3, 3, 3) # 3
my @logs = qw(INFO WARN INFO ERROR INFO)
p mode(@logs) # INFO
</code></pre>
</article>
<article class="doc-entry" id="doc-stddev">
<h3><a class="doc-anchor" href="#doc-stddev">#</a> <code>stddev</code></h3>
<p><code>stddev @list</code> (alias <code>std</code>) — returns the population standard deviation of a numeric list. This is the square root of the population variance, measuring how spread out values are from the mean. Uses N (not N-1) in the denominator, so it computes the population statistic rather than the sample statistic. Returns <code>undef</code> for an empty list.</p>
<pre><code class="lang-perl">p stddev(2, 4, 4, 4, 5, 5, 7, 9) # 2
1:10 |> std |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-variance">
<h3><a class="doc-anchor" href="#doc-variance">#</a> <code>variance</code></h3>
<p><code>variance @list</code> — returns the population variance of a numeric list, computed as the mean of the squared deviations from the mean. Like <code>stddev</code>, this uses N (not N-1) as the divisor. The variance is <code>stddev ** 2</code>. Returns <code>undef</code> for an empty list. Useful for statistical analysis and as a building block for higher-order stats.</p>
<pre><code class="lang-perl">p variance(2, 4, 4, 4, 5, 5, 7, 9) # 4
my @samples = map { rand(100) } 1:1000
p variance(@samples)
</code></pre>
</article>
<article class="doc-entry" id="doc-sample">
<h3><a class="doc-anchor" href="#doc-sample">#</a> <code>sample</code></h3>
<p><code>sample N, @list</code> — returns a random sample of N elements drawn without replacement from the list. The returned elements are in random order. If N exceeds the list length, the entire list is returned (shuffled). Uses a Fisher-Yates partial shuffle internally for efficiency. Each call produces a different result due to random selection.</p>
<pre><code class="lang-perl">my @pick = sample 3, 1:100
@pick |> e p # 3 random values
my @test_cases = sample 10, @all_cases
</code></pre>
</article>
<article class="doc-entry" id="doc-shuffle">
<h3><a class="doc-anchor" href="#doc-shuffle">#</a> <code>shuffle</code></h3>
<p><code>shuffle @list</code> — returns a new list with all elements in random order using a Fisher-Yates shuffle. The original list is not modified. Every permutation is equally likely. In stryke this is a global built-in; no import is needed. The alias <code>shuf</code> is also available. Commonly used with <code>|></code> and <code>take</code> to draw random subsets.</p>
<pre><code class="lang-perl">my @deck = shuffle 1:52
@deck |> take 5 |> e p # 5 random cards
my @randomized = shuffle @questions
</code></pre>
</article>
<article class="doc-entry" id="doc-uniq">
<h3><a class="doc-anchor" href="#doc-uniq">#</a> <code>uniq</code></h3>
<p><code>uniq @list</code> — removes duplicate elements from a list, preserving the order of first occurrence. Comparison is done by string equality. The alias <code>uq</code> is also available. This is eager (not streaming) and returns a new list. For streaming deduplication in <code>|></code> pipelines, use <code>distinct</code>. For type-specific comparison, see <code>uniqnum</code>, <code>uniqstr</code>, and <code>uniqint</code>.</p>
<pre><code class="lang-perl">my @u = uniq 1, 2, 2, 3, 1, 3
@u |> e p # 1 2 3
my @hosts = uniq @all_hosts
</code></pre>
</article>
<article class="doc-entry" id="doc-uniqint">
<h3><a class="doc-anchor" href="#doc-uniqint">#</a> <code>uniqint</code></h3>
<p><code>uniqint @list</code> — removes duplicate elements comparing values as integers. Each element is truncated to its integer part before comparison, so <code>1.1</code> and <code>1.9</code> are considered equal (both become <code>1</code>). The first occurrence is kept. This is useful when you have floating-point data but care only about the integer portion for uniqueness.</p>
<pre><code class="lang-perl">my @u = uniqint 1, 1.1, 1.9, 2
@u |> e p # 1 2
my @distinct_ids = uniqint @raw_ids
</code></pre>
</article>
<article class="doc-entry" id="doc-uniqnum">
<h3><a class="doc-anchor" href="#doc-uniqnum">#</a> <code>uniqnum</code></h3>
<p><code>uniqnum @list</code> — removes duplicate elements comparing values as floating-point numbers. Unlike <code>uniq</code> (which compares as strings), <code>uniqnum</code> treats <code>1.0</code> and <code>1.00</code> as equal because they have the same numeric value. The first occurrence of each numeric value is preserved. Use this when your data contains numbers that may have different string representations.</p>
<pre><code class="lang-perl">my @u = uniqnum 1.0, 1.00, 2.5, 2.50
@u |> e p # 1 2.5
my @prices = uniqnum @all_prices
</code></pre>
</article>
<article class="doc-entry" id="doc-uniqstr">
<h3><a class="doc-anchor" href="#doc-uniqstr">#</a> <code>uniqstr</code></h3>
<p><code>uniqstr @list</code> — removes duplicate elements comparing values strictly as strings. This is the same comparison as <code>uniq</code> but makes the intent explicit. Numeric values <code>1</code> and <code>1.0</code> are considered different because their string representations differ. Use <code>uniqstr</code> when you want to be explicit that string semantics are intended.</p>
<pre><code class="lang-perl">my @u = uniqstr "a", "b", "a", "c"
@u |> e p # a b c
my @tags = uniqstr @all_tags
</code></pre>
</article>
<article class="doc-entry" id="doc-zip">
<h3><a class="doc-anchor" href="#doc-zip">#</a> <code>zip</code></h3>
<p><code>zip(\@a, \@b, ...)</code> — combines multiple arrays element-wise into a list of arrayrefs. Each output arrayref contains one element from each input array at the corresponding index. Accepts two or more array references. The alias <code>zp</code> is also available. By default, <code>zip</code> pads shorter arrays with <code>undef</code> (equivalent to <code>zip_longest</code>). For truncating behavior, use <code>zip_shortest</code>.</p>
<pre><code class="lang-perl">my @a = 1:3
my @b = ("a","b","c")
zip(\@a, \@b) |> e p # [1,a] [2,b] [3,c]
my @matrix = zip(\@xs, \@ys, \@zs)
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-longest">
<h3><a class="doc-anchor" href="#doc-zip-longest">#</a> <code>zip_longest</code></h3>
<p><code>zip_longest(\@a, \@b, ...)</code> — combines arrays element-wise, padding shorter arrays with <code>undef</code> to match the longest. This is the explicit version of the default <code>zip</code> behavior. Every input array contributes exactly one element per output tuple; missing elements become <code>undef</code>. Useful when you need to process all data from unequal-length sources.</p>
<pre><code class="lang-perl">my @a = 1:3
my @b = ("x")
zip_longest(\@a, \@b) |> e p # [1,x] [2,undef] [3,undef]
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-shortest">
<h3><a class="doc-anchor" href="#doc-zip-shortest">#</a> <code>zip_shortest</code></h3>
<p><code>zip_shortest(\@a, \@b, ...)</code> — combines arrays element-wise, stopping at the shortest input array. No <code>undef</code> padding is produced; the output length equals the minimum input length. Use this when you only want complete tuples and extra trailing elements should be discarded.</p>
<pre><code class="lang-perl">my @a = 1:5
my @b = ("x","y")
zip_shortest(\@a, \@b) |> e p # [1,x] [2,y]
my @paired = zip_shortest(\@keys, \@values)
</code></pre>
</article>
<article class="doc-entry" id="doc-chunked">
<h3><a class="doc-anchor" href="#doc-chunked">#</a> <code>chunked</code></h3>
<p><code>chunked N, @list</code> — splits a list into non-overlapping chunks of N elements each. Each chunk is an arrayref. The final chunk may contain fewer than N elements if the list length is not evenly divisible. The alias <code>chk</code> is also available. In stryke, <code>chunked</code> is eager and returns a list of arrayrefs; for streaming chunk behavior in pipelines, use <code>chunk</code>.</p>
<pre><code class="lang-perl">my @ch = chunked 3, 1:7
@ch |> e p # [1,2,3] [4,5,6] [7]
1:12 |> chunked 4 |> e { p join ",", @_ }
</code></pre>
</article>
<article class="doc-entry" id="doc-windowed">
<h3><a class="doc-anchor" href="#doc-windowed">#</a> <code>windowed</code></h3>
<p><code>windowed N, @list</code> — returns a sliding window of N consecutive elements over the list. Each window is an arrayref. The output contains <code>len - N + 1</code> windows. Unlike <code>chunked</code>, windows overlap: each successive window advances by one element. The alias <code>win</code> is also available. Useful for computing moving averages, detecting patterns in sequences, or n-gram extraction.</p>
<pre><code class="lang-perl">my @w = windowed 3, 1:5
@w |> e p # [1,2,3] [2,3,4] [3,4,5]
my @deltas = windowed(2, @vals) |> map { _->[1] - _->[0] }
</code></pre>
</article>
<article class="doc-entry" id="doc-pairs">
<h3><a class="doc-anchor" href="#doc-pairs">#</a> <code>pairs</code></h3>
<p><code>pairs @list</code> — takes a flat list and groups consecutive elements into pairs, returning a list of two-element arrayrefs <code>([$k, $v], ...)</code>. The input list must have an even number of elements. Each pair can be accessed via array indexing (<code>_->[0]</code>, <code>_->[1]</code>). This is the inverse of <code>unpairs</code> and is commonly used to iterate over hash-like flat lists in a structured way.</p>
<pre><code class="lang-perl">my @p = pairs "a", 1, "b", 2
@p |> e { p "_->[0]=_->[1]" } # a=1 b=2
my @entries = pairs %hash
</code></pre>
</article>
<article class="doc-entry" id="doc-unpairs">
<h3><a class="doc-anchor" href="#doc-unpairs">#</a> <code>unpairs</code></h3>
<p><code>unpairs @list_of_pairs</code> — flattens a list of two-element arrayrefs back into a flat key-value list. This is the inverse of <code>pairs</code>. Each arrayref <code>[$k, $v]</code> becomes two consecutive elements in the output. Useful for converting structured pair data back into a format suitable for hash assignment or flat list processing.</p>
<pre><code class="lang-perl">my @flat = unpairs ["a",1], ["b",2]
@flat |> e p # a 1 b 2
my %h = unpairs @filtered_pairs
</code></pre>
</article>
<article class="doc-entry" id="doc-pairkeys">
<h3><a class="doc-anchor" href="#doc-pairkeys">#</a> <code>pairkeys</code></h3>
<p><code>pairkeys @list</code> — extracts the keys (even-indexed elements) from a flat pairlist. Given a list like <code>("a", 1, "b", 2, "c", 3)</code>, returns <code>("a", "b", "c")</code>. This is equivalent to <code>map { _->[0] } pairs @list</code> but more concise and efficient. Useful for extracting just the key side of a key-value flat list without constructing intermediate pair objects.</p>
<pre><code class="lang-perl">my @k = pairkeys "a", 1, "b", 2, "c", 3
@k |> e p # a b c
my @config_pairs = (host => "localhost", port => 8080)
my @names = pairkeys @config_pairs
</code></pre>
</article>
<article class="doc-entry" id="doc-pairvalues">
<h3><a class="doc-anchor" href="#doc-pairvalues">#</a> <code>pairvalues</code></h3>
<p><code>pairvalues @list</code> — extracts the values (odd-indexed elements) from a flat pairlist. Given <code>("a", 1, "b", 2)</code>, returns <code>(1, 2)</code>. This is equivalent to <code>map { _->[1] } pairs @list</code> but more concise. Pair it with <code>pairkeys</code> to split a flat key-value list into separate key and value arrays.</p>
<pre><code class="lang-perl">my @v = pairvalues "a", 1, "b", 2
@v |> e p # 1 2
my @defaults = (timeout => 30, retries => 3)
my @settings = pairvalues @defaults
</code></pre>
</article>
<article class="doc-entry" id="doc-pairmap">
<h3><a class="doc-anchor" href="#doc-pairmap">#</a> <code>pairmap</code></h3>
<p><code>pairmap BLOCK @list</code> — maps over consecutive pairs in a flat list, passing the key as <code>$_0</code> (or <code>$a</code>) and the value as <code>$_1</code> (or <code>$b</code>). The block can return any number of elements. This is the pair-aware equivalent of <code>map</code> and is ideal for transforming hash-like flat lists. The result is a flat list of whatever the block returns.</p>
<pre><code class="lang-perl">my @out = pairmap { "$_0=$_1" } "a", 1, "b", 2
@out |> e p # a=1 b=2
my @cfg_pairs = (host => "x", port => 80)
my @upper = pairmap { uc($_0), $_1 } @cfg_pairs
</code></pre>
</article>
<article class="doc-entry" id="doc-pairgrep">
<h3><a class="doc-anchor" href="#doc-pairgrep">#</a> <code>pairgrep</code></h3>
<p><code>pairgrep { BLOCK } @list</code> — filters consecutive pairs from a flat list, keeping only those where the block returns true. The key is available as <code>$_0</code> (or <code>$a</code>) and the value as <code>$_1</code> (or <code>$b</code>). Returns a flat list of the matching key-value pairs. This is the pair-aware equivalent of <code>grep</code> and is useful for filtering hash-like data by both key and value simultaneously.</p>
<pre><code class="lang-perl">my @big = pairgrep { $_1 > 5 } "a", 3, "b", 9, "c", 1
@big |> e p # b 9
my @alert_pairs = (info => 1, critical_a => 9, critical_b => 7)
my @important = pairgrep { $_0 =~ /^critical/ } @alert_pairs
</code></pre>
</article>
<article class="doc-entry" id="doc-pairfirst">
<h3><a class="doc-anchor" href="#doc-pairfirst">#</a> <code>pairfirst</code></h3>
<p><code>pairfirst { BLOCK } @list</code> — returns the first pair from a flat list where the block returns true, as a two-element list <code>($key, $value)</code>. The key is <code>$_0</code> (or <code>$a</code>) and the value is <code>$_1</code> (or <code>$b</code>). Short-circuits on the first match. Returns an empty list if no pair matches. This is the pair-aware equivalent of <code>first</code>.</p>
<pre><code class="lang-perl">my @hit = pairfirst { $_1 > 5 } "x", 2, "y", 8
p "@hit" # y 8
my @flags = (info => 1, debug => 7, trace => 0)
my ($k, $v) = pairfirst { $_0 eq "debug" } @flags
</code></pre>
</article>
<article class="doc-entry" id="doc-mesh">
<h3><a class="doc-anchor" href="#doc-mesh">#</a> <code>mesh</code></h3>
<p><code>mesh(\@a, \@b, ...)</code> — interleaves multiple arrays into a flat list rather than arrayrefs. While <code>zip</code> returns <code>([1,"a"], [2,"b"])</code>, <code>mesh</code> returns <code>(1, "a", 2, "b")</code>. This makes it ideal for constructing hashes from parallel key and value arrays. The result is a flat list suitable for direct hash assignment.</p>
<pre><code class="lang-perl">my @k = ("a","b")
my @v = (1,2)
my %h = mesh(\@k, \@v)
p $h{a} # 1
my %lookup = mesh(\@ids, \@names)
</code></pre>
</article>
<article class="doc-entry" id="doc-mesh-longest">
<h3><a class="doc-anchor" href="#doc-mesh-longest">#</a> <code>mesh_longest</code></h3>
<p><code>mesh_longest(\@a, \@b, ...)</code> — interleaves arrays into a flat list, padding shorter arrays with <code>undef</code> to match the longest. Like <code>mesh</code>, the output is flat (not arrayrefs). Missing elements become <code>undef</code> in the output sequence. Use this when building a flat interleaved list from arrays of unequal length where you need every element represented.</p>
<pre><code class="lang-perl">my @a = 1:3
my @b = ("x")
my @r = mesh_longest(\@a, \@b)
@r |> e p # 1 x 2 undef 3 undef
</code></pre>
</article>
<article class="doc-entry" id="doc-mesh-shortest">
<h3><a class="doc-anchor" href="#doc-mesh-shortest">#</a> <code>mesh_shortest</code></h3>
<p><code>mesh_shortest(\@a, \@b, ...)</code> — interleaves arrays into a flat list, stopping at the shortest input array. No <code>undef</code> padding is produced; trailing elements from longer arrays are silently dropped. Use this when you only want complete interleaved groups and partial data should be discarded.</p>
<pre><code class="lang-perl">my @a = 1:3
my @b = ("x","y")
my @r = mesh_shortest(\@a, \@b)
@r |> e p # 1 x 2 y
</code></pre>
</article>
<article class="doc-entry" id="doc-partition">
<h3><a class="doc-anchor" href="#doc-partition">#</a> <code>partition</code></h3>
<p><code>partition</code> — functional / iterator builtin. Alias for <code>take_while</code>.</p>
<pre><code class="lang-perl">my $result = partition $x
# or in a pipeline:
@list |> map partition |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-frequencies">
<h3><a class="doc-anchor" href="#doc-frequencies">#</a> <code>frequencies</code></h3>
<p><code>frequencies</code> (aliases <code>freq</code>, <code>frq</code>) counts how many times each distinct element appears in a list and returns a hashref mapping each value to its count. This is the stryke equivalent of a histogram or counter — useful for analyzing log files, counting word occurrences, tallying categorical data, or finding duplicates. The input list is flattened, so you can pass arrays directly. The returned hashref can be fed into <code>dd</code> for inspection or <code>to_json</code> for serialization.</p>
<pre><code class="lang-perl">my @words = qw(apple banana apple cherry banana apple)
my $counts = freq @words
p $counts # {apple => 3, banana => 2, cherry => 1}
rl("access.log") |> map { /^(\S+)/ && $1 } |> freq |> dd
my @rolls = map { 1 + int(rand 6) } 1:1000
frq(@rolls) |> to_json |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tally">
<h3><a class="doc-anchor" href="#doc-tally">#</a> <code>tally</code></h3>
<p><code>tally</code> counts how many times each distinct element appears in a list and returns a hash ref mapping element → count. This is the same as Ruby's <code>Enumerable#tally</code> or Python's <code>Counter</code>. Similar to <code>frequencies</code> but follows the Ruby naming convention.</p>
<pre><code class="lang-perl">my $t = tally("a", "b", "a", "c", "a", "b")
p $t->{a} # 3
p $t->{b} # 2
qw(red blue red green blue red) |> tally |> dd
</code></pre>
</article>
<article class="doc-entry" id="doc-interleave">
<h3><a class="doc-anchor" href="#doc-interleave">#</a> <code>interleave</code></h3>
<p><code>interleave</code> (alias <code>il</code>) merges two or more arrays by alternating their elements: first element of each array, then second element of each, and so on. If the arrays have different lengths, shorter arrays contribute <code>undef</code> for their missing positions. This is useful for building key-value pair lists from separate key and value arrays, creating round-robin schedules, or weaving parallel data streams together.</p>
<pre><code class="lang-perl">my @keys = qw(name age city)
my @vals = ("Alice", 30, "NYC")
my @pairs = il \@keys, \@vals
p @pairs # name, Alice, age, 30, city, NYC
my %h = il \@keys, \@vals
p $h{name} # Alice
my @rgb = il [255,0,0], [0,255,0], [0,0,255]
</code></pre>
</article>
<article class="doc-entry" id="doc-pluck">
<h3><a class="doc-anchor" href="#doc-pluck">#</a> <code>pluck</code></h3>
<p><code>pluck KEY, LIST_OF_HASHREFS</code> — extract a single key from each hashref in the list.</p>
<p>For each element, <code>pluck</code> dereferences it as a hashref and returns the value at the given key. Elements where the key is missing yield <code>undef</code>. This is a streaming operation: in a pipeline, each hashref is processed and the extracted value is emitted immediately. It is the stryke equivalent of <code>map { _->{KEY} }</code> but more readable and optimized internally.</p>
<pre><code class="lang-perl">@users |> pluck "name" |> e p
my @ids = pluck "id", @records
@rows |> pluck "email" |> distinct |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-grep-v">
<h3><a class="doc-anchor" href="#doc-grep-v">#</a> <code>grep_v</code></h3>
<p><code>grep_v PATTERN, LIST</code> — inverse grep: reject elements that match the pattern, keep the rest.</p>
<p>This is the complement of <code>grep</code> — any element where the pattern matches is dropped, and non-matching elements pass through. It accepts a regex, a string, or a code block as the pattern. In streaming mode, each element is tested and either forwarded or discarded without buffering. This is a stryke built-in that avoids the awkward <code>grep { !/pattern/ }</code> double-negation.</p>
<pre><code class="lang-perl">@words |> grep_v /^ #/ |> e p # drop comments
my @clean = grep_v qr/tmp/, @files
stdin |> grep_v /^\s*$/ |> e p # drop blank lines
</code></pre>
</article>
<article class="doc-entry" id="doc-select-keys">
<h3><a class="doc-anchor" href="#doc-select-keys">#</a> <code>select_keys</code></h3>
<p><code>select_keys</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = select_keys $x
# or in a pipeline:
@list |> map select_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp">
<h3><a class="doc-anchor" href="#doc-clamp">#</a> <code>clamp</code></h3>
<p><code>clamp</code> (alias <code>clp</code>) constrains each value in a list to lie within a specified minimum and maximum range. Values below the minimum are raised to it; values above the maximum are lowered to it; values already in range pass through unchanged. This is essential for sanitizing user input, bounding computed values before display, or enforcing physical constraints in simulations. When given a single scalar, it returns a single clamped value.</p>
<pre><code class="lang-perl">my @scores = (105, -3, 42, 99, 200)
my @clamped = clp 0, 100, @scores
p @clamped # 100, 0, 42, 99, 100
my $val = clp 0, 255, $input # bound to byte range
my @pct = map { clp 0.0, 1.0, _ } @raw_ratios
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize">
<h3><a class="doc-anchor" href="#doc-normalize">#</a> <code>normalize</code></h3>
<p><code>normalize</code> (alias <code>nrm</code>) rescales a list of numeric values so that the minimum maps to 0 and the maximum maps to 1, using min-max normalization. This is a standard preprocessing step for machine learning features, data visualization (mapping values to color gradients or bar heights), and statistical analysis. If all values are identical, the result is a list of zeros to avoid division by zero. The output preserves the relative ordering of the input.</p>
<pre><code class="lang-perl">my @temps = (32, 68, 100, 212)
my @normed = nrm @temps
p @normed # 0, 0.2, 0.377..., 1
my @pixels = nrm @raw_intensities
@pixels |> map { int(_ * 255) } |> e p # scale to 0-255
</code></pre>
</article>
<article class="doc-entry" id="doc-compose">
<h3><a class="doc-anchor" href="#doc-compose">#</a> <code>compose</code></h3>
<p><code>compose</code> (alias <code>comp</code>) creates a right-to-left function composition. Given <code>compose(\&f, \&g)</code>, calling the result with <code>x</code> computes <code>f(g(x))</code>. Chain any number of functions — they apply from right to left (last argument first). This is the standard mathematical function composition found in Haskell, Clojure, and Ramda. The returned code ref can be stored, passed around, or used in pipelines.</p>
<pre><code class="lang-perl">my $double = fn { $_[0] * 2 }
my $inc = fn { $_[0] + 1 }
my $f = compose($inc, $double)
p $f->(5) # 11 (double 5 → 10, inc 10 → 11)
my $pipeline = compose(
fn { join ",", @{$_[0]} },
fn { [sort @{$_[0]}] },
fn { [grep { _ > 2 } @{$_[0]}] },
)
p $pipeline->([3,1,4,1,5]) # 3,4,5
</code></pre>
</article>
<article class="doc-entry" id="doc-partial">
<h3><a class="doc-anchor" href="#doc-partial">#</a> <code>partial</code></h3>
<p><code>partial</code> returns a partially applied function — the bound arguments are prepended to any arguments supplied at call time. <code>partial(\&f, @bound)->(x)</code> is equivalent to <code>f(@bound, x)</code>. This is the standard partial application from functional programming, useful for creating specialized versions of general functions without closures.</p>
<pre><code class="lang-perl">my $add = fn { $_[0] + $_[1] }
my $add5 = partial($add, 5)
p $add5->(3) # 8
my $log = fn { p "[$_[0]] $_[1]" }
my $warn_log = partial($log, "WARN")
$warn_log->("disk full") # [WARN] disk full
</code></pre>
</article>
<article class="doc-entry" id="doc-curry">
<h3><a class="doc-anchor" href="#doc-curry">#</a> <code>curry</code></h3>
<p><code>curry</code> auto-curries a function with a given arity. The curried function accumulates arguments across calls and invokes the original only when enough have been collected. <code>curry(\&f, N)->(a)->(b)</code> calls <code>f(a, b)</code> when N=2. If all arguments are supplied at once, it calls immediately.</p>
<pre><code class="lang-perl">my $add = curry(fn { $_[0] + $_[1] }, 2)
my $add5 = $add->(5)
p $add5->(3) # 8
p $add->(10, 20) # 30 (enough args — calls immediately)
</code></pre>
</article>
<article class="doc-entry" id="doc-memoize">
<h3><a class="doc-anchor" href="#doc-memoize">#</a> <code>memoize</code></h3>
<p><code>memoize</code> (alias <code>memo</code>) wraps a function so that repeated calls with the same arguments return a cached result instead of re-executing the function. Arguments are stringified and joined as the cache key. This is essential for expensive pure functions like recursive algorithms, API lookups with stable results, or any computation where the same inputs always produce the same output.</p>
<pre><code class="lang-perl">my $fib = memoize(fn {
my $n = $_[0]
$n < 2 ? $n : $fib->($n-1) + $fib->($n-2)
})
p $fib->(30) # instant (without memoize: ~1B calls)
my $fetch_user = memo(fn { fetch_json("https://api/users/$_[0]") })
$fetch_user->(42) # hits API
$fetch_user->(42) # returns cached
</code></pre>
</article>
<article class="doc-entry" id="doc-once">
<h3><a class="doc-anchor" href="#doc-once">#</a> <code>once</code></h3>
<p><code>once</code> wraps a function so it is called at most once. The first invocation executes the function and caches the result; all subsequent calls return the cached value without re-executing. This is ideal for lazy initialization, one-time setup, or singleton patterns.</p>
<pre><code class="lang-perl">my $init = once(fn { p "initializing..."
42 })
p $init->() # prints "initializing..." → 42
p $init->() # 42 (no print — cached)
p $init->() # 42 (still cached)
</code></pre>
</article>
<article class="doc-entry" id="doc-constantly">
<h3><a class="doc-anchor" href="#doc-constantly">#</a> <code>constantly</code></h3>
<p><code>constantly</code> (alias <code>const</code>) returns a function that ignores all arguments and always returns the given value. Useful as a default callback, a stub in higher-order function pipelines, or anywhere a function is required but a fixed value suffices.</p>
<pre><code class="lang-perl">my $zero = constantly(0)
p $zero->("anything") # 0
my @defaults = map { constantly(0)->() } 1:5 # [0,0,0,0,0]
</code></pre>
</article>
<article class="doc-entry" id="doc-complement">
<h3><a class="doc-anchor" href="#doc-complement">#</a> <code>complement</code></h3>
<p><code>complement</code> (alias <code>compl</code>) wraps a predicate function and returns a new function that negates its boolean result. <code>complement(\&even?)->(3)</code> returns true. This is the functional equivalent of <code>!f(x)</code> without creating a closure.</p>
<pre><code class="lang-perl">my $even = fn { $_[0] % 2 == 0 }
my $odd = complement($even)
p $odd->(3) # 1
p $odd->(4) # 0
1:10 |> grep { complement($even)->(_) } |> e p # 1 3 5 7 9
</code></pre>
</article>
<article class="doc-entry" id="doc-juxt">
<h3><a class="doc-anchor" href="#doc-juxt">#</a> <code>juxt</code></h3>
<p><code>juxt</code> (juxtapose) takes multiple functions and returns a new function that calls each one with the same arguments and collects the results into an array. This is useful for computing multiple derived values from the same input in a single pass.</p>
<pre><code class="lang-perl">my $stats = juxt(fn { min @_ }, fn { max @_ }, fn { avg @_ })
my @r = $stats->(3, 1, 4, 1, 5)
p "@r" # 1 5 2.8
</code></pre>
</article>
<article class="doc-entry" id="doc-fnil">
<h3><a class="doc-anchor" href="#doc-fnil">#</a> <code>fnil</code></h3>
<p><code>fnil</code> wraps a function so that any <code>undef</code> arguments are replaced with the given defaults before the function is called. This eliminates repetitive <code>// $default</code> patterns inside function bodies.</p>
<pre><code class="lang-perl">my $greet = fnil(fn { "Hello, $_[0]!" }, "World")
p $greet->(undef) # Hello, World!
p $greet->("Alice") # Hello, Alice!
</code></pre>
</article>
<article class="doc-entry" id="doc-deep-clone">
<h3><a class="doc-anchor" href="#doc-deep-clone">#</a> <code>deep_clone</code></h3>
<p><code>deep_clone</code> (alias <code>dclone</code>) performs a recursive deep copy of a nested data structure. Array refs, hash refs, and scalar refs are cloned recursively so that the result shares no references with the original. Modifications to the clone never affect the source. This is the stryke equivalent of JavaScript's <code>structuredClone</code> or Perl's <code>Storable::dclone</code>.</p>
<pre><code class="lang-perl">my $orig = {users => [{name => "Alice"}], meta => {v => 1}}
my $copy = deep_clone($orig)
$copy->{users}[0]{name} = "Bob"
p $orig->{users}[0]{name} # Alice (unchanged)
</code></pre>
</article>
<article class="doc-entry" id="doc-deep-merge">
<h3><a class="doc-anchor" href="#doc-deep-merge">#</a> <code>deep_merge</code></h3>
<p><code>deep_merge</code> (alias <code>dmerge</code>) recursively merges two hash references. When both sides have a hash ref for the same key, they are merged recursively; otherwise the right-hand value wins. This is the standard deep merge from Lodash, Ruby's <code>deep_merge</code>, and config-file overlay patterns. Returns a new hash ref — neither input is modified.</p>
<pre><code class="lang-perl">my $defaults = {db => {host => "localhost", port => 5432}, debug => 0}
my $overrides = {db => {port => 3306}, debug => 1}
my $cfg = deep_merge($defaults, $overrides)
p $cfg->{db}{host} # localhost (from defaults)
p $cfg->{db}{port} # 3306 (overridden)
p $cfg->{debug} # 1 (overridden)
</code></pre>
</article>
<article class="doc-entry" id="doc-deep-equal">
<h3><a class="doc-anchor" href="#doc-deep-equal">#</a> <code>deep_equal</code></h3>
<p><code>deep_equal</code> (alias <code>deq</code>) performs structural equality comparison of two values, recursively descending into array refs, hash refs, and scalar refs. Returns 1 if the structures are identical, 0 otherwise. This is the stryke equivalent of Node's <code>assert.deepStrictEqual</code>, Lodash <code>isEqual</code>, or Python's <code>==</code> on nested dicts/lists.</p>
<pre><code class="lang-perl">p deep_equal([1, {a => 2}], [1, {a => 2}]) # 1
p deep_equal([1, {a => 2}], [1, {a => 3}]) # 0
p deq({x => [1,2]}, {x => [1,2]}) # 1
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-stryke-extensions">
<h2>stryke Extensions</h2>
<p class="chapter-meta">19 topics</p>
<article class="doc-entry" id="doc-fn">
<h3><a class="doc-anchor" href="#doc-fn">#</a> <code>fn</code></h3>
<p>Define a named or anonymous function with optional typed parameters and default values. Named functions are installed into the current package; anonymous functions (closures) capture their enclosing lexical scope. Functions are first-class values — assign them to scalars, store in arrays, pass as callbacks. The last expression evaluated is the implicit return value unless an explicit <code>return</code> is used.</p>
<pre><code class="lang-perl">fn dbl($x) { $x * 2 }
my $f = fn { _ * 2 }
my $add = fn ($a: Int, $b: Int) { $a + $b }
# Default parameter values:
fn greet($name = "world") { p "hello $name" }
greet() # hello world
greet("Alice") # hello Alice
fn range_check($x, $min = 0, $max = 100) { $min <= $x <= $max }
fn with_list(@items = (1, 2, 3)) { join "-", @items }
fn with_hash(%opts = (debug => 0)) { $opts{debug} }
</code></pre>
<p>Default values are evaluated at call time if the argument is not provided.</p>
</article>
<article class="doc-entry" id="doc-struct">
<h3><a class="doc-anchor" href="#doc-struct">#</a> <code>struct</code></h3>
<p><code>struct</code> declares a named record type with typed fields, giving stryke lightweight struct semantics similar to Rust structs or Python dataclasses. Structs support multiple construction syntaxes, default values, field mutation, user-defined methods, functional updates, and structural equality.</p>
<p><strong>Declaration:</strong></p>
<pre><code class="lang-perl">struct Point { x => Float, y => Float } # typed fields
struct Point { x => Float = 0.0, y => Float = 0.0 } # with defaults
struct Pair { key, value } # untyped (Any)
</code></pre>
<p><strong>Construction:</strong></p>
<pre><code class="lang-perl">my $p = Point(x => 1.5, y => 2.0) # function-call with named args
my $p = Point(1.5, 2.0) # positional (declaration order)
my $p = Point->new(x => 1.5, y => 2.0) # traditional OO style
my $p = Point() # uses defaults if defined
</code></pre>
<p><strong>Field access (getter/setter):</strong></p>
<pre><code class="lang-perl">p $p->x # getter (0 args)
$p->x(3.0) # setter (1 arg)
</code></pre>
<p><strong>User-defined methods:</strong></p>
<pre><code class="lang-perl">struct Circle {
radius => Float,
fn area { 3.14159 * $self->radius ** 2 }
fn scale($factor: Float) {
Circle(radius => $self->radius * $factor)
}
}
my $c = Circle(radius => 5)
p $c->area # 78.53975
p $c->scale(2) # Circle(radius => 10)
</code></pre>
<p><strong>Built-in methods:</strong></p>
<pre><code class="lang-perl">my $q = $p->with(x => 5) # functional update — new instance
my $h = $p->to_hash # { x => 1.5, y => 2.0 }
my @f = $p->fields # (x, y)
my $c = $p->clone # deep copy
</code></pre>
<p><strong>Smart stringify:</strong></p>
<pre><code class="lang-perl">p $p # Point(x => 1.5, y => 2)
</code></pre>
<p><strong>Structural equality:</strong></p>
<pre><code class="lang-perl">my $a = Point(1, 2)
my $b = Point(1, 2)
p $a == $b # 1 (compares all fields)
</code></pre>
<p>Note: field type is checked at construction and mutation; unknown field names are fatal errors.</p>
</article>
<article class="doc-entry" id="doc-typed">
<h3><a class="doc-anchor" href="#doc-typed">#</a> <code>typed</code></h3>
<p><code>typed</code> adds optional runtime type annotations to lexical variables and subroutine parameters. When a <code>typed</code> declaration is in effect, stryke inserts a lightweight check at assignment time that verifies the value matches the declared type (<code>Int</code>, <code>Str</code>, <code>Float</code>, <code>Bool</code>, <code>ArrayRef</code>, <code>HashRef</code>, or a user-defined <code>struct</code> name). This is especially useful for catching accidental type mismatches at function boundaries in larger programs. The annotation is purely a runtime guard — it has zero impact on pipeline performance because the check is only performed once at the point of assignment, not on every read.</p>
<pre><code class="lang-perl">typed my $x : Int = 42
typed my $name : Str = "hello"
typed my $pi : Float = 3.14
my $add = fn ($a: Int, $b: Int) { $a + $b }
p $add->(3, 4) # 7
</code></pre>
<p>Note: assigning a value of the wrong type raises a runtime exception immediately.</p>
<p>You can mix typed and untyped variables freely in the same scope, so adopting <code>typed</code> is incremental — annotate the variables that matter and leave the rest dynamic. Subroutine parameters declared with type annotations in <code>fn</code> are checked on every call, giving you contract-style validation at function boundaries without a separate assertion library.</p>
<pre><code class="lang-perl">typed my @nums : Int = (1, 2, 3)
typed my %cfg : Str = (host => "localhost", port => "8080")
</code></pre>
</article>
<article class="doc-entry" id="doc-match">
<h3><a class="doc-anchor" href="#doc-match">#</a> <code>match</code></h3>
<p>Algebraic pattern matching (stryke extension).</p>
<pre><code class="lang-perl">match ($val) {
/^\d+$/ => p "number: $val",
[1, 2, _] => p "array starting with 1,2",
{ name => $n } => p "name is $n",
_ => p "default",
}
</code></pre>
<p>Patterns: regex, array, hash, literal, wildcard <code>_</code>. Optional <code>if</code> guard per arm.</p>
</article>
<article class="doc-entry" id="doc-frozen">
<h3><a class="doc-anchor" href="#doc-frozen">#</a> <code>frozen</code></h3>
<p>Declare an immutable lexical variable. <code>const my</code> and <code>frozen my</code> are interchangeable spellings; <code>const</code> reads more naturally for engineers coming from other languages.</p>
<pre><code class="lang-perl">const my $pi = 3.14159
# $pi = 3 # ERROR: cannot assign to frozen variable
frozen my @primes = (2, 3, 5, 7, 11)
</code></pre>
</article>
<article class="doc-entry" id="doc-fore">
<h3><a class="doc-anchor" href="#doc-fore">#</a> <code>fore</code></h3>
<p>Side-effect-only list iterator (like <code>map</code> but void, returns item count).</p>
<pre><code class="lang-perl">qw(a b c) |> e p # prints a, b, c; returns 3
1:5 |> map _ * 2 |> e p # prints 2,4,6,8,10
</code></pre>
</article>
<article class="doc-entry" id="doc-ep">
<h3><a class="doc-anchor" href="#doc-ep">#</a> <code>ep</code></h3>
<p><code>ep</code> — shorthand for <code>e { p }</code> (foreach + print). Iterates the list and prints each element.</p>
<pre><code class="lang-perl">qw(a b c) |> ep # prints a, b, c (one per line)
filef |> sorted |> ep # print sorted file list
1:5 |> map _ * 2 |> ep # prints 2,4,6,8,10
</code></pre>
</article>
<article class="doc-entry" id="doc-p">
<h3><a class="doc-anchor" href="#doc-p">#</a> <code>p</code></h3>
<p><code>p</code> — alias for <code>say</code> (print with newline).</p>
<pre><code class="lang-perl">p "hello" # hello\n
p 42 # 42\n
1:5 |> e p # prints each on its own line
</code></pre>
</article>
<article class="doc-entry" id="doc-gen">
<h3><a class="doc-anchor" href="#doc-gen">#</a> <code>gen</code></h3>
<p>Create a generator — lazy <code>yield</code> values on demand.</p>
<pre><code class="lang-perl">my $g = gen { yield _ for 1:5 }
my ($val, $more) = @{$g->next}
</code></pre>
</article>
<article class="doc-entry" id="doc-yield">
<h3><a class="doc-anchor" href="#doc-yield">#</a> <code>yield</code></h3>
<p>Yield a value from inside a <code>gen { }</code> generator block, suspending the generator until the consumer calls <code>->next</code> again. Each <code>yield</code> produces one element in the lazy sequence. When the block finishes without yielding, the generator signals exhaustion. This is the stryke equivalent of Python's <code>yield</code> or Rust's <code>Iterator::next</code>.</p>
<pre><code class="lang-perl">my $fib = gen {
my ($a, $b) = (0, 1)
while (1) {
yield $a
($a, $b) = ($b, $a + $b)
}
}
for (1:10) {
my ($val) = @{$fib->next}
p $val
}
</code></pre>
</article>
<article class="doc-entry" id="doc-trace">
<h3><a class="doc-anchor" href="#doc-trace">#</a> <code>trace</code></h3>
<p>Trace <code>mysync</code> mutations to stderr (tagged with worker index under <code>fan</code>).</p>
<pre><code class="lang-perl">trace { fan 10 { $counter++ } }
</code></pre>
</article>
<article class="doc-entry" id="doc-timer">
<h3><a class="doc-anchor" href="#doc-timer">#</a> <code>timer</code></h3>
<p>Measure wall-clock milliseconds for a block.</p>
<pre><code class="lang-perl">my $ms = timer { heavy_work() }
</code></pre>
</article>
<article class="doc-entry" id="doc-bench">
<h3><a class="doc-anchor" href="#doc-bench">#</a> <code>bench</code></h3>
<p>Benchmark a block N times; returns <code>"min/mean/p99"</code>.</p>
<pre><code class="lang-perl">my $report = bench { work() } 1000
</code></pre>
</article>
<article class="doc-entry" id="doc-eval-timeout">
<h3><a class="doc-anchor" href="#doc-eval-timeout">#</a> <code>eval_timeout</code></h3>
<p>Run a block with a wall-clock timeout (seconds).</p>
<pre><code class="lang-perl">eval_timeout 5 { slow_operation() }
</code></pre>
</article>
<article class="doc-entry" id="doc-retry">
<h3><a class="doc-anchor" href="#doc-retry">#</a> <code>retry</code></h3>
<p>Retry a block on failure.</p>
<pre><code class="lang-perl">retry { http_call() } times => 3, backoff => 'exponential'
</code></pre>
</article>
<article class="doc-entry" id="doc-rate-limit">
<h3><a class="doc-anchor" href="#doc-rate-limit">#</a> <code>rate_limit</code></h3>
<p>Limit invocations per time window.</p>
<pre><code class="lang-perl">rate_limit(10, "1s") { hit_api() }
</code></pre>
</article>
<article class="doc-entry" id="doc-every">
<h3><a class="doc-anchor" href="#doc-every">#</a> <code>every</code></h3>
<p>Run a block at a fixed interval.</p>
<pre><code class="lang-perl">every "500ms" { tick() }
</code></pre>
</article>
<article class="doc-entry" id="doc-watch">
<h3><a class="doc-anchor" href="#doc-watch">#</a> <code>watch</code></h3>
<p>Watch a single file for changes (non-parallel).</p>
<pre><code class="lang-perl">watch "/tmp/x", fn { process }
</code></pre>
</article>
<article class="doc-entry" id="doc-capture">
<h3><a class="doc-anchor" href="#doc-capture">#</a> <code>capture</code></h3>
<p>Run a command and capture structured output. Returns an object with <code>->stdout</code>, <code>->stderr</code>, <code>->exitcode</code>, and <code>->failed</code> methods. When piped to <code>lines</code> or <code>words</code>, stdout is auto-extracted so you can chain directly.</p>
<pre><code class="lang-perl">my $r = capture("ls -la")
p $r->stdout, $r->stderr, $r->exitcode
capture("ps aux") |> lines |> map { columns } |> tbl |> p
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-data-serialization">
<h2>Data & Serialization</h2>
<p class="chapter-meta">45 topics</p>
<article class="doc-entry" id="doc-json-encode">
<h3><a class="doc-anchor" href="#doc-json-encode">#</a> <code>json_encode</code></h3>
<p><code>json_encode</code> serializes any stryke data structure — hashrefs, arrayrefs, nested combinations, numbers, strings, booleans, and undef — into a compact JSON string. Native bare-name builtin backed by a Rust serializer; no module to import. The output is always valid UTF-8 JSON suitable for writing to files, sending over HTTP, or piping to other tools. Use <code>json_decode</code> to round-trip back.</p>
<pre><code class="lang-perl">my %cfg = (debug => 1, paths => ["/tmp", "/var"])
my $j = json_encode(\%cfg)
p $j # {"debug":1,"paths":["/tmp","/var"]}
$j |> spurt "/tmp/cfg.json"$1
Note: undef becomes JSON `null`; booleans serialize as `true`/`false`.
</code></pre>
</article>
<article class="doc-entry" id="doc-json-decode">
<h3><a class="doc-anchor" href="#doc-json-decode">#</a> <code>json_decode</code></h3>
<p><code>json_decode</code> parses a JSON string and returns the corresponding Perl data structure — hashrefs for objects, arrayrefs for arrays, and native scalars for strings/numbers/booleans. It is strict by default: malformed JSON raises an exception rather than returning partial data. This makes it safe to use in pipelines where corrupt input should halt processing. The Rust parser underneath handles large documents efficiently and supports full Unicode.</p>
<pre><code class="lang-perl">my $data = json_decode('{"name":"stryke","ver":1}')
p $data->{name} # stryke
slurp("data.json") |> json_decode |> dd$1
Note: JSON `null` becomes Perl `undef`; trailing commas and comments are not allowed.
</code></pre>
</article>
<article class="doc-entry" id="doc-json-jq">
<h3><a class="doc-anchor" href="#doc-json-jq">#</a> <code>json_jq</code></h3>
<p><code>json_jq</code> applies a jq-style query expression to a stryke data structure and returns the matched value. This brings the power of the <code>jq</code> command-line JSON processor directly into stryke without shelling out. Dot notation traverses hash keys, bracket notation indexes arrays, and nested paths are separated by dots. It is ideal for extracting deeply nested values from API responses or config files without chains of hash dereferences.</p>
<pre><code class="lang-perl">my $data = json_decode(slurp "api.json")
p json_jq($data, ".results[0].name")
my $cfg = rj "config.json"
p json_jq($cfg, ".database.host") # deep extract
fetch_json("https://api.example.com/users") |> json_jq(".data[0].email") |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-to-json">
<h3><a class="doc-anchor" href="#doc-to-json">#</a> <code>to_json</code></h3>
<p><code>to_json</code> (alias <code>tj</code>) converts a stryke data structure into a JSON string, functioning as a convenient shorthand for <code>json_encode</code>. It accepts hashrefs, arrayrefs, scalars, and nested combinations, producing compact JSON output suitable for APIs, config files, or inter-process communication. The alias <code>tj</code> is particularly useful at the end of a pipeline to serialize the final result. The Rust-backed serializer handles large structures efficiently and always produces valid UTF-8.</p>
<pre><code class="lang-perl">my %user = (name => "Bob", age => 30)
p tj \%user # {"age":30,"name":"Bob"}
my @items = map { {id => _, val => _ * 2} } 1:3
p tj \@items # [{"id":1,"val":2},{"id":2,"val":4},{"id":3,"val":6}]
@data |> tj |> spurt "out.json"
</code></pre>
</article>
<article class="doc-entry" id="doc-to-csv">
<h3><a class="doc-anchor" href="#doc-to-csv">#</a> <code>to_csv</code></h3>
<p><code>to_csv</code> (alias <code>tc</code>) serializes a list of hashrefs or arrayrefs into a CSV-formatted string, complete with a header row derived from hash keys when given hashrefs. This is the fastest way to produce spreadsheet-ready output from structured data. Fields containing commas, quotes, or newlines are automatically escaped according to RFC 4180. The alias <code>tc</code> keeps one-liners terse when piping query results or API responses straight to CSV.</p>
<pre><code class="lang-perl">my @rows = ({name => "Alice", age => 30}, {name => "Bob", age => 25})
p tc \@rows # name,age\nAlice,30\nBob,25
tc(\@rows) |> spurt "people.csv"
my @grid = ([1, 2, 3], [4, 5, 6])
p tc \@grid # 1,2,3\n4,5,6
</code></pre>
</article>
<article class="doc-entry" id="doc-to-toml">
<h3><a class="doc-anchor" href="#doc-to-toml">#</a> <code>to_toml</code></h3>
<p><code>to_toml</code> (alias <code>tt</code>) serializes a stryke hashref into a TOML-formatted string. TOML is a popular configuration format that maps cleanly to hash structures, making <code>tt</code> ideal for generating config files programmatically. Nested hashes become TOML sections, arrays become TOML arrays, and scalar values are serialized with their natural types. The output is always valid TOML that can be parsed back with <code>toml_decode</code>.</p>
<pre><code class="lang-perl">my %cfg = (database => {host => "localhost", port => 5432}, debug => 1)
p tt \%cfg
# [database]
# host = "localhost"
# port = 5432
# debug = 1
tt(\%cfg) |> spurt "config.toml"
</code></pre>
</article>
<article class="doc-entry" id="doc-to-yaml">
<h3><a class="doc-anchor" href="#doc-to-yaml">#</a> <code>to_yaml</code></h3>
<p><code>to_yaml</code> (alias <code>ty</code>) serializes a stryke data structure into a YAML-formatted string. YAML is widely used for configuration and data exchange where human readability matters. Nested structures are represented with indentation, arrays with leading dashes, and strings are quoted only when necessary. The output is valid YAML 1.2 that round-trips cleanly through <code>yaml_decode</code>. The alias <code>ty</code> is convenient for quick inspection of complex data.</p>
<pre><code class="lang-perl">my %app = (name => "myapp", deps => ["tokio", "serde"], version => "1.0")
p ty \%app
# name: myapp
# version: "1.0"
# deps:
# - tokio
# - serde
ty(\%app) |> spurt "app.yaml"
</code></pre>
</article>
<article class="doc-entry" id="doc-to-xml">
<h3><a class="doc-anchor" href="#doc-to-xml">#</a> <code>to_xml</code></h3>
<p><code>to_xml</code> (alias <code>tx</code>) serializes a stryke data structure into an XML string. Hash keys become element names, array values become repeated child elements, and scalar values become text content. This is useful for generating XML payloads for SOAP APIs, RSS feeds, or configuration files that require XML format. The output is well-formed XML that can be parsed back with <code>xml_decode</code>.</p>
<pre><code class="lang-perl">my %doc = (root => {title => "Hello", items => ["a", "b", "c"]})
p tx \%doc
# <root><title>Hello</title><items>a</items><items>b</items><items>c</items></root>
tx(\%doc) |> spurt "doc.xml"
</code></pre>
</article>
<article class="doc-entry" id="doc-to-html">
<h3><a class="doc-anchor" href="#doc-to-html">#</a> <code>to_html</code></h3>
<p><code>to_html</code> (alias <code>th</code>) serializes a stryke data structure into a self-contained HTML document with cyberpunk styling (dark background, neon cyan/magenta accents, monospace fonts). Arrays of hashrefs render as full tables with headers, plain arrays as bullet lists, single hashes as key-value tables, and scalars as styled text blocks. Pipe to a file and open in a browser for instant data visualization.</p>
<pre><code class="lang-perl">fr |> map +{name => _, size => format_bytes(size)} |> th |> to_file("report.html")
my @rows = ({name => "Alice", age => 30}, {name => "Bob", age => 25})
@rows |> th |> to_file("people.html")
th({host => "localhost", port => 5432}) |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-to-markdown">
<h3><a class="doc-anchor" href="#doc-to-markdown">#</a> <code>to_markdown</code></h3>
<p><code>to_markdown</code> (aliases <code>to_md</code>, <code>tmd</code>) serializes a stryke data structure into Markdown text. Arrays of hashrefs render as GFM tables with headers and separator rows, plain arrays as bullet lists, single hashes as 2-column key-value tables, and scalars as plain text. The output is valid GitHub-Flavored Markdown suitable for README files, issue comments, or any Markdown renderer.</p>
<pre><code class="lang-perl">fr |> map +{name => _, size => format_bytes(size)} |> tmd |> to_file("report.md")
my @rows = ({name => "Alice", age => 30}, {name => "Bob", age => 25})
@rows |> tmd |> p
# | name | age |
# | --- | --- |
# | Alice | 30 |
# | Bob | 25 |
</code></pre>
</article>
<article class="doc-entry" id="doc-from-json">
<h3><a class="doc-anchor" href="#doc-from-json">#</a> <code>from_json</code></h3>
<p><code>from_json</code> (alias <code>fj</code>) parses a JSON string into a stryke data structure (hashref, arrayref, scalar). This is the inverse of <code>to_json</code> and the idiomatic way to decode JSON responses from APIs, config files, or inter-process communication. The Rust-backed parser handles large documents efficiently.</p>
<pre><code class="lang-perl">my $json = '{"name":"Alice","age":30}'
my $data = from_json($json)
p $data->{name} # Alice
my $arr = fj '[1, 2, {"x": 3}]'
p $arr->[2]{x} # 3
slurp("config.json") |> fj
</code></pre>
</article>
<article class="doc-entry" id="doc-from-yaml">
<h3><a class="doc-anchor" href="#doc-from-yaml">#</a> <code>from_yaml</code></h3>
<p><code>from_yaml</code> (alias <code>fy</code>) parses a YAML string into a stryke data structure. YAML is commonly used for configuration files due to its human-readable syntax. Handles scalars, arrays, hashes, and nested combinations. The parser supports common YAML features like multi-line strings and bare unquoted keys.</p>
<pre><code class="lang-perl">my $yaml = "name: Alice\nage: 30"
my $data = from_yaml($yaml)
p $data->{name} # Alice
slurp("config.yaml") |> fy |> say _->{database}{host}
</code></pre>
</article>
<article class="doc-entry" id="doc-from-toml">
<h3><a class="doc-anchor" href="#doc-from-toml">#</a> <code>from_toml</code></h3>
<p><code>from_toml</code> (alias <code>ftoml</code>) parses a TOML string into a stryke hashref. TOML is popular for Rust, Python, and other config files due to its explicit syntax. Sections become nested hashes, arrays stay arrays, and typed values (integers, floats, strings, booleans) are preserved.</p>
<pre><code class="lang-perl">my $toml = "[package]\nname = \"myapp\"\nversion = \"1.0\""
my $data = from_toml($toml)
p $data->{package}{name} # myapp
slurp("Cargo.toml") |> ftoml |> say _->{package}{version}
</code></pre>
</article>
<article class="doc-entry" id="doc-from-xml">
<h3><a class="doc-anchor" href="#doc-from-xml">#</a> <code>from_xml</code></h3>
<p><code>from_xml</code> (alias <code>fx</code>) parses an XML string into a stryke hashref. Element names become hash keys, text content becomes string values, nested elements become nested hashes. The parser handles the XML declaration and basic structures.</p>
<pre><code class="lang-perl">my $xml = '<root><name>Alice</name><age>30</age></root>'
my $data = from_xml($xml)
p $data->{root}{name} # Alice
slurp("config.xml") |> fx |> say _->{config}{database}{host}
</code></pre>
</article>
<article class="doc-entry" id="doc-from-csv">
<h3><a class="doc-anchor" href="#doc-from-csv">#</a> <code>from_csv</code></h3>
<p><code>from_csv</code> (alias <code>fcsv</code>) parses a CSV string into an arrayref of hashrefs, treating the first line as headers. This is the inverse of <code>to_csv</code> and handles quoted fields containing commas according to RFC 4180.</p>
<pre><code class="lang-perl">my $csv = "name,age\nAlice,30\nBob,25"
my $rows = from_csv($csv)
p $rows->[0]{name} # Alice
p $rows->[1]{age} # 25
slurp("data.csv") |> fcsv |> grep { _->{age} > 25 }
</code></pre>
</article>
<article class="doc-entry" id="doc-xopen">
<h3><a class="doc-anchor" href="#doc-xopen">#</a> <code>xopen</code></h3>
<p><code>xopen</code> (alias <code>xo</code>) opens a file or URL with the system default handler — <code>open</code> on macOS, <code>xdg-open</code> on Linux, <code>start</code> on Windows. Returns the path unchanged so it can sit transparently in a pipeline. This is the missing link between generating output files and viewing them: pipe the path through <code>xopen</code> and the OS opens it in the appropriate app (browser for HTML, viewer for PDF, editor for text).</p>
<pre><code class="lang-perl">fr |> map +{name => _, size => format_bytes(size)} |> th |> to_file("report.html") |> xopen
xopen "https://example.com"
xopen "output.pdf"
</code></pre>
</article>
<article class="doc-entry" id="doc-clip">
<h3><a class="doc-anchor" href="#doc-clip">#</a> <code>clip</code></h3>
<p><code>clip</code> (aliases <code>clipboard</code>, <code>pbcopy</code>) copies text to the system clipboard (<code>pbcopy</code> on macOS, <code>xclip</code>/<code>xsel</code> on Linux). Returns the text unchanged for pipeline chaining. This is the missing link between generating output and sharing it — pipe any serializer's output through <code>clip</code> and paste directly into Slack, GitHub, docs, or email.</p>
<pre><code class="lang-perl">fr |> map +{name => _, size => format_bytes(size)} |> tmd |> clip # markdown table → clipboard
qw(a b c) |> join "," |> clip |> p # also prints
"some text" |> clip # just copy
</code></pre>
</article>
<article class="doc-entry" id="doc-paste">
<h3><a class="doc-anchor" href="#doc-paste">#</a> <code>paste</code></h3>
<p><code>paste</code> (alias <code>pbpaste</code>) reads text from the system clipboard (<code>pbpaste</code> on macOS, <code>xclip</code>/<code>xsel</code> on Linux). Returns the clipboard contents as a string, ready for pipeline processing.</p>
<pre><code class="lang-perl">p paste # print clipboard contents
paste |> lines |> grep /error/i |> p # search clipboard for errors
paste |> wc |> p # word count of clipboard
</code></pre>
</article>
<article class="doc-entry" id="doc-to-table">
<h3><a class="doc-anchor" href="#doc-to-table">#</a> <code>to_table</code></h3>
<p><code>to_table</code> (aliases <code>table</code>, <code>tbl</code>) renders data as a plain-text column-aligned table with Unicode box-drawing borders. Arrays of hashrefs render as full tables with headers, plain arrays as numbered rows, single hashes as key-value tables sorted by numeric value descending (ties by key), matching <code>freq</code> → <code>tbl</code> expectations. The output is fixed-width text suitable for terminal display, log files, or any monospace context.</p>
<pre><code class="lang-perl">my @r = ({name => "Alice", age => 30}, {name => "Bob", age => 25})
@r |> tbl |> p
# ┌───────┬─────┐
# │ name │ age │
# ├───────┼─────┤
# │ Alice │ 30 │
# │ Bob │ 25 │
# └───────┴─────┘
fr |> map +{name => _, size => format_bytes(size)} |> tbl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sparkline">
<h3><a class="doc-anchor" href="#doc-sparkline">#</a> <code>sparkline</code></h3>
<p><code>sparkline</code> (alias <code>spark</code>) renders a list of numbers as a compact Unicode sparkline string using block characters (▁▂▃▄▅▆▇█). Each value maps to a bar height proportional to the min/max range. Ideal for inline data visualization in terminal output, dashboards, or log summaries.</p>
<pre><code class="lang-perl">(3,7,1,9,4,2,8,5) |> spark |> p # ▃▆▁█▄▂▇▅
@daily_sales |> spark |> p # quick trend line
fr |> map { size } |> spark |> p # file size distribution
</code></pre>
</article>
<article class="doc-entry" id="doc-bar-chart">
<h3><a class="doc-anchor" href="#doc-bar-chart">#</a> <code>bar_chart</code></h3>
<p><code>bar_chart</code> (alias <code>bars</code>) renders a hashref as a colored horizontal bar chart in the terminal. Each key becomes a label, each value a proportional bar. Colors cycle automatically. Pairs naturally with <code>freq</code> for instant word/event counting visualization.</p>
<pre><code class="lang-perl">qw(a b a c a b) |> freq |> bars |> p
# a │ ████████████████████████████████████████ 3
# b │ ███████████████████████████ 2
# c │ █████████████ 1
bars({cpu => 73, mem => 45, disk => 91}) |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flame">
<h3><a class="doc-anchor" href="#doc-flame">#</a> <code>flame</code></h3>
<p><code>flame</code> (alias <code>flamechart</code>) renders a hierarchical hashref as a terminal flamechart with colored stacked bars. Nested hashes become child rows; widths are proportional to leaf values (weights). Useful for visualizing call stacks, cost breakdowns, or any tree-structured data.</p>
<pre><code class="lang-perl">flame({main => {parse => 30, eval => {compile => 15, run => 45}}, init => 10}) |> p
my $profile = read_json "profile.json"
flame($profile) |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-histo">
<h3><a class="doc-anchor" href="#doc-histo">#</a> <code>histo</code></h3>
<p><code>histo</code> renders a vertical histogram in the terminal. Given a hashref (label → count), it draws colored vertical bars. Given a flat array of numbers, it auto-bins into 10 buckets and shows the distribution. Pairs with <code>freq</code> for categorical data.</p>
<pre><code class="lang-perl">qw(a b a c a b) |> freq |> histo |> p # vertical bars for a/b/c
(map { int(rand(100)) } 1:1000) |> histo |> p # distribution of randoms
</code></pre>
</article>
<article class="doc-entry" id="doc-gauge">
<h3><a class="doc-anchor" href="#doc-gauge">#</a> <code>gauge</code></h3>
<p><code>gauge</code> renders a single value as a horizontal gauge bar with color coding (green ≥80%, yellow ≥50%, magenta ≥25%, red below). Accepts a fraction (0.0–1.0) or a value with max: <code>gauge(45, 100)</code>.</p>
<pre><code class="lang-perl">p gauge(0.73) # [██████████████████████░░░░░░░░] 73%
p gauge(45, 100) # [█████████████░░░░░░░░░░░░░░░░] 45%
</code></pre>
</article>
<article class="doc-entry" id="doc-spinner">
<h3><a class="doc-anchor" href="#doc-spinner">#</a> <code>spinner</code></h3>
<p><code>spinner</code> shows an animated braille spinner on stderr while a block executes, then clears the spinner and returns the block's result. Useful for long-running one-liners where you want visual feedback without polluting stdout.</p>
<pre><code class="lang-perl">my $r = spinner "loading" { fetch_json("https://api.example.com/data") }
spinner { sleep 2
42 } # default message "working"
</code></pre>
</article>
<article class="doc-entry" id="doc-csv-read">
<h3><a class="doc-anchor" href="#doc-csv-read">#</a> <code>csv_read</code></h3>
<p><code>csv_read</code> (alias <code>cr</code>) reads CSV data from a file path or string and returns an array of arrayrefs, where each inner arrayref represents one row. The parser handles RFC 4180 CSV correctly — quoted fields with embedded commas, newlines inside quotes, and escaped double quotes are all supported. The first row is treated as data (not a header) unless you process it separately. This is the fastest way to ingest tabular data in stryke.</p>
<pre><code class="lang-perl">my @rows = csv_read "data.csv"
p $rows[0] # first row as arrayref
@rows |> e { p _->[0] } # print first column
my @inline = csv_read "a,b,c\n1,2,3\n4,5,6"
p scalar @inline # 3 rows (including header)
</code></pre>
</article>
<article class="doc-entry" id="doc-csv-write">
<h3><a class="doc-anchor" href="#doc-csv-write">#</a> <code>csv_write</code></h3>
<p><code>csv_write</code> (alias <code>cw</code>) serializes an array of arrayrefs into a CSV-formatted string. Each inner arrayref becomes one row, and fields are automatically quoted when they contain commas, quotes, or newlines. This is the complement of <code>csv_read</code> and produces output conforming to RFC 4180. Use it to generate CSV files from computed data, export database query results, or prepare data for spreadsheet import.</p>
<pre><code class="lang-perl">my @data = (["name", "age"], ["Alice", 30], ["Bob", 25])
csv_write(\@data) |> spurt "people.csv"
my @report = map { [_->{id}, _->{score}] } @results
p csv_write \@report
</code></pre>
</article>
<article class="doc-entry" id="doc-dataframe">
<h3><a class="doc-anchor" href="#doc-dataframe">#</a> <code>dataframe</code></h3>
<p><code>dataframe</code> (alias <code>df</code>) creates a columnar dataframe from tabular data, providing a structured way to work with rows and columns. You can construct a dataframe from an array of hashrefs, an array of arrayrefs with a header row, or from a CSV file. The dataframe supports column selection, filtering, sorting, and aggregation operations. This is stryke's answer to Python's pandas DataFrame — lightweight but sufficient for common data manipulation tasks.</p>
<pre><code class="lang-perl">my $df = df [{name => "Alice", age => 30}, {name => "Bob", age => 25}]
p $df
my $df2 = df csv_read "data.csv"
my @ages = $df->{age}
p @ages # 30, 25
</code></pre>
</article>
<article class="doc-entry" id="doc-sqlite">
<h3><a class="doc-anchor" href="#doc-sqlite">#</a> <code>sqlite</code></h3>
<p><code>sqlite</code> (alias <code>sql</code>) executes a SQL statement against an SQLite database file and returns the results. For SELECT queries, it returns an array of hashrefs where each hashref represents one row with column names as keys. For INSERT, UPDATE, and DELETE statements, it returns the number of affected rows. Bind parameters prevent SQL injection and handle quoting automatically. The database file is created if it does not exist, making <code>sqlite</code> a zero-setup embedded database.</p>
<pre><code class="lang-perl">sqlite("app.db", "CREATE TABLE users (name TEXT, age INT)")
sqlite("app.db", "INSERT INTO users VALUES (?, ?)", "Alice", 30)
my @rows = sqlite("app.db", "SELECT * FROM users WHERE age > ?", 20)
@rows |> e { p _->{name} }
sqlite("app.db", "SELECT count(*) as n FROM users") |> dd
</code></pre>
</article>
<article class="doc-entry" id="doc-digits">
<h3><a class="doc-anchor" href="#doc-digits">#</a> <code>digits</code></h3>
<p><code>digits</code> (alias <code>dg</code>) extracts all digit characters from a string and returns them as a list. This is a quick way to pull numbers out of mixed text without writing a regex. Pairs naturally with <code>join</code> to reconstruct the numeric string, or <code>freq</code> for digit distribution analysis.</p>
<pre><code class="lang-perl">p join "", digits("phone: 555-1234") # 5551234
"abc123def456" |> digits |> cnt |> p # 6
cat("log.txt") |> digits |> freq |> bars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-letters">
<h3><a class="doc-anchor" href="#doc-letters">#</a> <code>letters</code></h3>
<p><code>letters</code> (alias <code>lts</code>) extracts all alphabetic characters from a string and returns them as a list. Filters out digits, punctuation, whitespace — keeps only letters.</p>
<pre><code class="lang-perl">p join "", letters("h3ll0 w0rld!") # hllwrld
"abc123DEF" |> letters |> cnt |> p # 6
</code></pre>
</article>
<article class="doc-entry" id="doc-sentences">
<h3><a class="doc-anchor" href="#doc-sentences">#</a> <code>sentences</code></h3>
<p><code>sentences</code> (alias <code>sents</code>) splits text on sentence boundaries (<code>.</code> <code>!</code> <code>?</code> followed by whitespace or end of string). Returns a list of trimmed sentences. Useful for NLP pipelines, text analysis, or splitting prose into processable units.</p>
<pre><code class="lang-perl">"Hello world. How are you? Fine!" |> sentences |> e p
# Hello world.
# How are you?
# Fine!
cat("essay.txt") |> sentences |> cnt |> p # sentence count
</code></pre>
</article>
<article class="doc-entry" id="doc-paragraphs">
<h3><a class="doc-anchor" href="#doc-paragraphs">#</a> <code>paragraphs</code></h3>
<p><code>paragraphs</code> (alias <code>paras</code>) splits text on blank lines (one or more consecutive newlines). Returns a list of trimmed paragraph strings. Useful for processing structured documents, README files, or any text with paragraph breaks.</p>
<pre><code class="lang-perl">cat("README.md") |> paragraphs |> cnt |> p # paragraph count
cat("essay.txt") |> paragraphs |> map { sentences |> cnt } |> spark |> p # sentences per paragraph
</code></pre>
</article>
<article class="doc-entry" id="doc-sections">
<h3><a class="doc-anchor" href="#doc-sections">#</a> <code>sections</code></h3>
<p><code>sections</code> (alias <code>sects</code>) splits text on markdown-style headers (<code># ...</code>, <code>## ...</code>) or lines of <code>===</code>/<code>---</code>. Returns a list of arrayrefs <code>[heading, body]</code> where each section's heading and body are separated. Useful for parsing structured documents.</p>
<pre><code class="lang-perl">cat("README.md") |> sections |> cnt |> p # section count
cat("README.md") |> sections |> map { _->[0] } |> e p # list all headings
</code></pre>
</article>
<article class="doc-entry" id="doc-numbers">
<h3><a class="doc-anchor" href="#doc-numbers">#</a> <code>numbers</code></h3>
<p><code>numbers</code> (alias <code>nums</code>) extracts all numbers (integers and floats, including negatives) from a string and returns them as numeric values. Unlike <code>digits</code> which returns individual digit characters, <code>numbers</code> returns actual parsed values. Useful for pulling measurements, scores, or IDs out of mixed text.</p>
<pre><code class="lang-perl">p join ",", numbers("temp 98.6F, -20C, ver 3") # 98.6,-20,3
cat("log.txt") |> numbers |> avg |> p # average of all numbers in file
"price: $12.99 qty: 5" |> numbers |> e p # 12.99, 5
</code></pre>
</article>
<article class="doc-entry" id="doc-graphemes">
<h3><a class="doc-anchor" href="#doc-graphemes">#</a> <code>graphemes</code></h3>
<p><code>graphemes</code> (alias <code>grs</code>) splits a string into Unicode grapheme clusters. Unlike <code>chars</code> which splits on code points, <code>graphemes</code> keeps combining marks and emoji sequences together as single visual units. <code>"cafe\u{0301}"</code> gives 4 graphemes (not 5 code points). Essential for correct text processing of accented characters, emoji, and non-Latin scripts.</p>
<pre><code class="lang-perl">p cnt graphemes("cafe\u{0301}") # 4 (not 5)
graphemes("hello") |> e p # h, e, l, l, o
</code></pre>
</article>
<article class="doc-entry" id="doc-columns">
<h3><a class="doc-anchor" href="#doc-columns">#</a> <code>columns</code></h3>
<p><code>columns</code> (alias <code>cols</code>) splits fixed-width columnar text into fields. Without a widths argument, it auto-detects columns by splitting on runs of 2+ whitespace (ideal for <code>ps aux</code>, <code>ls -l</code>, <code>df</code> output). With an arrayref of widths, it splits at exact fixed positions. Pairs with <code>lines</code> for processing tabular command output.</p>
<pre><code class="lang-perl">my @fields = columns("USER PID %CPU") # auto-detect: [USER, PID, %CPU]
my @fixed = columns("John Doe 30", [7, 7, 3]) # fixed-width: [John, Doe, 30]
capture("ps aux") |> lines |> map { columns } |> tbl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stringify">
<h3><a class="doc-anchor" href="#doc-stringify">#</a> <code>stringify</code></h3>
<p><code>stringify</code> (alias <code>str</code>) converts any stryke value — scalars, array refs, hash refs, nested structures, undef — into a string representation that is a valid stryke literal. The output is designed for round-tripping: you can <code>eval</code> the returned string to reconstruct the original data structure. This makes it ideal for serializing state to a file in a Perl-native format, generating code fragments, or building reproducible test fixtures. Unlike <code>dd</code>, which targets human readability, <code>str</code> prioritizes parseability.</p>
<pre><code class="lang-perl">my $s = str {a => 1, b => [2, 3]}
p $s # {a => 1, b => [2, 3]}
my $copy = eval $s # round-trip back to hashref
my @list = (1, "hello", undef)
p str \@list # [1, "hello", undef]
</code></pre>
<p>Note: references are serialized recursively; circular references will cause infinite recursion.</p>
</article>
<article class="doc-entry" id="doc-ddump">
<h3><a class="doc-anchor" href="#doc-ddump">#</a> <code>ddump</code></h3>
<p><code>ddump</code> (alias <code>dd</code>) pretty-prints any stryke data structure to stderr in a human-readable, indented format. Native bare-name builtin — no module to import. It is the go-to tool for quick debugging — drop a <code>dd</code> call anywhere in a pipeline to inspect intermediate values without disrupting the data flow. The output is colorized when stderr is a terminal. Unlike <code>str</code>, the output is not meant for <code>eval</code> round-tripping; it prioritizes clarity over parseability. <code>dd</code> returns its argument unchanged, so it can be inserted into pipelines transparently.</p>
<pre><code class="lang-perl">my %h = (name => "Alice", scores => [98, 87, 95])
dd \%h # pretty-prints to stderr
my @result = @data |> dd |> grep { _->{active} } |> dd
dd [1, {a => 2}, [3, 4]] # nested structure
</code></pre>
<p>Note: <code>dd</code> writes to stderr, not stdout, so it never contaminates pipeline output.</p>
</article>
<article class="doc-entry" id="doc-toml-decode">
<h3><a class="doc-anchor" href="#doc-toml-decode">#</a> <code>toml_decode</code></h3>
<p><code>toml_decode</code> (alias <code>td</code>) parses a TOML-formatted string and returns the corresponding stryke hash structure. TOML sections become nested hashrefs, arrays map to arrayrefs, and typed scalars (integers, floats, booleans, datetime strings) are preserved. This is useful for reading configuration files, parsing Cargo.toml manifests, or processing any TOML input. Malformed TOML raises an exception.</p>
<pre><code class="lang-perl">my $cfg = toml_decode(slurp "config.toml")
p $cfg->{database}{host} # localhost
my $cargo = toml_decode(slurp "Cargo.toml")
p $cargo->{package}{version}
slurp("settings.toml") |> toml_decode |> dd
</code></pre>
</article>
<article class="doc-entry" id="doc-toml-encode">
<h3><a class="doc-anchor" href="#doc-toml-encode">#</a> <code>toml_encode</code></h3>
<p><code>toml_encode</code> (alias <code>te</code>) serializes a stryke hashref into a valid TOML string. Nested hashes become TOML sections with <code>[section]</code> headers, arrays become TOML arrays, and scalars are serialized with appropriate quoting. This is the inverse of <code>toml_decode</code> and is useful for generating or updating configuration files programmatically. The output is human-readable and can be written directly to a <code>.toml</code> file.</p>
<pre><code class="lang-perl">my %cfg = (server => {host => "0.0.0.0", port => 8080}, debug => 0)
toml_encode(\%cfg) |> spurt "server.toml"
my $round = toml_decode(toml_encode(\%cfg))
p $round->{server}{port} # 8080
</code></pre>
</article>
<article class="doc-entry" id="doc-yaml-decode">
<h3><a class="doc-anchor" href="#doc-yaml-decode">#</a> <code>yaml_decode</code></h3>
<p><code>yaml_decode</code> (alias <code>yd</code>) parses a YAML string and returns the corresponding stryke data structure. Mappings become hashrefs, sequences become arrayrefs, and scalars are coerced to their natural Perl types. This handles YAML 1.2 including multi-document streams, anchors/aliases, and flow notation. It is the go-to function for reading YAML configuration files, Kubernetes manifests, or CI pipeline definitions. Invalid YAML raises an exception.</p>
<pre><code class="lang-perl">my $cfg = yaml_decode(slurp "docker-compose.yml")
p $cfg->{services}{web}{image}
my $ci = yaml_decode(slurp ".github/workflows/ci.yml")
dd $ci->{jobs}
slurp("values.yaml") |> yaml_decode |> json_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yaml-encode">
<h3><a class="doc-anchor" href="#doc-yaml-encode">#</a> <code>yaml_encode</code></h3>
<p><code>yaml_encode</code> (alias <code>ye</code>) serializes a stryke data structure into a valid YAML string. Hashes become YAML mappings, arrays become sequences with dash prefixes, and scalars are quoted only when necessary for disambiguation. The output is human-readable and suitable for writing config files, generating Kubernetes resources, or producing YAML-based API payloads. It is the inverse of <code>yaml_decode</code>.</p>
<pre><code class="lang-perl">my %svc = (name => "api", replicas => 3, ports => [80, 443])
yaml_encode(\%svc) |> spurt "service.yaml"
my $round = yaml_decode(yaml_encode(\%svc))
p $round->{replicas} # 3
rj("config.json") |> yaml_encode |> p # JSON to YAML
</code></pre>
</article>
<article class="doc-entry" id="doc-xml-decode">
<h3><a class="doc-anchor" href="#doc-xml-decode">#</a> <code>xml_decode</code></h3>
<p><code>xml_decode</code> (alias <code>xd</code>) parses an XML string and returns a stryke data structure. Elements become hash keys, text content becomes scalar values, repeated child elements become arrayrefs, and attributes are accessible through a conventions-based mapping. This is useful for consuming SOAP responses, RSS feeds, SVG files, or any XML-based API. Malformed XML raises an exception rather than returning partial data.</p>
<pre><code class="lang-perl">my $doc = xml_decode('<root><name>stryke</name><ver>1</ver></root>')
p $doc->{root}{name} # stryke
slurp("feed.xml") |> xml_decode |> dd
my $svg = xml_decode(fetch("https://example.com/image.svg"))
p $svg->{svg}
</code></pre>
</article>
<article class="doc-entry" id="doc-xml-encode">
<h3><a class="doc-anchor" href="#doc-xml-encode">#</a> <code>xml_encode</code></h3>
<p><code>xml_encode</code> (alias <code>xe</code>) serializes a stryke data structure into a well-formed XML string. Hash keys become element names, scalar values become text content, and arrayrefs become repeated sibling elements. This is useful for generating XML payloads for SOAP APIs, creating RSS or Atom feeds, or producing configuration files in XML format. The output is the inverse of <code>xml_decode</code> and round-trips cleanly.</p>
<pre><code class="lang-perl">my %data = (root => {title => "Test", items => [{id => 1}, {id => 2}]})
p xml_encode \%data
xml_encode(\%data) |> spurt "output.xml"
my $payload = xml_encode {request => {action => "query", id => 42}}
http_request(method => "POST", url => $endpoint, body => $payload)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-http-networking">
<h2>HTTP & Networking</h2>
<p class="chapter-meta">23 topics</p>
<article class="doc-entry" id="doc-fetch">
<h3><a class="doc-anchor" href="#doc-fetch">#</a> <code>fetch</code></h3>
<p><code>fetch</code> (alias <code>ft</code>) performs a blocking HTTP GET request to the given URL and returns the response body as a string. It follows redirects automatically and raises an exception on network errors or non-2xx status codes. This is the simplest way to retrieve content from the web in stryke — no need to configure a client or parse response objects. For JSON APIs, prefer <code>fetch_json</code> which additionally decodes the response.</p>
<pre><code class="lang-perl">my $html = fetch "https://example.com"
p $html
my $ip = fetch "https://api.ipify.org"
p "My IP: $ip"
fetch("https://example.com/data.txt") |> spurt "local.txt"$1
Note: for POST, PUT, DELETE, or custom headers, use `http_request` instead.
</code></pre>
</article>
<article class="doc-entry" id="doc-fetch-json">
<h3><a class="doc-anchor" href="#doc-fetch-json">#</a> <code>fetch_json</code></h3>
<p><code>fetch_json</code> (alias <code>ftj</code>) performs a blocking HTTP GET request and automatically decodes the JSON response body into a stryke data structure. This combines <code>fetch</code> and <code>json_decode</code> into a single call, which is the common case when consuming REST APIs. It raises an exception if the response is not valid JSON or the request fails. The returned value is typically a hashref or arrayref ready for immediate use.</p>
<pre><code class="lang-perl">my $data = fetch_json "https://api.github.com/repos/stryke/stryke"
p $data->{stargazers_count}
fetch_json("https://jsonplaceholder.typicode.com/todos") |> e { p _->{title} }
my $weather = fetch_json "https://wttr.in/?format=j1"
p $weather->{current_condition}[0]{temp_C}
</code></pre>
</article>
<article class="doc-entry" id="doc-fetch-async">
<h3><a class="doc-anchor" href="#doc-fetch-async">#</a> <code>fetch_async</code></h3>
<p><code>fetch_async</code> (alias <code>fta</code>) initiates a non-blocking HTTP GET request and returns a task handle that can be awaited later. This allows you to fire off multiple HTTP requests concurrently and wait for them all to complete, dramatically reducing total latency when fetching from several endpoints. The task resolves to the response body as a string, just like <code>fetch</code>. Use this when you need to parallelize network I/O without threads.</p>
<pre><code class="lang-perl">my $t1 = fetch_async "https://api.example.com/users"
my $t2 = fetch_async "https://api.example.com/posts"
my $users = await $t1
my $posts = await $t2
p "Got users and posts concurrently"
</code></pre>
</article>
<article class="doc-entry" id="doc-fetch-async-json">
<h3><a class="doc-anchor" href="#doc-fetch-async-json">#</a> <code>fetch_async_json</code></h3>
<p><code>fetch_async_json</code> (alias <code>ftaj</code>) initiates a non-blocking HTTP GET request that automatically decodes the JSON response when awaited. This combines <code>fetch_async</code> with <code>json_decode</code>, making it the ideal choice for concurrent API calls where every response is JSON. The task resolves to the decoded stryke data structure — a hashref, arrayref, or scalar depending on the JSON content.</p>
<pre><code class="lang-perl">my @urls = map { "https://api.example.com/item/$_" } 1:10
my @tasks = map fetch_async_json @urls
my @results = map await @tasks
@results |> e { p _->{name} }
</code></pre>
</article>
<article class="doc-entry" id="doc-http-request">
<h3><a class="doc-anchor" href="#doc-http-request">#</a> <code>http_request</code></h3>
<p><code>http_request</code> (alias <code>hr</code>) performs a fully configurable HTTP request with control over method, headers, body, and timeout. Unlike <code>fetch</code> which is limited to GET, <code>http_request</code> supports POST, PUT, PATCH, DELETE, and any other HTTP method. Pass named parameters for configuration. The response is returned as a hashref containing <code>status</code>, <code>headers</code>, and <code>body</code> fields, giving you full access to the HTTP response. This is the right tool when you need to send data, set authentication headers, or inspect status codes.</p>
<pre><code class="lang-perl">my $res = http_request(method => "POST", url => "https://api.example.com/users",
headers => {"Content-Type" => "application/json", Authorization => "Bearer $token"},
body => tj {name => "Alice"})
p $res->{status} # 201
my $data = json_decode $res->{body}
my $del = http_request(method => "DELETE", url => "https://api.example.com/users/42")
</code></pre>
</article>
<article class="doc-entry" id="doc-par-fetch">
<h3><a class="doc-anchor" href="#doc-par-fetch">#</a> <code>par_fetch</code></h3>
<p><code>par_fetch @urls</code> — fetch a list of URLs in parallel using async HTTP, returning an array of response bodies in input order.</p>
<p>Under the hood, stryke spawns concurrent HTTP GET requests across a connection pool with keep-alive and automatic retry on transient failures (5xx, timeouts). The degree of parallelism is bounded by the connection pool size (default 64) to avoid overwhelming the target server. For heterogeneous HTTP methods or custom headers, use <code>http_request</code> inside <code>pmap</code> instead. <code>par_fetch</code> is the right tool when you have a homogeneous list of URLs and just need the bodies — it handles connection reuse, DNS caching, and TLS session resumption automatically for maximum throughput.</p>
<pre><code class="lang-perl">my @bodies = par_fetch @urls
# Fetch and decode JSON in one shot:
my @data = par_fetch(@api_urls) |> map json_decode
# Download pages with progress:
my @pages = par_fetch @urls, progress => 1
</code></pre>
</article>
<article class="doc-entry" id="doc-serve">
<h3><a class="doc-anchor" href="#doc-serve">#</a> <code>serve</code></h3>
<p>Start a blocking HTTP server.</p>
<pre><code class="lang-perl">serve 8080, fn ($req) {
# $req = { method, path, query, headers, body, peer }
{ status => 200, body => "hello" }
}
serve 3000, fn ($req) {
my $data = { name => "stryke", version => "0.4" }
{ status => 200, body => json_encode($data) }
}, { workers => 8 }$1
Handler returns: hashref `{ status, body, headers }`, string (200 OK), or undef (404).
JSON content-type auto-detected when body starts with `{` or `[`.
</code></pre>
</article>
<article class="doc-entry" id="doc-socket">
<h3><a class="doc-anchor" href="#doc-socket">#</a> <code>socket</code></h3>
<p>Create a network socket with the specified domain, type, and protocol. The socket handle is stored in the first argument and can then be used with <code>bind</code>, <code>connect</code>, <code>send</code>, <code>recv</code>, and other socket operations. Domain constants include <code>AF_INET</code> (IPv4) and <code>AF_INET6</code> (IPv6); type constants include <code>SOCK_STREAM</code> (TCP) and <code>SOCK_DGRAM</code> (UDP).</p>
<pre><code class="lang-perl">socket(my $sock, AF_INET, SOCK_STREAM, 0)
my $addr = sockaddr_in(8080, inet_aton("127.0.0.1"))
connect($sock, $addr)
send($sock, "GET / HTTP/1.0\r\n\r\n", 0)
</code></pre>
</article>
<article class="doc-entry" id="doc-bind">
<h3><a class="doc-anchor" href="#doc-bind">#</a> <code>bind</code></h3>
<p>Bind a socket to a local address so it can accept connections or receive datagrams on that address. The address is a packed <code>sockaddr_in</code> or <code>sockaddr_in6</code> structure. Binding is required before calling <code>listen</code> on a server socket. Dies if the address is already in use unless <code>SO_REUSEADDR</code> is set.</p>
<pre><code class="lang-perl">socket(my $srv, AF_INET, SOCK_STREAM, 0)
setsockopt($srv, SOL_SOCKET, SO_REUSEADDR, 1)
bind($srv, sockaddr_in(8080, INADDR_ANY)) or die "bind: $!"
listen($srv, 5)
</code></pre>
</article>
<article class="doc-entry" id="doc-listen">
<h3><a class="doc-anchor" href="#doc-listen">#</a> <code>listen</code></h3>
<p>Mark a bound socket as passive, ready to accept incoming connections. The backlog argument specifies the maximum number of pending connections the OS will queue before refusing new ones. This is only meaningful for stream (TCP) sockets. Call <code>accept</code> in a loop after <code>listen</code> to handle clients.</p>
<pre><code class="lang-perl">socket(my $srv, AF_INET, SOCK_STREAM, 0)
bind($srv, sockaddr_in(9000, INADDR_ANY))
listen($srv, 128) or die "listen: $!"
while (accept(my $client, $srv)) {
send($client, "hello\n", 0)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-accept">
<h3><a class="doc-anchor" href="#doc-accept">#</a> <code>accept</code></h3>
<p>Accept a pending connection on a listening socket and return a new connected socket handle. The new handle is used for communication with that specific client while the original listening socket continues accepting others. Returns the packed remote address on success, false on failure.</p>
<pre><code class="lang-perl">listen($srv, 5)
while (my $remote = accept(my $client, $srv)) {
my ($port, $ip) = sockaddr_in($remote)
p "connection from " . inet_ntoa($ip) . ":$port"
send($client, "welcome\n", 0)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-connect">
<h3><a class="doc-anchor" href="#doc-connect">#</a> <code>connect</code></h3>
<p>Initiate a connection from a socket to a remote address. For TCP sockets this performs the three-way handshake; for UDP it sets the default destination so subsequent <code>send</code> calls do not need an address. Dies or returns false if the connection is refused or times out.</p>
<pre><code class="lang-perl">socket(my $sock, AF_INET, SOCK_STREAM, 0)
my $addr = sockaddr_in(80, inet_aton("example.com"))
connect($sock, $addr) or die "connect: $!"
send($sock, "GET / HTTP/1.0\r\n\r\n", 0)
recv($sock, my $buf, 4096, 0)
p $buf
</code></pre>
</article>
<article class="doc-entry" id="doc-send">
<h3><a class="doc-anchor" href="#doc-send">#</a> <code>send</code></h3>
<p>Send data through a connected socket. The flags argument controls behavior — use <code>0</code> for normal sends. For UDP sockets you can supply a destination address as a fourth argument to send to a specific peer without calling <code>connect</code> first. Returns the number of bytes sent, or <code>undef</code> on error.</p>
<pre><code class="lang-perl">send($sock, "hello world\n", 0)
my $n = send($sock, $payload, 0)
p "sent $n bytes"
# UDP to specific peer
send($udp, $msg, 0, sockaddr_in(5000, inet_aton("10.0.0.1")))
</code></pre>
</article>
<article class="doc-entry" id="doc-recv">
<h3><a class="doc-anchor" href="#doc-recv">#</a> <code>recv</code></h3>
<p>Receive data from a socket into a buffer. The length argument specifies the maximum number of bytes to read. For stream sockets a short read is normal — loop until you have all expected data. For datagram sockets each call returns exactly one datagram. Returns the sender address for UDP, or empty string for TCP.</p>
<pre><code class="lang-perl">recv($sock, my $buf, 4096, 0) or die "recv: $!"
p $buf
my $data = ""
while (recv($sock, my $chunk, 8192, 0) && length($chunk)) {
$data .= $chunk
}
</code></pre>
</article>
<article class="doc-entry" id="doc-shutdown">
<h3><a class="doc-anchor" href="#doc-shutdown">#</a> <code>shutdown</code></h3>
<p>Shut down part or all of a socket connection without closing the file descriptor. The <code>how</code> argument controls direction: <code>0</code> stops reading, <code>1</code> stops writing (sends FIN to peer), <code>2</code> stops both. This is useful for signaling end-of-data to the remote side while still reading its response.</p>
<pre><code class="lang-perl">send($sock, $request, 0)
shutdown($sock, 1) # done writing
recv($sock, my $resp, 65536, 0) # still read response
shutdown($sock, 2) # fully close
</code></pre>
</article>
<article class="doc-entry" id="doc-setsockopt">
<h3><a class="doc-anchor" href="#doc-setsockopt">#</a> <code>setsockopt</code></h3>
<p>Set an option on a socket at the specified protocol level. Common uses include enabling <code>SO_REUSEADDR</code> to allow immediate rebinding after a server restart, setting <code>TCP_NODELAY</code> to disable Nagle's algorithm, or adjusting buffer sizes. The value is typically a packed integer.</p>
<pre><code class="lang-perl">setsockopt($srv, SOL_SOCKET, SO_REUSEADDR, 1)
setsockopt($sock, IPPROTO_TCP, TCP_NODELAY, 1)
setsockopt($sock, SOL_SOCKET, SO_RCVBUF, pack("I", 262144))
</code></pre>
</article>
<article class="doc-entry" id="doc-getsockopt">
<h3><a class="doc-anchor" href="#doc-getsockopt">#</a> <code>getsockopt</code></h3>
<p>Retrieve the current value of a socket option at the specified protocol level. Returns the option value as a packed binary string — use <code>unpack</code> to interpret it. Useful for inspecting buffer sizes, checking whether <code>SO_REUSEADDR</code> is set, or reading OS-assigned values.</p>
<pre><code class="lang-perl">my $val = getsockopt($sock, SOL_SOCKET, SO_RCVBUF)
p unpack("I", $val) # e.g. 131072
my $reuse = getsockopt($srv, SOL_SOCKET, SO_REUSEADDR)
p unpack("I", $reuse) # 1 or 0
</code></pre>
</article>
<article class="doc-entry" id="doc-getsockname">
<h3><a class="doc-anchor" href="#doc-getsockname">#</a> <code>getsockname</code></h3>
<p>Return the packed socket address of the local end of a socket. This is useful when the socket was bound to <code>INADDR_ANY</code> or port <code>0</code> (OS-assigned) and you need to discover the actual address and port the OS chose. Unpack the result with <code>sockaddr_in</code>.</p>
<pre><code class="lang-perl">bind($sock, sockaddr_in(0, INADDR_ANY)) # OS picks port
my $local = getsockname($sock)
my ($port, $ip) = sockaddr_in($local)
p "listening on port $port"
</code></pre>
</article>
<article class="doc-entry" id="doc-getpeername">
<h3><a class="doc-anchor" href="#doc-getpeername">#</a> <code>getpeername</code></h3>
<p>Return the packed socket address of the remote end of a connected socket. Use <code>sockaddr_in</code> or <code>sockaddr_in6</code> to unpack it into a port and IP address. This is how a server discovers which client it is talking to after <code>accept</code>, or how a client confirms the peer address after <code>connect</code>.</p>
<pre><code class="lang-perl">my $packed = getpeername($client)
my ($port, $ip) = sockaddr_in($packed)
p "peer: " . inet_ntoa($ip) . ":$port"
</code></pre>
</article>
<article class="doc-entry" id="doc-gethostbyname">
<h3><a class="doc-anchor" href="#doc-gethostbyname">#</a> <code>gethostbyname</code></h3>
<p>Resolve a hostname to its network addresses using the system resolver. Returns <code>($name, $aliases, $addrtype, $length, @addrs)</code>. The addresses are packed binary — pass them through <code>inet_ntoa</code> to get dotted-quad strings. This is the classic DNS forward-lookup function.</p>
<pre><code class="lang-perl">my @info = gethostbyname("example.com")
my @addrs = @info[4..$ #info]
@addrs |> map inet_ntoa |> e p
my $ip = inet_ntoa((gethostbyname("localhost"))[4])
p $ip # 127.0.0.1
</code></pre>
</article>
<article class="doc-entry" id="doc-gethostbyaddr">
<h3><a class="doc-anchor" href="#doc-gethostbyaddr">#</a> <code>gethostbyaddr</code></h3>
<p>Perform a reverse DNS lookup — given a packed binary IP address and address family, return the hostname associated with that address. Returns <code>($name, $aliases, $addrtype, $length, @addrs)</code> on success, or empty list if no PTR record exists.</p>
<pre><code class="lang-perl">my $packed = inet_aton("8.8.8.8")
my $name = (gethostbyaddr($packed, AF_INET))[0]
p $name # dns.google
</code></pre>
</article>
<article class="doc-entry" id="doc-getprotobyname">
<h3><a class="doc-anchor" href="#doc-getprotobyname">#</a> <code>getprotobyname</code></h3>
<p>Look up a network protocol by its name and return protocol information. Returns <code>($name, $aliases, $proto_number)</code>. The protocol number is what you pass to <code>socket</code> as the protocol argument. Common names include <code>tcp</code>, <code>udp</code>, and <code>icmp</code>.</p>
<pre><code class="lang-perl">my ($name, $aliases, $proto) = getprotobyname("tcp")
p "$name = protocol $proto" # tcp = protocol 6
socket(my $raw, AF_INET, SOCK_RAW, (getprotobyname("icmp"))[2])
</code></pre>
</article>
<article class="doc-entry" id="doc-getservbyname">
<h3><a class="doc-anchor" href="#doc-getservbyname">#</a> <code>getservbyname</code></h3>
<p>Look up a network service by its name and protocol, returning the port number and related information. Returns <code>($name, $aliases, $port, $proto)</code>. The port is in host byte order. This resolves well-known service names like <code>http</code>, <code>ssh</code>, or <code>smtp</code> to their port numbers portably.</p>
<pre><code class="lang-perl">my ($name, $aliases, $port) = getservbyname("http", "tcp")
p "$name => port $port" # http => port 80
my $ssh_port = (getservbyname("ssh", "tcp"))[2]
p $ssh_port # 22
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-crypto-encoding">
<h2>Crypto & Encoding</h2>
<p class="chapter-meta">133 topics</p>
<article class="doc-entry" id="doc-sha256">
<h3><a class="doc-anchor" href="#doc-sha256">#</a> <code>sha256</code></h3>
<p><code>sha256</code> (alias <code>s256</code>) computes the SHA-256 cryptographic hash of the input data and returns it as a 64-character lowercase hexadecimal string. SHA-256 is the most widely used hash function for data integrity verification, content addressing, and digital signatures. The Rust implementation is significantly faster than pure-Perl alternatives. Accepts strings or byte buffers.</p>
<pre><code class="lang-perl">p sha256 "hello world" # b94d27b9934d3e08...
my $checksum = sha256 slurp "release.tar.gz"
p $checksum
rl("passwords.txt") |> map sha256 |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-sha224">
<h3><a class="doc-anchor" href="#doc-sha224">#</a> <code>sha224</code></h3>
<p><code>sha224</code> (alias <code>s224</code>) computes the SHA-224 cryptographic hash and returns a 56-character hex string. SHA-224 is a truncated variant of SHA-256 that produces a shorter digest while maintaining strong collision resistance. It is sometimes preferred when storage or bandwidth for the hash value is constrained, such as in compact data structures or short identifiers.</p>
<pre><code class="lang-perl">p sha224 "hello world" # 2f05477fc24bb4fa...
my $h = sha224(tj {key => "value"})
p $h
</code></pre>
</article>
<article class="doc-entry" id="doc-sha384">
<h3><a class="doc-anchor" href="#doc-sha384">#</a> <code>sha384</code></h3>
<p><code>sha384</code> (alias <code>s384</code>) computes the SHA-384 cryptographic hash and returns a 96-character hex string. SHA-384 is a truncated variant of SHA-512 that offers a middle ground between SHA-256 and SHA-512 in both digest length and security margin. It is commonly used in TLS certificate fingerprints and government security standards that require larger-than-256-bit digests.</p>
<pre><code class="lang-perl">p sha384 "hello world" # fdbd8e75a67f29f7...
my $sig = sha384(slurp "document.pdf")
spurt "document.pdf.sha384", $sig
</code></pre>
</article>
<article class="doc-entry" id="doc-sha512">
<h3><a class="doc-anchor" href="#doc-sha512">#</a> <code>sha512</code></h3>
<p><code>sha512</code> (alias <code>s512</code>) computes the SHA-512 cryptographic hash and returns a 128-character hex string. SHA-512 provides the largest digest size in the SHA-2 family and is the strongest option when maximum collision resistance is needed. On 64-bit systems, SHA-512 is often faster than SHA-256 because it operates on 64-bit words natively. Use this for high-security applications or when you need a longer hash.</p>
<pre><code class="lang-perl">p sha512 "hello world" # 309ecc489c12d6eb...
my $hash = sha512(slurp "firmware.bin");
p $hash;
my @hashes = map { sha512 } @files
</code></pre>
</article>
<article class="doc-entry" id="doc-sha1">
<h3><a class="doc-anchor" href="#doc-sha1">#</a> <code>sha1</code></h3>
<p><code>sha1</code> (alias <code>s1</code>) computes the SHA-1 hash and returns a 40-character hex string. SHA-1 is considered cryptographically broken for collision resistance and should not be used for security-sensitive applications. However, it remains widely used for non-security purposes such as Git object IDs, cache keys, and deduplication checksums where collision attacks are not a concern.</p>
<pre><code class="lang-perl">p sha1 "hello world" # 2aae6c35c94fcfb4...
my $git_id = sha1("blob " . length($content) . "\0" . $content)
p $git_id$1
Note: prefer SHA-256 for any security-related use case.
</code></pre>
</article>
<article class="doc-entry" id="doc-crc32">
<h3><a class="doc-anchor" href="#doc-crc32">#</a> <code>crc32</code></h3>
<p><code>crc32</code> computes the CRC-32 checksum of the input data and returns it as an unsigned 32-bit integer. CRC-32 is not a cryptographic hash — it is a fast error-detection code used in network protocols (Ethernet, ZIP, PNG), file integrity checks, and hash table bucketing. It is extremely fast compared to SHA functions, making it suitable for high-throughput deduplication or quick change detection where collision resistance is not required.</p>
<pre><code class="lang-perl">p crc32 "hello world" # 222957957
my $chk = crc32(slurp "archive.zip");
p sprintf "0x%08x", $chk; # hex representation
my @checksums = map { crc32 } @chunks
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-sha256">
<h3><a class="doc-anchor" href="#doc-hmac-sha256">#</a> <code>hmac_sha256</code></h3>
<p><code>hmac_sha256</code> (alias <code>hmac</code>) computes an HMAC-SHA256 message authentication code using the given data and secret key, returning a hex string. HMAC combines a cryptographic hash with a secret key to produce a signature that verifies both data integrity and authenticity. This is the standard mechanism for signing API requests (AWS, Stripe, GitHub webhooks), generating secure tokens, and verifying message authenticity.</p>
<pre><code class="lang-perl">my $sig = hmac_sha256 "request body", "my-secret-key"
p $sig
my $webhook_sig = hmac("POST /hook\n$body", $secret)
p $webhook_sig eq $expected ? "valid" : "tampered"
</code></pre>
</article>
<article class="doc-entry" id="doc-blake2b">
<h3><a class="doc-anchor" href="#doc-blake2b">#</a> <code>blake2b</code></h3>
<p><code>blake2b</code> (alias <code>b2b</code>) computes the BLAKE2b-512 cryptographic hash and returns a 128-character hex string. BLAKE2b is faster than SHA-256 while being at least as secure. It is used in Argon2 password hashing, libsodium, WireGuard, and many modern cryptographic protocols. Prefer BLAKE2b or BLAKE3 for new projects over SHA-256.</p>
<pre><code class="lang-perl">p blake2b "hello world" # 021ced8799...
my $hash = b2b(slurp "large-file.bin");
my @hashes = map { blake2b } @messages
</code></pre>
</article>
<article class="doc-entry" id="doc-blake2s">
<h3><a class="doc-anchor" href="#doc-blake2s">#</a> <code>blake2s</code></h3>
<p><code>blake2s</code> (alias <code>b2s</code>) computes the BLAKE2s-256 cryptographic hash and returns a 64-character hex string. BLAKE2s is optimized for 8-32 bit platforms while BLAKE2b targets 64-bit. Use BLAKE2s when targeting embedded systems, WebAssembly, or when a 256-bit digest suffices.</p>
<pre><code class="lang-perl">p blake2s "hello world" # 9aec6806...
my $checksum = b2s($firmware_blob)
</code></pre>
</article>
<article class="doc-entry" id="doc-blake3">
<h3><a class="doc-anchor" href="#doc-blake3">#</a> <code>blake3</code></h3>
<p><code>blake3</code> (alias <code>b3</code>) computes the BLAKE3 cryptographic hash and returns a 64-character hex string (256-bit). BLAKE3 is the latest evolution — it is parallelizable, even faster than BLAKE2, and suitable for hashing large files at maximum speed. It is the recommended hash function for new projects where legacy compatibility is not required.</p>
<pre><code class="lang-perl">p blake3 "hello world" # d74981efa...
my $hash = b3(slurp "gigabyte-file.bin") # fast!
</code></pre>
</article>
<article class="doc-entry" id="doc-argon2-hash">
<h3><a class="doc-anchor" href="#doc-argon2-hash">#</a> <code>argon2_hash</code></h3>
<p><code>argon2_hash</code> (alias <code>argon2</code>) hashes a password using Argon2id, the winner of the Password Hashing Competition. Returns a PHC-format string containing algorithm parameters, salt, and hash. Argon2 is memory-hard and resistant to GPU/ASIC attacks. Use this for user password storage — never use MD5/SHA for passwords.</p>
<pre><code class="lang-perl">my $hash = argon2_hash("user-password")
to_file("user.hash", $hash)
# later...
if (argon2_verify("user-password", $hash)) {
p "login successful"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-argon2-verify">
<h3><a class="doc-anchor" href="#doc-argon2-verify">#</a> <code>argon2_verify</code></h3>
<p><code>argon2_verify</code> verifies a password against an Argon2 PHC hash string. Returns 1 if the password matches, 0 otherwise. The verification automatically extracts parameters from the stored hash, so changing Argon2 settings for new hashes does not break existing ones.</p>
<pre><code class="lang-perl">my $stored = rl("user.hash")
if (argon2_verify($user_input, $stored)) {
p "access granted"
} else {
p "invalid password"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-bcrypt-hash">
<h3><a class="doc-anchor" href="#doc-bcrypt-hash">#</a> <code>bcrypt_hash</code></h3>
<p><code>bcrypt_hash</code> (alias <code>bcrypt</code>) hashes a password using the bcrypt algorithm, returning a standard <code>$2b$...</code> format string. Bcrypt has been the industry standard for password hashing for over 20 years. While Argon2 is now preferred for new systems, bcrypt remains secure and widely deployed.</p>
<pre><code class="lang-perl">my $hash = bcrypt_hash("my-password")
p $hash # $2b$12$...
if (bcrypt_verify("my-password", $hash)) {
p "correct"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-bcrypt-verify">
<h3><a class="doc-anchor" href="#doc-bcrypt-verify">#</a> <code>bcrypt_verify</code></h3>
<p><code>bcrypt_verify</code> verifies a password against a bcrypt hash string. Returns 1 if correct, 0 otherwise. The cost factor and salt are extracted from the stored hash automatically.</p>
<pre><code class="lang-perl">if (bcrypt_verify($password, $stored_hash)) {
grant_access()
}
</code></pre>
</article>
<article class="doc-entry" id="doc-scrypt-hash">
<h3><a class="doc-anchor" href="#doc-scrypt-hash">#</a> <code>scrypt_hash</code></h3>
<p><code>scrypt_hash</code> (alias <code>scrypt</code>) hashes a password using the scrypt algorithm, returning a PHC-format string. Scrypt is memory-hard like Argon2 and is used in cryptocurrency (Litecoin) and some enterprise systems. It predates Argon2 but remains secure.</p>
<pre><code class="lang-perl">my $hash = scrypt_hash("password123")
if (scrypt_verify("password123", $hash)) {
p "verified"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-scrypt-verify">
<h3><a class="doc-anchor" href="#doc-scrypt-verify">#</a> <code>scrypt_verify</code></h3>
<p><code>scrypt_verify</code> verifies a password against a scrypt PHC hash. Returns 1 on match, 0 otherwise.</p>
<pre><code class="lang-perl">if (scrypt_verify($input, $stored)) {
p "valid"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-pbkdf2">
<h3><a class="doc-anchor" href="#doc-pbkdf2">#</a> <code>pbkdf2</code></h3>
<p><code>pbkdf2</code> (alias <code>pbkdf2_derive</code>) derives a cryptographic key from a password using PBKDF2-HMAC-SHA256. Returns a 64-character hex string (32 bytes). Takes password, salt, and optional iteration count (default 100,000). Use this when you need a fixed-length key from a password — for encryption keys, not password storage (use Argon2/bcrypt for that).</p>
<pre><code class="lang-perl">my $key = pbkdf2("password", "random-salt")
p $key # 64 hex chars = 32 bytes
my $strong = pbkdf2("pass", $salt, 200_000) # more iterations
</code></pre>
</article>
<article class="doc-entry" id="doc-random-bytes">
<h3><a class="doc-anchor" href="#doc-random-bytes">#</a> <code>random_bytes</code></h3>
<p><code>random_bytes</code> (alias <code>randbytes</code>) generates cryptographically secure random bytes using the OS CSPRNG. Returns a byte buffer of the specified length. Use for encryption keys, nonces, salts, and any security-sensitive randomness. Never use <code>rand()</code> for cryptographic purposes.</p>
<pre><code class="lang-perl">my $key = random_bytes(32) # 256-bit key
my $nonce = random_bytes(12) # 96-bit nonce for AES-GCM
p hex_encode($key)
</code></pre>
</article>
<article class="doc-entry" id="doc-random-bytes-hex">
<h3><a class="doc-anchor" href="#doc-random-bytes-hex">#</a> <code>random_bytes_hex</code></h3>
<p><code>random_bytes_hex</code> (alias <code>randhex</code>) generates cryptographically secure random bytes and returns them as a hex string. Convenient when you need a random hex token or key without a separate hex_encode call.</p>
<pre><code class="lang-perl">my $token = random_bytes_hex(16) # 32 hex chars
p $token # 7a3f9b2c1d...
my $api_key = "sk_" . randhex(24)
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-encrypt">
<h3><a class="doc-anchor" href="#doc-aes-encrypt">#</a> <code>aes_encrypt</code></h3>
<p><code>aes_encrypt</code> (alias <code>aes_enc</code>) encrypts plaintext using AES-256-GCM authenticated encryption. Takes a 32-byte key (use <code>random_bytes(32)</code> or <code>pbkdf2</code>). Returns a base64 string containing the nonce and ciphertext. AES-GCM provides both confidentiality and integrity — tampering is detected on decryption.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $cipher = aes_encrypt($key, "secret message")
p $cipher # base64 encoded
my $plain = aes_decrypt($key, $cipher)
p $plain # secret message
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-decrypt">
<h3><a class="doc-anchor" href="#doc-aes-decrypt">#</a> <code>aes_decrypt</code></h3>
<p><code>aes_decrypt</code> (alias <code>aes_dec</code>) decrypts AES-256-GCM ciphertext produced by <code>aes_encrypt</code>. Takes the same 32-byte key and the base64 ciphertext. Dies if the key is wrong or the ciphertext was tampered with (authentication failure).</p>
<pre><code class="lang-perl">my $plain = aes_decrypt($key, $ciphertext)
p $plain
# wrong key or tampered data raises exception
</code></pre>
</article>
<article class="doc-entry" id="doc-chacha-encrypt">
<h3><a class="doc-anchor" href="#doc-chacha-encrypt">#</a> <code>chacha_encrypt</code></h3>
<p><code>chacha_encrypt</code> (alias <code>chacha_enc</code>) encrypts plaintext using ChaCha20-Poly1305 authenticated encryption. Takes a 32-byte key. Returns base64(nonce || ciphertext || tag). ChaCha20-Poly1305 is the modern alternative to AES-GCM — faster in software, constant-time, and used in TLS 1.3, WireGuard, and SSH.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $cipher = chacha_encrypt($key, "secret data")
my $plain = chacha_decrypt($key, $cipher)
p $plain
</code></pre>
</article>
<article class="doc-entry" id="doc-chacha-decrypt">
<h3><a class="doc-anchor" href="#doc-chacha-decrypt">#</a> <code>chacha_decrypt</code></h3>
<p><code>chacha_decrypt</code> (alias <code>chacha_dec</code>) decrypts ChaCha20-Poly1305 ciphertext. Takes the same 32-byte key and base64 ciphertext. Dies on wrong key or tampering.</p>
<pre><code class="lang-perl">my $plain = chacha_decrypt($key, $cipher)
p $plain
</code></pre>
</article>
<article class="doc-entry" id="doc-ed25519-keygen">
<h3><a class="doc-anchor" href="#doc-ed25519-keygen">#</a> <code>ed25519_keygen</code></h3>
<p><code>ed25519_keygen</code> (alias <code>ed_keygen</code>) generates an Ed25519 signing keypair. Returns [private_key_hex, public_key_hex]. Ed25519 is the modern standard for digital signatures — fast, secure, and used in SSH, GPG, and cryptocurrency. The private key is 32 bytes (64 hex), the public key is also 32 bytes.</p>
<pre><code class="lang-perl">my ($priv, $pub) = @{ ed25519_keygen() }
p "Private: $priv"
p "Public: $pub"
my $sig = ed25519_sign($priv, "message")
</code></pre>
</article>
<article class="doc-entry" id="doc-ed25519-sign">
<h3><a class="doc-anchor" href="#doc-ed25519-sign">#</a> <code>ed25519_sign</code></h3>
<p><code>ed25519_sign</code> (alias <code>ed_sign</code>) signs a message with an Ed25519 private key. Takes the private key (hex) and message. Returns a 128-character hex signature (64 bytes). Signatures are deterministic — the same key+message always produces the same signature.</p>
<pre><code class="lang-perl">my $sig = ed25519_sign($private_key, "hello world")
p $sig # 128 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-ed25519-verify">
<h3><a class="doc-anchor" href="#doc-ed25519-verify">#</a> <code>ed25519_verify</code></h3>
<p><code>ed25519_verify</code> (alias <code>ed_verify</code>) verifies an Ed25519 signature. Takes public_key_hex, message, signature_hex. Returns 1 if valid, 0 if invalid. Never trust unsigned data in security contexts.</p>
<pre><code class="lang-perl">if (ed25519_verify($pub, "hello world", $sig)) {
p "signature valid"
} else {
p "FORGED!"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-x25519-keygen">
<h3><a class="doc-anchor" href="#doc-x25519-keygen">#</a> <code>x25519_keygen</code></h3>
<p><code>x25519_keygen</code> (alias <code>x_keygen</code>) generates an X25519 key-exchange keypair. Returns [private_key_hex, public_key_hex]. X25519 is the modern Diffie-Hellman — used in TLS 1.3, Signal, WireGuard. Both parties generate keypairs and exchange public keys to derive a shared secret.</p>
<pre><code class="lang-perl">my ($my_priv, $my_pub) = @{ x25519_keygen() }
# send $my_pub to peer, receive $their_pub
my $shared = x25519_dh($my_priv, $their_pub)
</code></pre>
</article>
<article class="doc-entry" id="doc-x25519-dh">
<h3><a class="doc-anchor" href="#doc-x25519-dh">#</a> <code>x25519_dh</code></h3>
<p><code>x25519_dh</code> (alias <code>x_dh</code>) performs X25519 Diffie-Hellman key exchange. Takes your private key and their public key. Returns a 64-character hex shared secret. Both parties derive the same secret, which can be used as an encryption key.</p>
<pre><code class="lang-perl">my $shared = x25519_dh($my_private, $their_public)
my $key = hex_decode(substr($shared, 0, 64)) # use as AES key
</code></pre>
</article>
<article class="doc-entry" id="doc-base64-encode">
<h3><a class="doc-anchor" href="#doc-base64-encode">#</a> <code>base64_encode</code></h3>
<p><code>base64_encode</code> (alias <code>b64e</code>) encodes a string or byte buffer as a Base64 string using the standard alphabet (A-Z, a-z, 0-9, +, /). Base64 is the standard way to embed binary data in text-based formats like JSON, XML, email (MIME), and data URIs. The output length is always a multiple of 4, padded with <code>=</code> as needed. Use <code>base64_decode</code> to reverse the encoding.</p>
<pre><code class="lang-perl">my $encoded = base64_encode "hello world"
p $encoded # aGVsbG8gd29ybGQ=
my $img_data = slurp "photo.png"
my $data_uri = "data:image/png;base64," . base64_encode($img_data)
p base64_decode(base64_encode("round trip")) # round trip
</code></pre>
</article>
<article class="doc-entry" id="doc-base64-decode">
<h3><a class="doc-anchor" href="#doc-base64-decode">#</a> <code>base64_decode</code></h3>
<p><code>base64_decode</code> (alias <code>b64d</code>) decodes a Base64-encoded string back to its original bytes. It accepts standard Base64 with padding and is tolerant of line breaks within the input. This is essential for processing email attachments, decoding JWT payloads, extracting embedded images from data URIs, or reading any Base64-encoded field from an API response. Raises an exception on invalid Base64 input.</p>
<pre><code class="lang-perl">my $decoded = base64_decode "aGVsbG8gd29ybGQ="
p $decoded # hello world
my $img = base64_decode($api_response->{avatar_b64})
spurt "avatar.png", $img
my $json = base64_decode($jwt_parts[1])
dd json_decode $json
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-encode">
<h3><a class="doc-anchor" href="#doc-hex-encode">#</a> <code>hex_encode</code></h3>
<p><code>hex_encode</code> (alias <code>hxe</code>) converts a string or byte buffer into its lowercase hexadecimal representation, with two hex characters per input byte. This is useful for displaying binary data in a human-readable format, generating hex-encoded keys or IDs, logging raw bytes, or preparing data for protocols that use hex encoding. The output is always an even number of characters.</p>
<pre><code class="lang-perl">p hex_encode "hello" # 68656c6c6f
my $raw = slurp "key.bin"
p hex_encode $raw
my $color = hex_encode chr(255) . chr(128) . chr(0)
p "#$color" # #ff8000
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-decode">
<h3><a class="doc-anchor" href="#doc-hex-decode">#</a> <code>hex_decode</code></h3>
<p><code>hex_decode</code> (alias <code>hxd</code>) converts a hexadecimal string back to its original bytes, interpreting every two hex characters as one byte. This is the inverse of <code>hex_encode</code> and is useful for parsing hex-encoded binary data from config files, network protocols, or cryptographic outputs. The input must have an even number of valid hex characters (0-9, a-f, A-F) or an exception is raised.</p>
<pre><code class="lang-perl">my $bytes = hex_decode "68656c6c6f"
p $bytes # hello
my $key = hex_decode $env_hex_key
my $mac = hmac_sha256($data, hex_decode($secret_hex))
p hex_decode(hex_encode("round trip")) # round trip
</code></pre>
</article>
<article class="doc-entry" id="doc-uuid">
<h3><a class="doc-anchor" href="#doc-uuid">#</a> <code>uuid</code></h3>
<p><code>uuid</code> generates a cryptographically random UUID version 4 string in the standard 8-4-4-4-12 hyphenated format. Each call produces a unique identifier suitable for database primary keys, correlation IDs, session tokens, temporary file names, or any situation requiring a globally unique identifier without coordination. The randomness comes from the OS CSPRNG.</p>
<pre><code class="lang-perl">my $id = uuid()
p $id # e.g., 550e8400-e29b-41d4-a716-446655440000
my %record = (id => uuid(), name => "Alice", created => time)
my @ids = map { uuid() } 1:10
</code></pre>
</article>
<article class="doc-entry" id="doc-jwt-encode">
<h3><a class="doc-anchor" href="#doc-jwt-encode">#</a> <code>jwt_encode</code></h3>
<p><code>jwt_encode</code> creates a signed JSON Web Token from a payload hashref and a secret key. The default algorithm is HS256 (HMAC-SHA256), but you can specify an alternative as the third argument. JWTs are the standard for stateless authentication tokens, API authorization, and secure inter-service communication. The returned string contains the base64url-encoded header, payload, and signature separated by dots.</p>
<pre><code class="lang-perl">my $token = jwt_encode({sub => "user123", exp => time + 3600}, "my-secret")
p $token
my $admin = jwt_encode({role => "admin", iat => time}, $secret, "HS512")
# send as Authorization header
http_request(method => "GET", url => $api_url,
headers => {Authorization => "Bearer $token"})
</code></pre>
</article>
<article class="doc-entry" id="doc-jwt-decode">
<h3><a class="doc-anchor" href="#doc-jwt-decode">#</a> <code>jwt_decode</code></h3>
<p><code>jwt_decode</code> verifies the signature of a JSON Web Token using the provided secret key and returns the decoded payload as a hashref. If the signature is invalid, the token has been tampered with, or it has expired (when an <code>exp</code> claim is present), the function raises an exception. This is the secure way to validate incoming JWTs from clients or other services — always use this over <code>jwt_decode_unsafe</code> in production.</p>
<pre><code class="lang-perl">my $payload = jwt_decode($token, "my-secret")
p $payload->{sub} # user123
my $claims = jwt_decode($bearer_token, $secret)
if ($claims->{role} eq "admin") {
p "admin access granted"
}
</code></pre>
<p>Note: raises an exception on expired tokens, invalid signatures, or malformed input.</p>
</article>
<article class="doc-entry" id="doc-jwt-decode-unsafe">
<h3><a class="doc-anchor" href="#doc-jwt-decode-unsafe">#</a> <code>jwt_decode_unsafe</code></h3>
<p><code>jwt_decode_unsafe</code> decodes a JSON Web Token and returns the payload as a hashref without verifying the signature. This is intentionally insecure and should only be used for debugging, logging, or inspecting token contents in development environments. Never use this to make authorization decisions in production — an attacker can stryke arbitrary payloads. The function still parses the JWT structure and base64-decodes the payload, but skips all cryptographic checks.</p>
<pre><code class="lang-perl"># debugging only — never use for auth
my $claims = jwt_decode_unsafe($token)
dd $claims
p $claims->{sub} # inspect without needing the secret
my $exp = $claims->{exp}
p "Expires: " . datetime_from_epoch($exp)$1
Note: this function exists for debugging. Use `jwt_decode` with a secret for any security-relevant validation.
</code></pre>
</article>
<article class="doc-entry" id="doc-url-encode">
<h3><a class="doc-anchor" href="#doc-url-encode">#</a> <code>url_encode</code></h3>
<p>Percent-encode a string so it is safe to embed in a URL query parameter or path segment. Unreserved characters (alphanumeric, <code>-</code>, <code>_</code>, <code>.</code>, <code>~</code>) are left as-is; everything else becomes <code>%XX</code>. The alias <code>uri_escape</code> matches the classic <code>URI::Escape</code> name for Perl muscle-memory.</p>
<pre><code class="lang-perl">my $q = "hello world & friends"
my $safe = url_encode($q)
p $safe # hello%20world%20%26%20friends
my $url = "https://example.com/search?q=" . url_encode($q)
p $url$1
Note: does not encode the full URL structure — encode individual components, not the whole URL.
</code></pre>
</article>
<article class="doc-entry" id="doc-url-decode">
<h3><a class="doc-anchor" href="#doc-url-decode">#</a> <code>url_decode</code></h3>
<p>Decode a percent-encoded string back to its original form, converting <code>%XX</code> sequences to the corresponding bytes and <code>+</code> to space. The alias <code>uri_unescape</code> matches <code>URI::Escape</code> conventions. Use this when parsing query strings from incoming URLs or reading URL-encoded form data.</p>
<pre><code class="lang-perl">my $encoded = "hello%20world%20%26%20friends"
p url_decode($encoded) # hello world & friends
# round-trip
my $orig = "café ☕"
p url_decode(url_encode($orig)) eq $orig # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-gzip">
<h3><a class="doc-anchor" href="#doc-gzip">#</a> <code>gzip</code></h3>
<p>Compress a string or byte buffer using the gzip (RFC 1952) format and return the compressed bytes. Useful for shrinking data before writing to disk or sending over the network. Pairs with <code>gunzip</code> for decompression. The compression level is chosen automatically for a good speed/size tradeoff.</p>
<pre><code class="lang-perl">my $raw = "hello world" x 1000
my $gz = gzip($raw)
to_file("data.gz", $gz)
p length($gz) # much smaller than original
p gunzip($gz) eq $raw # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-gunzip">
<h3><a class="doc-anchor" href="#doc-gunzip">#</a> <code>gunzip</code></h3>
<p>Decompress gzip-compressed data (RFC 1952) and return the original bytes. Dies if the input is not valid gzip. Use this to read <code>.gz</code> files or decompress data received from HTTP responses with <code>Content-Encoding: gzip</code>. Always the inverse of <code>gzip</code>.</p>
<pre><code class="lang-perl">my $compressed = rl("archive.gz")
my $text = gunzip($compressed)
p $text
# round-trip in a pipeline
"payload" |> gzip |> gunzip |> p # payload
</code></pre>
</article>
<article class="doc-entry" id="doc-zstd">
<h3><a class="doc-anchor" href="#doc-zstd">#</a> <code>zstd</code></h3>
<p>Compress a string or byte buffer using the Zstandard algorithm and return the compressed bytes. Zstandard offers significantly better compression ratios and speed compared to gzip, making it ideal for large datasets, IPC buffers, and caching. Pairs with <code>zstd_decode</code> for decompression.</p>
<pre><code class="lang-perl">my $big = "x]" x 100_000
my $compressed = zstd($big)
p length($compressed) # fraction of original
to_file("data.zst", $compressed)
p zstd_decode($compressed) eq $big # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-zstd-decode">
<h3><a class="doc-anchor" href="#doc-zstd-decode">#</a> <code>zstd_decode</code></h3>
<p>Decompress Zstandard-compressed data and return the original bytes. Dies if the input is not valid Zstandard. This is the inverse of <code>zstd</code>. Use it to read <code>.zst</code> files or decompress cached buffers that were compressed with <code>zstd</code>.</p>
<pre><code class="lang-perl">my $packed = zstd("important data\n" x 500)
my $original = zstd_decode($packed)
p $original
# file round-trip
to_file("cache.zst", zstd($payload))
p zstd_decode(rl("cache.zst"))
</code></pre>
</article>
<article class="doc-entry" id="doc-sha3-256">
<h3><a class="doc-anchor" href="#doc-sha3-256">#</a> <code>sha3_256</code></h3>
<p><code>sha3_256</code> (alias <code>s3_256</code>) computes the SHA3-256 hash (NIST FIPS 202) and returns a 64-character hex string. SHA-3 is the newest NIST-approved hash family, designed as a backup if SHA-2 is ever compromised. It uses the Keccak sponge construction which is fundamentally different from SHA-2.</p>
<pre><code class="lang-perl">p sha3_256 "hello world" # 644bcc7e...
my $h = s3_256(slurp "file.bin")
</code></pre>
</article>
<article class="doc-entry" id="doc-sha3-512">
<h3><a class="doc-anchor" href="#doc-sha3-512">#</a> <code>sha3_512</code></h3>
<p><code>sha3_512</code> (alias <code>s3_512</code>) computes the SHA3-512 hash and returns a 128-character hex string. Provides a 512-bit digest with the SHA-3 sponge construction.</p>
<pre><code class="lang-perl">p sha3_512 "hello world" # 840006...
</code></pre>
</article>
<article class="doc-entry" id="doc-shake128">
<h3><a class="doc-anchor" href="#doc-shake128">#</a> <code>shake128</code></h3>
<p><code>shake128</code> is a SHA-3 extendable-output function (XOF). Unlike fixed-length hashes, SHAKE can produce arbitrary-length output. Takes data and output length in bytes, returns hex. Useful for key derivation or when you need a variable-length digest.</p>
<pre><code class="lang-perl">p shake128("seed", 32) # 64 hex chars (32 bytes)
p shake128("seed", 64) # 128 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-shake256">
<h3><a class="doc-anchor" href="#doc-shake256">#</a> <code>shake256</code></h3>
<p><code>shake256</code> is a SHA-3 XOF with higher security margin than SHAKE128. Takes data and output length in bytes, returns hex.</p>
<pre><code class="lang-perl">p shake256("seed", 32)
p shake256("key material", 64)
</code></pre>
</article>
<article class="doc-entry" id="doc-ripemd160">
<h3><a class="doc-anchor" href="#doc-ripemd160">#</a> <code>ripemd160</code></h3>
<p><code>ripemd160</code> (alias <code>rmd160</code>) computes the RIPEMD-160 hash and returns a 40-character hex string. RIPEMD-160 is used in Bitcoin addresses (Hash160 = RIPEMD160(SHA256(pubkey))) and some legacy systems. Not recommended for new designs but essential for Bitcoin/crypto compatibility.</p>
<pre><code class="lang-perl">p ripemd160 "hello world" # 98c615784c...
my $hash160 = ripemd160(hex_decode(sha256($pubkey)))
</code></pre>
</article>
<article class="doc-entry" id="doc-siphash">
<h3><a class="doc-anchor" href="#doc-siphash">#</a> <code>siphash</code></h3>
<p><code>siphash</code> computes SipHash-2-4 with default keys (0,0) and returns a 16-character hex string (64-bit). SipHash is designed for hash table DoS resistance — it's fast and keyed, preventing attackers from crafting collisions. Used in Rust's HashMap, Python dict, and many other hash tables.</p>
<pre><code class="lang-perl">p siphash "key" # 16 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-sha1">
<h3><a class="doc-anchor" href="#doc-hmac-sha1">#</a> <code>hmac_sha1</code></h3>
<p><code>hmac_sha1</code> computes HMAC-SHA1 and returns a 40-character hex string. Used in OAuth 1.0, TOTP (Google Authenticator), and legacy APIs. Prefer HMAC-SHA256 for new designs.</p>
<pre><code class="lang-perl">p hmac_sha1("secret", "message") # 40 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-sha384">
<h3><a class="doc-anchor" href="#doc-hmac-sha384">#</a> <code>hmac_sha384</code></h3>
<p><code>hmac_sha384</code> computes HMAC-SHA384 and returns a 96-character hex string. Middle ground between SHA-256 and SHA-512.</p>
<pre><code class="lang-perl">p hmac_sha384("key", "data") # 96 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-sha512">
<h3><a class="doc-anchor" href="#doc-hmac-sha512">#</a> <code>hmac_sha512</code></h3>
<p><code>hmac_sha512</code> computes HMAC-SHA512 and returns a 128-character hex string. Maximum security margin in the SHA-2 family.</p>
<pre><code class="lang-perl">p hmac_sha512("key", "data") # 128 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-md5">
<h3><a class="doc-anchor" href="#doc-hmac-md5">#</a> <code>hmac_md5</code></h3>
<p><code>hmac_md5</code> computes HMAC-MD5 and returns a 32-character hex string. Legacy only — MD5 is broken for collision resistance but HMAC-MD5 is still considered safe for authentication. Only use for compatibility with old systems.</p>
<pre><code class="lang-perl">p hmac_md5("key", "data") # 32 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hkdf-sha256">
<h3><a class="doc-anchor" href="#doc-hkdf-sha256">#</a> <code>hkdf_sha256</code></h3>
<p><code>hkdf_sha256</code> (alias <code>hkdf</code>) is HKDF key derivation (RFC 5869) using HMAC-SHA256. Extracts entropy from input key material and expands it to the desired length. Used to derive encryption keys from shared secrets (after ECDH/X25519). Args: ikm, salt, info, output_length.</p>
<pre><code class="lang-perl">my $key = hkdf("shared_secret", "salt", "context", 32) # 64 hex
my $enc_key = hex_decode($key) # 32 bytes for AES-256
</code></pre>
</article>
<article class="doc-entry" id="doc-hkdf-sha512">
<h3><a class="doc-anchor" href="#doc-hkdf-sha512">#</a> <code>hkdf_sha512</code></h3>
<p><code>hkdf_sha512</code> is HKDF using HMAC-SHA512. Higher security margin than SHA256 variant.</p>
<pre><code class="lang-perl">my $key = hkdf_sha512("ikm", "salt", "info", 64) # 128 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-poly1305">
<h3><a class="doc-anchor" href="#doc-poly1305">#</a> <code>poly1305</code></h3>
<p><code>poly1305</code> computes a Poly1305 one-time MAC. Takes a 32-byte key and message, returns a 32-character hex tag (128-bit). Poly1305 is used with ChaCha20 in TLS 1.3. CRITICAL: each key must only be used once — reusing a key completely breaks security.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
p poly1305($key, "message") # 32 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-keygen">
<h3><a class="doc-anchor" href="#doc-rsa-keygen">#</a> <code>rsa_keygen</code></h3>
<p><code>rsa_keygen</code> generates an RSA keypair. Takes key size in bits (2048, 3072, or 4096). Returns [private_key_pem, public_key_pem]. RSA is the most widely used asymmetric algorithm — essential for TLS, SSH, and JWT RS256 signing.</p>
<pre><code class="lang-perl">my @kp = rsa_keygen(2048)
my ($priv, $pub) = @kp
spurt("private.pem", $priv)
spurt("public.pem", $pub)
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-encrypt">
<h3><a class="doc-anchor" href="#doc-rsa-encrypt">#</a> <code>rsa_encrypt</code></h3>
<p><code>rsa_encrypt</code> (alias <code>rsa_enc</code>) encrypts data with RSA-OAEP-SHA256. Takes public_key_pem and plaintext. Returns base64 ciphertext. Message size is limited to key_size/8 - 66 bytes (e.g. 190 bytes for 2048-bit key).</p>
<pre><code class="lang-perl">my $cipher = rsa_encrypt($pub_pem, "secret")
my $plain = rsa_decrypt($priv_pem, $cipher)
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-decrypt">
<h3><a class="doc-anchor" href="#doc-rsa-decrypt">#</a> <code>rsa_decrypt</code></h3>
<p><code>rsa_decrypt</code> (alias <code>rsa_dec</code>) decrypts RSA-OAEP ciphertext. Takes private_key_pem and base64 ciphertext.</p>
<pre><code class="lang-perl">my $plain = rsa_decrypt($priv, $ciphertext)
p $plain
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-sign">
<h3><a class="doc-anchor" href="#doc-rsa-sign">#</a> <code>rsa_sign</code></h3>
<p><code>rsa_sign</code> signs a message with RSA-PKCS1v15-SHA256. Takes private_key_pem and message. Returns base64 signature. This is the RS256 algorithm used in JWT.</p>
<pre><code class="lang-perl">my $sig = rsa_sign($priv, "message")
if (rsa_verify($pub, "message", $sig)) {
p "valid"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-verify">
<h3><a class="doc-anchor" href="#doc-rsa-verify">#</a> <code>rsa_verify</code></h3>
<p><code>rsa_verify</code> verifies an RSA-PKCS1v15-SHA256 signature. Takes public_key_pem, message, and base64 signature. Returns 1 if valid, 0 if not.</p>
<pre><code class="lang-perl">if (rsa_verify($pub_pem, $msg, $sig)) {
p "signature valid"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p256-keygen">
<h3><a class="doc-anchor" href="#doc-ecdsa-p256-keygen">#</a> <code>ecdsa_p256_keygen</code></h3>
<p><code>ecdsa_p256_keygen</code> (alias <code>p256_keygen</code>) generates an ECDSA P-256 (secp256r1/prime256v1) keypair. Returns [private_hex, public_hex_compressed]. P-256 is the NIST curve used in TLS, ES256 JWT, and WebAuthn.</p>
<pre><code class="lang-perl">my @kp = ecdsa_p256_keygen()
my ($priv, $pub) = @kp
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p256-sign">
<h3><a class="doc-anchor" href="#doc-ecdsa-p256-sign">#</a> <code>ecdsa_p256_sign</code></h3>
<p><code>ecdsa_p256_sign</code> (alias <code>p256_sign</code>) signs a message with ECDSA P-256. Takes private_key_hex and message. Returns DER-encoded signature as hex.</p>
<pre><code class="lang-perl">my $sig = ecdsa_p256_sign($priv, "hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p256-verify">
<h3><a class="doc-anchor" href="#doc-ecdsa-p256-verify">#</a> <code>ecdsa_p256_verify</code></h3>
<p><code>ecdsa_p256_verify</code> (alias <code>p256_verify</code>) verifies an ECDSA P-256 signature. Returns 1 if valid.</p>
<pre><code class="lang-perl">if (ecdsa_p256_verify($pub, "hello", $sig)) {
p "valid"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p384-keygen">
<h3><a class="doc-anchor" href="#doc-ecdsa-p384-keygen">#</a> <code>ecdsa_p384_keygen</code></h3>
<p><code>ecdsa_p384_keygen</code> generates an ECDSA P-384 keypair. P-384 offers more security margin than P-256.</p>
<pre><code class="lang-perl">my @kp = ecdsa_p384_keygen()
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p384-sign">
<h3><a class="doc-anchor" href="#doc-ecdsa-p384-sign">#</a> <code>ecdsa_p384_sign</code></h3>
<p><code>ecdsa_p384_sign</code> signs with ECDSA P-384.</p>
<pre><code class="lang-perl">my $sig = ecdsa_p384_sign($priv, $msg)
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p384-verify">
<h3><a class="doc-anchor" href="#doc-ecdsa-p384-verify">#</a> <code>ecdsa_p384_verify</code></h3>
<p><code>ecdsa_p384_verify</code> verifies an ECDSA P-384 signature.</p>
<pre><code class="lang-perl">p ecdsa_p384_verify($pub, $msg, $sig)
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-secp256k1-keygen">
<h3><a class="doc-anchor" href="#doc-ecdsa-secp256k1-keygen">#</a> <code>ecdsa_secp256k1_keygen</code></h3>
<p><code>ecdsa_secp256k1_keygen</code> generates an ECDSA secp256k1 keypair. This is the Bitcoin/Ethereum curve — different from P-256.</p>
<pre><code class="lang-perl">my @kp = ecdsa_secp256k1_keygen()
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-secp256k1-sign">
<h3><a class="doc-anchor" href="#doc-ecdsa-secp256k1-sign">#</a> <code>ecdsa_secp256k1_sign</code></h3>
<p><code>ecdsa_secp256k1_sign</code> signs with ECDSA secp256k1.</p>
<pre><code class="lang-perl">my $sig = ecdsa_secp256k1_sign($priv, $msg)
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-secp256k1-verify">
<h3><a class="doc-anchor" href="#doc-ecdsa-secp256k1-verify">#</a> <code>ecdsa_secp256k1_verify</code></h3>
<p><code>ecdsa_secp256k1_verify</code> verifies an ECDSA secp256k1 signature.</p>
<pre><code class="lang-perl">p ecdsa_secp256k1_verify($pub, $msg, $sig)
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdh-p256">
<h3><a class="doc-anchor" href="#doc-ecdh-p256">#</a> <code>ecdh_p256</code></h3>
<p><code>ecdh_p256</code> (alias <code>p256_dh</code>) performs ECDH key exchange on P-256. Takes my_private_hex and their_public_hex, returns shared_secret_hex. Use HKDF to derive encryption keys from the shared secret.</p>
<pre><code class="lang-perl">my @alice = ecdsa_p256_keygen()
my @bob = ecdsa_p256_keygen()
my $shared_a = ecdh_p256($alice[0], $bob[1])
my $shared_b = ecdh_p256($bob[0], $alice[1])
p $shared_a eq $shared_b # 1 — same secret
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdh-p384">
<h3><a class="doc-anchor" href="#doc-ecdh-p384">#</a> <code>ecdh_p384</code></h3>
<p><code>ecdh_p384</code> performs ECDH key exchange on P-384.</p>
<pre><code class="lang-perl">my $shared = ecdh_p384($my_priv, $their_pub)
</code></pre>
</article>
<article class="doc-entry" id="doc-base32-encode">
<h3><a class="doc-anchor" href="#doc-base32-encode">#</a> <code>base32_encode</code></h3>
<p><code>base32_encode</code> (alias <code>b32e</code>) encodes data as RFC 4648 Base32. Used in TOTP secrets, onion addresses, and Bech32. Returns uppercase with padding.</p>
<pre><code class="lang-perl">p base32_encode("hello") # NBSWY3DP
my $secret = base32_encode(random_bytes(20))
</code></pre>
</article>
<article class="doc-entry" id="doc-base32-decode">
<h3><a class="doc-anchor" href="#doc-base32-decode">#</a> <code>base32_decode</code></h3>
<p><code>base32_decode</code> (alias <code>b32d</code>) decodes RFC 4648 Base32 back to bytes. Accepts with or without padding.</p>
<pre><code class="lang-perl">p base32_decode("NBSWY3DP") # hello
</code></pre>
</article>
<article class="doc-entry" id="doc-base58-encode">
<h3><a class="doc-anchor" href="#doc-base58-encode">#</a> <code>base58_encode</code></h3>
<p><code>base58_encode</code> (alias <code>b58e</code>) encodes data using Bitcoin's Base58 alphabet (no 0, O, I, l to avoid confusion). Used in Bitcoin addresses, IPFS CIDs.</p>
<pre><code class="lang-perl">p base58_encode("hello") # Cn8eVZg
</code></pre>
</article>
<article class="doc-entry" id="doc-base58-decode">
<h3><a class="doc-anchor" href="#doc-base58-decode">#</a> <code>base58_decode</code></h3>
<p><code>base58_decode</code> (alias <code>b58d</code>) decodes Base58 back to bytes.</p>
<pre><code class="lang-perl">p base58_decode("Cn8eVZg") # hello
</code></pre>
</article>
<article class="doc-entry" id="doc-totp">
<h3><a class="doc-anchor" href="#doc-totp">#</a> <code>totp</code></h3>
<p><code>totp</code> (alias <code>totp_generate</code>) generates a TOTP code (RFC 6238) for 2FA. Takes base32-encoded secret, optional digits (default 6), optional period (default 30s). Compatible with Google Authenticator, Authy, etc.</p>
<pre><code class="lang-perl">my $secret = base32_encode(random_bytes(20))
my $code = totp($secret)
p $code # 6-digit code
# Custom: 8 digits, 60s period
my $code8 = totp($secret, 8, 60)
</code></pre>
</article>
<article class="doc-entry" id="doc-totp-verify">
<h3><a class="doc-anchor" href="#doc-totp-verify">#</a> <code>totp_verify</code></h3>
<p><code>totp_verify</code> verifies a TOTP code with optional time window (default ±1 period). Returns 1 if valid.</p>
<pre><code class="lang-perl">if (totp_verify($secret, $user_code)) {
p "2FA valid"
}
# Wider window: ±2 periods
totp_verify($secret, $code, 2)
</code></pre>
</article>
<article class="doc-entry" id="doc-hotp">
<h3><a class="doc-anchor" href="#doc-hotp">#</a> <code>hotp</code></h3>
<p><code>hotp</code> (alias <code>hotp_generate</code>) generates an HOTP code (RFC 4226) using a counter. Takes base32 secret, counter value, optional digits.</p>
<pre><code class="lang-perl">my $code = hotp($secret, 42) # counter=42
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-cbc-encrypt">
<h3><a class="doc-anchor" href="#doc-aes-cbc-encrypt">#</a> <code>aes_cbc_encrypt</code></h3>
<p><code>aes_cbc_encrypt</code> (alias <code>aes_cbc_enc</code>) encrypts with AES-256-CBC and PKCS7 padding. Takes 32-byte key, plaintext, optional 16-byte IV (auto-generated if omitted). Returns base64(iv || ciphertext). Legacy mode — prefer <code>aes_encrypt</code> (GCM) for new code.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $ct = aes_cbc_encrypt($key, "secret")
my $pt = aes_cbc_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-cbc-decrypt">
<h3><a class="doc-anchor" href="#doc-aes-cbc-decrypt">#</a> <code>aes_cbc_decrypt</code></h3>
<p><code>aes_cbc_decrypt</code> (alias <code>aes_cbc_dec</code>) decrypts AES-256-CBC. Takes 32-byte key and base64(iv || ciphertext).</p>
<pre><code class="lang-perl">my $pt = aes_cbc_decrypt($key, $ciphertext)
</code></pre>
</article>
<article class="doc-entry" id="doc-qr-ascii">
<h3><a class="doc-anchor" href="#doc-qr-ascii">#</a> <code>qr_ascii</code></h3>
<p><code>qr_ascii</code> (alias <code>qr</code>) generates a QR code as ASCII art. Perfect for terminal output.</p>
<pre><code class="lang-perl">p qr("https://example.com")
p qr("otpauth://totp/App:user?secret=$secret&issuer=App")
</code></pre>
</article>
<article class="doc-entry" id="doc-qr-png">
<h3><a class="doc-anchor" href="#doc-qr-png">#</a> <code>qr_png</code></h3>
<p><code>qr_png</code> generates a QR code as PNG image data (base64 encoded). Optional size parameter. Save to file or embed in HTML.</p>
<pre><code class="lang-perl">my $png = qr_png("https://example.com")
spurt("qr.png", base64_decode($png))
# Larger QR
my $big = qr_png($url, 16)
</code></pre>
</article>
<article class="doc-entry" id="doc-qr-svg">
<h3><a class="doc-anchor" href="#doc-qr-svg">#</a> <code>qr_svg</code></h3>
<p><code>qr_svg</code> generates a QR code as SVG string. Scalable vector graphics, ideal for web.</p>
<pre><code class="lang-perl">my $svg = qr_svg("https://example.com")
spurt("qr.svg", $svg)
</code></pre>
</article>
<article class="doc-entry" id="doc-barcode-code128">
<h3><a class="doc-anchor" href="#doc-barcode-code128">#</a> <code>barcode_code128</code></h3>
<p><code>barcode_code128</code> (alias <code>code128</code>) generates a Code 128 barcode as ASCII. Code 128 supports alphanumeric data and is widely used in shipping labels.</p>
<pre><code class="lang-perl">p code128("ABC-123")
</code></pre>
</article>
<article class="doc-entry" id="doc-barcode-code39">
<h3><a class="doc-anchor" href="#doc-barcode-code39">#</a> <code>barcode_code39</code></h3>
<p><code>barcode_code39</code> (alias <code>code39</code>) generates a Code 39 barcode. Supports uppercase, digits, and some symbols. Used in automotive and defense.</p>
<pre><code class="lang-perl">p code39("HELLO123")
</code></pre>
</article>
<article class="doc-entry" id="doc-barcode-ean13">
<h3><a class="doc-anchor" href="#doc-barcode-ean13">#</a> <code>barcode_ean13</code></h3>
<p><code>barcode_ean13</code> (alias <code>ean13</code>) generates an EAN-13 barcode (European Article Number). Standard retail barcode — requires exactly 12-13 digits.</p>
<pre><code class="lang-perl">p ean13("5901234123457")
</code></pre>
</article>
<article class="doc-entry" id="doc-barcode-svg">
<h3><a class="doc-anchor" href="#doc-barcode-svg">#</a> <code>barcode_svg</code></h3>
<p><code>barcode_svg</code> generates a barcode as SVG. Second argument specifies type: code128, code39, ean13, upca.</p>
<pre><code class="lang-perl">my $svg = barcode_svg("ABC-123", "code128")
spurt("barcode.svg", $svg)
my $retail = barcode_svg("012345678905", "upca")
</code></pre>
</article>
<article class="doc-entry" id="doc-brotli">
<h3><a class="doc-anchor" href="#doc-brotli">#</a> <code>brotli</code></h3>
<p><code>brotli</code> (alias <code>br</code>) compresses data using the Brotli algorithm (RFC 7932). Excellent compression ratio, used in HTTP compression. Returns compressed bytes.</p>
<pre><code class="lang-perl">my $compressed = brotli($data)
p length($data) . " -> " . length($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-brotli-decode">
<h3><a class="doc-anchor" href="#doc-brotli-decode">#</a> <code>brotli_decode</code></h3>
<p><code>brotli_decode</code> (alias <code>ubr</code>) decompresses Brotli data.</p>
<pre><code class="lang-perl">my $original = brotli_decode($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-xz">
<h3><a class="doc-anchor" href="#doc-xz">#</a> <code>xz</code></h3>
<p><code>xz</code> (alias <code>lzma</code>) compresses data using XZ/LZMA2. Best compression ratio, slower. Returns compressed bytes.</p>
<pre><code class="lang-perl">my $compressed = xz($data)
spurt("file.xz", $compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-xz-decode">
<h3><a class="doc-anchor" href="#doc-xz-decode">#</a> <code>xz_decode</code></h3>
<p><code>xz_decode</code> (aliases <code>unxz</code>, <code>unlzma</code>) decompresses XZ/LZMA data.</p>
<pre><code class="lang-perl">my $original = xz_decode(slurp("file.xz"))
</code></pre>
</article>
<article class="doc-entry" id="doc-bzip2">
<h3><a class="doc-anchor" href="#doc-bzip2">#</a> <code>bzip2</code></h3>
<p><code>bzip2</code> (alias <code>bz2</code>) compresses data using bzip2. Good compression, moderate speed. Returns compressed bytes.</p>
<pre><code class="lang-perl">my $compressed = bzip2($data)
</code></pre>
</article>
<article class="doc-entry" id="doc-bzip2-decode">
<h3><a class="doc-anchor" href="#doc-bzip2-decode">#</a> <code>bzip2_decode</code></h3>
<p><code>bzip2_decode</code> (aliases <code>bunzip2</code>, <code>ubz2</code>) decompresses bzip2 data.</p>
<pre><code class="lang-perl">my $original = bunzip2($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-lz4">
<h3><a class="doc-anchor" href="#doc-lz4">#</a> <code>lz4</code></h3>
<p><code>lz4</code> compresses data using LZ4. Very fast compression/decompression, moderate ratio. Ideal for real-time compression.</p>
<pre><code class="lang-perl">my $compressed = lz4($data)
</code></pre>
</article>
<article class="doc-entry" id="doc-lz4-decode">
<h3><a class="doc-anchor" href="#doc-lz4-decode">#</a> <code>lz4_decode</code></h3>
<p><code>lz4_decode</code> (alias <code>unlz4</code>) decompresses LZ4 data.</p>
<pre><code class="lang-perl">my $original = lz4_decode($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-snappy">
<h3><a class="doc-anchor" href="#doc-snappy">#</a> <code>snappy</code></h3>
<p><code>snappy</code> (alias <code>snp</code>) compresses data using Snappy. Fastest compression, used in databases and RPC. Returns compressed bytes.</p>
<pre><code class="lang-perl">my $compressed = snappy($data)
</code></pre>
</article>
<article class="doc-entry" id="doc-snappy-decode">
<h3><a class="doc-anchor" href="#doc-snappy-decode">#</a> <code>snappy_decode</code></h3>
<p><code>snappy_decode</code> (alias <code>unsnappy</code>) decompresses Snappy data.</p>
<pre><code class="lang-perl">my $original = snappy_decode($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-lzw">
<h3><a class="doc-anchor" href="#doc-lzw">#</a> <code>lzw</code></h3>
<p><code>lzw</code> compresses data using LZW (GIF/TIFF style). Classic algorithm.</p>
<pre><code class="lang-perl">my $compressed = lzw($data)
</code></pre>
</article>
<article class="doc-entry" id="doc-lzw-decode">
<h3><a class="doc-anchor" href="#doc-lzw-decode">#</a> <code>lzw_decode</code></h3>
<p><code>lzw_decode</code> (alias <code>unlzw</code>) decompresses LZW data.</p>
<pre><code class="lang-perl">my $original = lzw_decode($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-create">
<h3><a class="doc-anchor" href="#doc-tar-create">#</a> <code>tar_create</code></h3>
<p><code>tar_create</code> (alias <code>tar</code>) creates a tar archive from a directory. Returns tar bytes.</p>
<pre><code class="lang-perl">my $archive = tar_create("./src")
spurt("backup.tar", $archive)
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-extract">
<h3><a class="doc-anchor" href="#doc-tar-extract">#</a> <code>tar_extract</code></h3>
<p><code>tar_extract</code> (alias <code>untar</code>) extracts a tar archive to a directory.</p>
<pre><code class="lang-perl">tar_extract(slurp("backup.tar"), "./restored")
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-list">
<h3><a class="doc-anchor" href="#doc-tar-list">#</a> <code>tar_list</code></h3>
<p><code>tar_list</code> lists files in a tar archive. Returns array of paths.</p>
<pre><code class="lang-perl">my @files = @{tar_list(slurp("backup.tar"))}
@files |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-gz-create">
<h3><a class="doc-anchor" href="#doc-tar-gz-create">#</a> <code>tar_gz_create</code></h3>
<p><code>tar_gz_create</code> (alias <code>tgz</code>) creates a gzipped tar archive. Convenience for tar + gzip.</p>
<pre><code class="lang-perl">my $tgz = tgz("./project")
spurt("project.tar.gz", $tgz)
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-gz-extract">
<h3><a class="doc-anchor" href="#doc-tar-gz-extract">#</a> <code>tar_gz_extract</code></h3>
<p><code>tar_gz_extract</code> (alias <code>untgz</code>) extracts a .tar.gz archive.</p>
<pre><code class="lang-perl">untgz(slurp("project.tar.gz"), "./extracted")
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-create">
<h3><a class="doc-anchor" href="#doc-zip-create">#</a> <code>zip_create</code></h3>
<p><code>zip_create</code> creates a ZIP archive from a directory. Returns zip bytes.</p>
<pre><code class="lang-perl">my $archive = zip_create("./docs")
spurt("docs.zip", $archive)
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-extract">
<h3><a class="doc-anchor" href="#doc-zip-extract">#</a> <code>zip_extract</code></h3>
<p><code>zip_extract</code> extracts a ZIP archive to a directory.</p>
<pre><code class="lang-perl">zip_extract(slurp("docs.zip"), "./extracted")
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-list">
<h3><a class="doc-anchor" href="#doc-zip-list">#</a> <code>zip_list</code></h3>
<p><code>zip_list</code> lists files in a ZIP archive. Returns array of paths.</p>
<pre><code class="lang-perl">my @files = @{zip_list(slurp("archive.zip"))}
</code></pre>
</article>
<article class="doc-entry" id="doc-md4">
<h3><a class="doc-anchor" href="#doc-md4">#</a> <code>md4</code></h3>
<p><code>md4</code> computes the MD4 hash and returns a 32-character hex string. MD4 is completely broken — only use for legacy NTLM compatibility or historical systems.</p>
<pre><code class="lang-perl">p md4("hello") # 32 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-xxh32">
<h3><a class="doc-anchor" href="#doc-xxh32">#</a> <code>xxh32</code></h3>
<p><code>xxh32</code> (alias <code>xxhash32</code>) computes xxHash32 — extremely fast non-cryptographic hash. Optional seed parameter. Returns 8 hex chars.</p>
<pre><code class="lang-perl">p xxh32("hello") # default seed 0
p xxh32("hello", 42) # with seed
</code></pre>
</article>
<article class="doc-entry" id="doc-xxh64">
<h3><a class="doc-anchor" href="#doc-xxh64">#</a> <code>xxh64</code></h3>
<p><code>xxh64</code> (alias <code>xxhash64</code>) computes xxHash64 — fast 64-bit hash. Returns 16 hex chars.</p>
<pre><code class="lang-perl">p xxh64("hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-xxh3">
<h3><a class="doc-anchor" href="#doc-xxh3">#</a> <code>xxh3</code></h3>
<p><code>xxh3</code> (alias <code>xxhash3</code>) computes xxHash3-64 — newest xxHash variant, fastest on modern CPUs. Returns 16 hex chars.</p>
<pre><code class="lang-perl">p xxh3("hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-xxh3-128">
<h3><a class="doc-anchor" href="#doc-xxh3-128">#</a> <code>xxh3_128</code></h3>
<p><code>xxh3_128</code> computes xxHash3-128. Returns 32 hex chars.</p>
<pre><code class="lang-perl">p xxh3_128("hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-murmur3">
<h3><a class="doc-anchor" href="#doc-murmur3">#</a> <code>murmur3</code></h3>
<p><code>murmur3</code> (alias <code>murmur3_32</code>) computes MurmurHash3 32-bit. Fast non-cryptographic hash, widely used in hash tables and bloom filters. Optional seed. Returns 8 hex chars.</p>
<pre><code class="lang-perl">p murmur3("hello") # default seed 0
p murmur3("hello", 42) # with seed
</code></pre>
</article>
<article class="doc-entry" id="doc-murmur3-128">
<h3><a class="doc-anchor" href="#doc-murmur3-128">#</a> <code>murmur3_128</code></h3>
<p><code>murmur3_128</code> computes MurmurHash3 128-bit (x64 variant). Returns 32 hex chars.</p>
<pre><code class="lang-perl">p murmur3_128("hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-blowfish-encrypt">
<h3><a class="doc-anchor" href="#doc-blowfish-encrypt">#</a> <code>blowfish_encrypt</code></h3>
<p><code>blowfish_encrypt</code> (alias <code>bf_enc</code>) encrypts with Blowfish-CBC. Key=4-56 bytes, optional 8-byte IV. Legacy cipher — use AES for new code.</p>
<pre><code class="lang-perl">my $ct = blowfish_encrypt($key, "secret")
my $pt = blowfish_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-blowfish-decrypt">
<h3><a class="doc-anchor" href="#doc-blowfish-decrypt">#</a> <code>blowfish_decrypt</code></h3>
<p><code>blowfish_decrypt</code> (alias <code>bf_dec</code>) decrypts Blowfish-CBC.</p>
<pre><code class="lang-perl">my $pt = blowfish_decrypt($key, $ciphertext)
</code></pre>
</article>
<article class="doc-entry" id="doc-des3-encrypt">
<h3><a class="doc-anchor" href="#doc-des3-encrypt">#</a> <code>des3_encrypt</code></h3>
<p><code>des3_encrypt</code> (aliases <code>3des_enc</code>, <code>tdes_enc</code>) encrypts with Triple DES (3DES) CBC. Key=24 bytes (three 8-byte DES keys). Legacy cipher for PCI-DSS compliance.</p>
<pre><code class="lang-perl">my $key = random_bytes(24)
my $ct = des3_encrypt($key, "secret")
my $pt = des3_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-des3-decrypt">
<h3><a class="doc-anchor" href="#doc-des3-decrypt">#</a> <code>des3_decrypt</code></h3>
<p><code>des3_decrypt</code> (aliases <code>3des_dec</code>, <code>tdes_dec</code>) decrypts Triple DES (3DES) CBC.</p>
<pre><code class="lang-perl">my $pt = des3_decrypt($key, $ciphertext)
</code></pre>
</article>
<article class="doc-entry" id="doc-twofish-encrypt">
<h3><a class="doc-anchor" href="#doc-twofish-encrypt">#</a> <code>twofish_encrypt</code></h3>
<p><code>twofish_encrypt</code> (alias <code>tf_enc</code>) encrypts with Twofish-CBC. Key=16/24/32 bytes. AES finalist, still secure.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $ct = twofish_encrypt($key, "secret")
</code></pre>
</article>
<article class="doc-entry" id="doc-twofish-decrypt">
<h3><a class="doc-anchor" href="#doc-twofish-decrypt">#</a> <code>twofish_decrypt</code></h3>
<p><code>twofish_decrypt</code> (alias <code>tf_dec</code>) decrypts Twofish-CBC.</p>
<pre><code class="lang-perl">my $pt = twofish_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-camellia-encrypt">
<h3><a class="doc-anchor" href="#doc-camellia-encrypt">#</a> <code>camellia_encrypt</code></h3>
<p><code>camellia_encrypt</code> (alias <code>cam_enc</code>) encrypts with Camellia-CBC. Key=16/24/32 bytes. Japanese/EU standard, equivalent security to AES.</p>
<pre><code class="lang-perl">my $ct = camellia_encrypt($key, "secret")
</code></pre>
</article>
<article class="doc-entry" id="doc-camellia-decrypt">
<h3><a class="doc-anchor" href="#doc-camellia-decrypt">#</a> <code>camellia_decrypt</code></h3>
<p><code>camellia_decrypt</code> (alias <code>cam_dec</code>) decrypts Camellia-CBC.</p>
<pre><code class="lang-perl">my $pt = camellia_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-cast5-encrypt">
<h3><a class="doc-anchor" href="#doc-cast5-encrypt">#</a> <code>cast5_encrypt</code></h3>
<p><code>cast5_encrypt</code> encrypts with CAST5-CBC. Key=5-16 bytes. Used in PGP.</p>
<pre><code class="lang-perl">my $ct = cast5_encrypt($key, "secret")
</code></pre>
</article>
<article class="doc-entry" id="doc-cast5-decrypt">
<h3><a class="doc-anchor" href="#doc-cast5-decrypt">#</a> <code>cast5_decrypt</code></h3>
<p><code>cast5_decrypt</code> decrypts CAST5-CBC.</p>
<pre><code class="lang-perl">my $pt = cast5_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-salsa20">
<h3><a class="doc-anchor" href="#doc-salsa20">#</a> <code>salsa20</code></h3>
<p><code>salsa20</code> encrypts with Salsa20 stream cipher. Key=32 bytes, nonce auto-generated. Fast, secure stream cipher.</p>
<pre><code class="lang-perl">my $ct = salsa20($key, "data")
my $pt = salsa20_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-salsa20-decrypt">
<h3><a class="doc-anchor" href="#doc-salsa20-decrypt">#</a> <code>salsa20_decrypt</code></h3>
<p><code>salsa20_decrypt</code> decrypts Salsa20.</p>
<pre><code class="lang-perl">my $pt = salsa20_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-xsalsa20">
<h3><a class="doc-anchor" href="#doc-xsalsa20">#</a> <code>xsalsa20</code></h3>
<p><code>xsalsa20</code> encrypts with XSalsa20 (extended 24-byte nonce). Safer for random nonces.</p>
<pre><code class="lang-perl">my $ct = xsalsa20($key, "data")
</code></pre>
</article>
<article class="doc-entry" id="doc-xsalsa20-decrypt">
<h3><a class="doc-anchor" href="#doc-xsalsa20-decrypt">#</a> <code>xsalsa20_decrypt</code></h3>
<p><code>xsalsa20_decrypt</code> decrypts XSalsa20.</p>
<pre><code class="lang-perl">my $pt = xsalsa20_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-secretbox">
<h3><a class="doc-anchor" href="#doc-secretbox">#</a> <code>secretbox</code></h3>
<p><code>secretbox</code> (alias <code>secretbox_seal</code>) is NaCl's symmetric authenticated encryption (XSalsa20-Poly1305). Key=32 bytes. Simple, secure, fast.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $ct = secretbox($key, "message")
my $pt = secretbox_open($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-secretbox-open">
<h3><a class="doc-anchor" href="#doc-secretbox-open">#</a> <code>secretbox_open</code></h3>
<p><code>secretbox_open</code> decrypts and authenticates NaCl secretbox.</p>
<pre><code class="lang-perl">my $pt = secretbox_open($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-nacl-box-keygen">
<h3><a class="doc-anchor" href="#doc-nacl-box-keygen">#</a> <code>nacl_box_keygen</code></h3>
<p><code>nacl_box_keygen</code> generates a NaCl box keypair (X25519). Returns [secret_key_hex, public_key_hex].</p>
<pre><code class="lang-perl">my @kp = nacl_box_keygen()
my ($sk, $pk) = @kp
</code></pre>
</article>
<article class="doc-entry" id="doc-nacl-box">
<h3><a class="doc-anchor" href="#doc-nacl-box">#</a> <code>nacl_box</code></h3>
<p><code>nacl_box</code> is NaCl's asymmetric authenticated encryption. Takes recipient's public key, sender's secret key, plaintext.</p>
<pre><code class="lang-perl">my @alice = nacl_box_keygen()
my @bob = nacl_box_keygen()
my $ct = nacl_box($bob[1], $alice[0], "hello") # to Bob from Alice
my $pt = nacl_box_open($alice[1], $bob[0], $ct) # Bob decrypts
</code></pre>
</article>
<article class="doc-entry" id="doc-nacl-box-open">
<h3><a class="doc-anchor" href="#doc-nacl-box-open">#</a> <code>nacl_box_open</code></h3>
<p><code>nacl_box_open</code> decrypts NaCl box. Takes sender's public key, recipient's secret key, ciphertext.</p>
<pre><code class="lang-perl">my $pt = nacl_box_open($sender_pk, $my_sk, $ct)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-special-math-functions">
<h2>Special Math Functions</h2>
<p class="chapter-meta">12 topics</p>
<article class="doc-entry" id="doc-erf">
<h3><a class="doc-anchor" href="#doc-erf">#</a> <code>erf</code></h3>
<p><code>erf</code> computes the error function, which arises in probability, statistics, and solutions to the heat equation. erf(x) is the probability that a standard normal random variable falls in [-x√2, x√2]. Returns a value in (-1, 1).</p>
<pre><code class="lang-perl">p erf(0) # 0
p erf(1) # 0.8427...
p erf(10) # ~1
</code></pre>
</article>
<article class="doc-entry" id="doc-erfc">
<h3><a class="doc-anchor" href="#doc-erfc">#</a> <code>erfc</code></h3>
<p><code>erfc</code> computes the complementary error function erfc(x) = 1 - erf(x). Numerically stable for large x where erf(x) ≈ 1. Used in computing tail probabilities of normal distributions.</p>
<pre><code class="lang-perl">p erfc(0) # 1
p erfc(3) # 0.0000220...
</code></pre>
</article>
<article class="doc-entry" id="doc-gamma">
<h3><a class="doc-anchor" href="#doc-gamma">#</a> <code>gamma</code></h3>
<p><code>gamma</code> (alias <code>tgamma</code>) computes the gamma function Γ(x), the extension of factorial to real numbers. Γ(n) = (n-1)! for positive integers. Used throughout statistics, physics, and combinatorics.</p>
<pre><code class="lang-perl">p gamma(5) # 24 (= 4!)
p gamma(0.5) # √π ≈ 1.7724...
p gamma(1) # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-lgamma">
<h3><a class="doc-anchor" href="#doc-lgamma">#</a> <code>lgamma</code></h3>
<p><code>lgamma</code> (alias <code>ln_gamma</code>) computes the natural logarithm of the gamma function: ln(Γ(x)). Avoids overflow for large arguments where Γ(x) would be astronomical. Essential for computing log-probabilities in statistics.</p>
<pre><code class="lang-perl">p lgamma(100) # 359.13...
p lgamma(1000) # 5905.22...
</code></pre>
</article>
<article class="doc-entry" id="doc-digamma">
<h3><a class="doc-anchor" href="#doc-digamma">#</a> <code>digamma</code></h3>
<p><code>digamma</code> (alias <code>psi</code>) computes the digamma function ψ(x) = d/dx ln(Γ(x)), the logarithmic derivative of gamma. Appears in Bayesian statistics (expected log of Dirichlet variables), optimization, and special function theory.</p>
<pre><code class="lang-perl">p digamma(1) # -γ ≈ -0.5772 (Euler-Mascheroni)
p digamma(2) # 1 - γ ≈ 0.4228
</code></pre>
</article>
<article class="doc-entry" id="doc-beta-fn">
<h3><a class="doc-anchor" href="#doc-beta-fn">#</a> <code>beta_fn</code></h3>
<p><code>beta_fn</code> computes the beta function B(a,b) = Γ(a)Γ(b)/Γ(a+b). The beta function is the normalizing constant of the Beta distribution and appears throughout Bayesian statistics and combinatorics.</p>
<pre><code class="lang-perl">p beta_fn(2, 3) # 0.0833...
p beta_fn(0.5, 0.5) # π
</code></pre>
</article>
<article class="doc-entry" id="doc-lbeta">
<h3><a class="doc-anchor" href="#doc-lbeta">#</a> <code>lbeta</code></h3>
<p><code>lbeta</code> (alias <code>ln_beta</code>) computes ln(B(a,b)), the log of the beta function. Avoids overflow for small a or b where B(a,b) is very large.</p>
<pre><code class="lang-perl">p lbeta(0.01, 0.01) # large positive
</code></pre>
</article>
<article class="doc-entry" id="doc-betainc">
<h3><a class="doc-anchor" href="#doc-betainc">#</a> <code>betainc</code></h3>
<p><code>betainc</code> (alias <code>beta_reg</code>) computes the regularized incomplete beta function I_x(a,b), the CDF of the Beta distribution. Takes (x, a, b). Essential for computing p-values of F-tests, t-tests, and binomial probabilities.</p>
<pre><code class="lang-perl">p betainc(0.5, 2, 3) # P(Beta(2,3) < 0.5)
</code></pre>
</article>
<article class="doc-entry" id="doc-gammainc">
<h3><a class="doc-anchor" href="#doc-gammainc">#</a> <code>gammainc</code></h3>
<p><code>gammainc</code> (alias <code>gamma_li</code>) computes the lower incomplete gamma function γ(a,x) = ∫₀ˣ t^(a-1) e^(-t) dt. Used in computing CDFs of gamma and chi-squared distributions.</p>
<pre><code class="lang-perl">p gammainc(2, 1) # γ(2, 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-gammaincc">
<h3><a class="doc-anchor" href="#doc-gammaincc">#</a> <code>gammaincc</code></h3>
<p><code>gammaincc</code> (alias <code>gamma_ui</code>) computes the upper incomplete gamma function Γ(a,x) = ∫ₓ^∞ t^(a-1) e^(-t) dt = Γ(a) - γ(a,x). Useful for tail probabilities.</p>
<pre><code class="lang-perl">p gammaincc(2, 1) # Γ(2, 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-gammainc-reg">
<h3><a class="doc-anchor" href="#doc-gammainc-reg">#</a> <code>gammainc_reg</code></h3>
<p><code>gammainc_reg</code> (alias <code>gamma_lr</code>) computes the regularized lower incomplete gamma P(a,x) = γ(a,x)/Γ(a), the CDF of the gamma distribution Gamma(a, 1).</p>
<pre><code class="lang-perl">p gammainc_reg(2, 1) # P(Gamma(2,1) < 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-gammaincc-reg">
<h3><a class="doc-anchor" href="#doc-gammaincc-reg">#</a> <code>gammaincc_reg</code></h3>
<p><code>gammaincc_reg</code> (alias <code>gamma_ur</code>) computes the regularized upper incomplete gamma Q(a,x) = 1 - P(a,x), the survival function of the gamma distribution.</p>
<pre><code class="lang-perl">p gammaincc_reg(2, 1) # P(Gamma(2,1) > 1)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-bessel-airy-hankel-struve-kelvin">
<h2>Bessel / Airy / Hankel / Struve / Kelvin</h2>
<p class="chapter-meta">19 topics</p>
<article class="doc-entry" id="doc-bessel-j0">
<h3><a class="doc-anchor" href="#doc-bessel-j0">#</a> <code>bessel_j0</code></h3>
<p><code>bessel_j0</code> (alias <code>j0</code>) computes the Bessel function of the first kind, order 0.</p>
<pre><code class="lang-perl">p j0(0) # 1.0
p j0(2.4) # ≈ 0 (first zero)
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-j1">
<h3><a class="doc-anchor" href="#doc-bessel-j1">#</a> <code>bessel_j1</code></h3>
<p><code>bessel_j1</code> (alias <code>j1</code>) computes the Bessel function of the first kind, order 1.</p>
<pre><code class="lang-perl">p j1(0) # 0.0
p j1(1.84) # ≈ 0.582 (first max)
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-j">
<h3><a class="doc-anchor" href="#doc-bessel-j">#</a> <code>bessel_j</code></h3>
<p><code>bessel_j N, X</code> — Bessel function of the first kind J_n(x) for integer n. Generalises <code>bessel_j0</code> / <code>bessel_j1</code>.</p>
<pre><code class="lang-perl">p bessel_j(2, 5) # ≈ 0.0466
p bessel_j(0, 0) # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-y">
<h3><a class="doc-anchor" href="#doc-bessel-y">#</a> <code>bessel_y</code></h3>
<p><code>bessel_y N, X</code> — Bessel function of the second kind Y_n(x). Singular at x = 0.</p>
<pre><code class="lang-perl">p bessel_y(0, 1) # ≈ 0.0883
p bessel_y(1, 5) # ≈ 0.1479
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-i">
<h3><a class="doc-anchor" href="#doc-bessel-i">#</a> <code>bessel_i</code></h3>
<p><code>bessel_i N, X</code> — Modified Bessel function I_n(x). Grows exponentially for large x.</p>
<pre><code class="lang-perl">p bessel_i(0, 1) # ≈ 1.266
p bessel_i(2, 3) # ≈ 2.245
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-k">
<h3><a class="doc-anchor" href="#doc-bessel-k">#</a> <code>bessel_k</code></h3>
<p><code>bessel_k N, X</code> — Modified Bessel function K_n(x). Decays exponentially for large x; singular at 0.</p>
<pre><code class="lang-perl">p bessel_k(0, 1) # ≈ 0.4210
p bessel_k(1, 1) # ≈ 0.6019
</code></pre>
</article>
<article class="doc-entry" id="doc-hankel-h1">
<h3><a class="doc-anchor" href="#doc-hankel-h1">#</a> <code>hankel_h1</code></h3>
<p><code>hankel_h1 N, X</code> returns the complex Hankel H_n^(1)(x) = J_n(x) + i Y_n(x) as <code>[Re, Im]</code>.</p>
<pre><code class="lang-perl">my ($re, $im) = hankel_h1(0, 1)
p "$re + i*$im"
</code></pre>
</article>
<article class="doc-entry" id="doc-hankel-h2">
<h3><a class="doc-anchor" href="#doc-hankel-h2">#</a> <code>hankel_h2</code></h3>
<p><code>hankel_h2 N, X</code> returns H_n^(2)(x) = J_n(x) - i Y_n(x) as <code>[Re, Im]</code>.</p>
</article>
<article class="doc-entry" id="doc-bessel-j-zero">
<h3><a class="doc-anchor" href="#doc-bessel-j-zero">#</a> <code>bessel_j_zero</code></h3>
<p><code>bessel_j_zero N, K</code> computes the Kth positive zero of J_n. Uses McMahon expansion + Newton refinement.</p>
<pre><code class="lang-perl">p bessel_j_zero(0, 1) # 2.4048…
p bessel_j_zero(1, 1) # 3.8317…
</code></pre>
</article>
<article class="doc-entry" id="doc-airy-ai">
<h3><a class="doc-anchor" href="#doc-airy-ai">#</a> <code>airy_ai</code></h3>
<p><code>airy_ai X</code> — Airy function Ai(x) (decaying solution of y'' = x y).</p>
<pre><code class="lang-perl">p airy_ai(0) # ≈ 0.3550
p airy_ai(2) # ≈ 0.0349
</code></pre>
</article>
<article class="doc-entry" id="doc-airy-bi">
<h3><a class="doc-anchor" href="#doc-airy-bi">#</a> <code>airy_bi</code></h3>
<p><code>airy_bi X</code> — Airy function Bi(x) (growing solution).</p>
</article>
<article class="doc-entry" id="doc-airy-ai-prime">
<h3><a class="doc-anchor" href="#doc-airy-ai-prime">#</a> <code>airy_ai_prime</code></h3>
<p><code>airy_ai_prime X</code> — derivative Ai'(x).</p>
</article>
<article class="doc-entry" id="doc-airy-bi-prime">
<h3><a class="doc-anchor" href="#doc-airy-bi-prime">#</a> <code>airy_bi_prime</code></h3>
<p><code>airy_bi_prime X</code> — derivative Bi'(x).</p>
</article>
<article class="doc-entry" id="doc-spherical-bessel-j">
<h3><a class="doc-anchor" href="#doc-spherical-bessel-j">#</a> <code>spherical_bessel_j</code></h3>
<p><code>spherical_bessel_j N, X</code> — j_n(x) = √(π/2x) J_{n+1/2}(x).</p>
<pre><code class="lang-perl">p spherical_bessel_j(0, 1) # sin(1)
</code></pre>
</article>
<article class="doc-entry" id="doc-spherical-bessel-y">
<h3><a class="doc-anchor" href="#doc-spherical-bessel-y">#</a> <code>spherical_bessel_y</code></h3>
<p><code>spherical_bessel_y N, X</code> — y_n(x) = √(π/2x) Y_{n+1/2}(x).</p>
</article>
<article class="doc-entry" id="doc-struve-h">
<h3><a class="doc-anchor" href="#doc-struve-h">#</a> <code>struve_h</code></h3>
<p><code>struve_h N, X</code> — Struve function H_n(x) (solution of an inhomogeneous Bessel equation).</p>
</article>
<article class="doc-entry" id="doc-struve-l">
<h3><a class="doc-anchor" href="#doc-struve-l">#</a> <code>struve_l</code></h3>
<p><code>struve_l N, X</code> — Modified Struve L_n(x).</p>
</article>
<article class="doc-entry" id="doc-kelvin-ber">
<h3><a class="doc-anchor" href="#doc-kelvin-ber">#</a> <code>kelvin_ber</code></h3>
<p><code>kelvin_ber X</code> — Real part of J_0(x e^(3πi/4)) (Kelvin function ber₀).</p>
</article>
<article class="doc-entry" id="doc-kelvin-bei">
<h3><a class="doc-anchor" href="#doc-kelvin-bei">#</a> <code>kelvin_bei</code></h3>
<p><code>kelvin_bei X</code> — Imaginary part of J_0(x e^(3πi/4)) (Kelvin function bei₀).</p>
</article>
</section>
<section class="tutorial-section" id="ch-orthogonal-polynomials">
<h2>Orthogonal Polynomials</h2>
<p class="chapter-meta">13 topics</p>
<article class="doc-entry" id="doc-legendre-p">
<h3><a class="doc-anchor" href="#doc-legendre-p">#</a> <code>legendre_p</code></h3>
<p><code>legendre_p N, X</code> — Legendre polynomial P_n(x). Uses the stable Bonnet recurrence (2n+1) x P_n = (n+1) P_{n+1} + n P_{n-1}.</p>
<pre><code class="lang-perl">p legendre_p(2, 0.5) # -0.125
p legendre_p(5, 1) # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-legendre-q">
<h3><a class="doc-anchor" href="#doc-legendre-q">#</a> <code>legendre_q</code></h3>
<p><code>legendre_q N, X</code> — Legendre Q_n(x), the second-kind solution. NaN for |x| ≥ 1.</p>
</article>
<article class="doc-entry" id="doc-assoc-legendre-p">
<h3><a class="doc-anchor" href="#doc-assoc-legendre-p">#</a> <code>assoc_legendre_p</code></h3>
<p><code>assoc_legendre_p N, M, X</code> — Associated Legendre P_n^m(x). Building block for spherical harmonics.</p>
</article>
<article class="doc-entry" id="doc-hermite-h">
<h3><a class="doc-anchor" href="#doc-hermite-h">#</a> <code>hermite_h</code></h3>
<p><code>hermite_h N, X</code> — Physicist's Hermite H_n(x): H_0=1, H_1=2x, H_{n+1}=2x H_n - 2n H_{n-1}.</p>
<pre><code class="lang-perl">p hermite_h(3, 1) # -4
</code></pre>
</article>
<article class="doc-entry" id="doc-hermite-he">
<h3><a class="doc-anchor" href="#doc-hermite-he">#</a> <code>hermite_he</code></h3>
<p><code>hermite_he N, X</code> — Probabilist's Hermite He_n(x): He_0=1, He_1=x, He_{n+1}=x He_n - n He_{n-1}.</p>
</article>
<article class="doc-entry" id="doc-laguerre-l">
<h3><a class="doc-anchor" href="#doc-laguerre-l">#</a> <code>laguerre_l</code></h3>
<p><code>laguerre_l N, X</code> — Laguerre polynomial L_n(x).</p>
</article>
<article class="doc-entry" id="doc-assoc-laguerre-l">
<h3><a class="doc-anchor" href="#doc-assoc-laguerre-l">#</a> <code>assoc_laguerre_l</code></h3>
<p><code>assoc_laguerre_l N, ALPHA, X</code> — Generalised Laguerre L_n^α(x).</p>
</article>
<article class="doc-entry" id="doc-jacobi-p">
<h3><a class="doc-anchor" href="#doc-jacobi-p">#</a> <code>jacobi_p</code></h3>
<p><code>jacobi_p N, ALPHA, BETA, X</code> — Jacobi polynomial P_n^{(α,β)}(x). Generalises Legendre/Chebyshev/Gegenbauer.</p>
</article>
<article class="doc-entry" id="doc-gegenbauer-c">
<h3><a class="doc-anchor" href="#doc-gegenbauer-c">#</a> <code>gegenbauer_c</code></h3>
<p><code>gegenbauer_c N, ALPHA, X</code> — Gegenbauer C_n^α(x). Reduces to Chebyshev/Legendre at specific α.</p>
</article>
<article class="doc-entry" id="doc-chebyshev-t">
<h3><a class="doc-anchor" href="#doc-chebyshev-t">#</a> <code>chebyshev_t</code></h3>
<p><code>chebyshev_t N, X</code> — Chebyshev polynomial of the first kind T_n(x). Recurrence T_{n+1} = 2x T_n - T_{n-1}.</p>
<pre><code class="lang-perl">p chebyshev_t(3, 0.5) # -0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-chebyshev-u">
<h3><a class="doc-anchor" href="#doc-chebyshev-u">#</a> <code>chebyshev_u</code></h3>
<p><code>chebyshev_u N, X</code> — Chebyshev polynomial of the second kind U_n(x).</p>
</article>
<article class="doc-entry" id="doc-spherical-harmonic-y">
<h3><a class="doc-anchor" href="#doc-spherical-harmonic-y">#</a> <code>spherical_harmonic_y</code></h3>
<p><code>spherical_harmonic_y L, M, THETA, PHI</code> — Spherical harmonic Y_l^m(θ, φ) returned as <code>[Re, Im]</code>.</p>
</article>
<article class="doc-entry" id="doc-zernike-r">
<h3><a class="doc-anchor" href="#doc-zernike-r">#</a> <code>zernike_r</code></h3>
<p><code>zernike_r N, M, R</code> — Radial Zernike polynomial R_n^m(r). 0 if (n − m) is odd or m > n.</p>
</article>
</section>
<section class="tutorial-section" id="ch-elliptic-integrals-functions">
<h2>Elliptic Integrals & Functions</h2>
<p class="chapter-meta">18 topics</p>
<article class="doc-entry" id="doc-elliptic-k">
<h3><a class="doc-anchor" href="#doc-elliptic-k">#</a> <code>elliptic_k</code></h3>
<p><code>elliptic_k M</code> — Complete elliptic integral K(m), m = k². Computed via Carlson R_F.</p>
<pre><code class="lang-perl">p elliptic_k(0) # π/2
p elliptic_k(0.5) # ≈ 1.8541
</code></pre>
</article>
<article class="doc-entry" id="doc-elliptic-e">
<h3><a class="doc-anchor" href="#doc-elliptic-e">#</a> <code>elliptic_e</code></h3>
<p><code>elliptic_e M</code> — Complete elliptic integral of the second kind E(m).</p>
</article>
<article class="doc-entry" id="doc-elliptic-pi">
<h3><a class="doc-anchor" href="#doc-elliptic-pi">#</a> <code>elliptic_pi</code></h3>
<p><code>elliptic_pi N, M</code> — Complete elliptic integral of the third kind Π(n | m).</p>
</article>
<article class="doc-entry" id="doc-elliptic-f">
<h3><a class="doc-anchor" href="#doc-elliptic-f">#</a> <code>elliptic_f</code></h3>
<p><code>elliptic_f PHI, M</code> — Incomplete F(φ, m).</p>
</article>
<article class="doc-entry" id="doc-elliptic-e-inc">
<h3><a class="doc-anchor" href="#doc-elliptic-e-inc">#</a> <code>elliptic_e_inc</code></h3>
<p><code>elliptic_e_inc PHI, M</code> — Incomplete E(φ, m).</p>
</article>
<article class="doc-entry" id="doc-elliptic-pi-inc">
<h3><a class="doc-anchor" href="#doc-elliptic-pi-inc">#</a> <code>elliptic_pi_inc</code></h3>
<p><code>elliptic_pi_inc N, PHI, M</code> — Incomplete Π(n; φ | m).</p>
</article>
<article class="doc-entry" id="doc-carlson-rf">
<h3><a class="doc-anchor" href="#doc-carlson-rf">#</a> <code>carlson_rf</code></h3>
<p><code>carlson_rf X, Y, Z</code> — Carlson symmetric form R_F. Building block for the elliptic family.</p>
</article>
<article class="doc-entry" id="doc-carlson-rd">
<h3><a class="doc-anchor" href="#doc-carlson-rd">#</a> <code>carlson_rd</code></h3>
<p><code>carlson_rd X, Y, Z</code> — Carlson R_D.</p>
</article>
<article class="doc-entry" id="doc-carlson-rj">
<h3><a class="doc-anchor" href="#doc-carlson-rj">#</a> <code>carlson_rj</code></h3>
<p><code>carlson_rj X, Y, Z, P</code> — Carlson R_J.</p>
</article>
<article class="doc-entry" id="doc-jacobi-sn">
<h3><a class="doc-anchor" href="#doc-jacobi-sn">#</a> <code>jacobi_sn</code></h3>
<p><code>jacobi_sn U, M</code> — Jacobi elliptic sn(u, m). Reduces to sin(u) at m = 0 and tanh(u) at m = 1.</p>
<pre><code class="lang-perl">p jacobi_sn(1, 0.5) # ≈ 0.8030
</code></pre>
</article>
<article class="doc-entry" id="doc-jacobi-cn">
<h3><a class="doc-anchor" href="#doc-jacobi-cn">#</a> <code>jacobi_cn</code></h3>
<p><code>jacobi_cn U, M</code> — Jacobi elliptic cn(u, m). Reduces to cos(u) at m = 0.</p>
</article>
<article class="doc-entry" id="doc-jacobi-dn">
<h3><a class="doc-anchor" href="#doc-jacobi-dn">#</a> <code>jacobi_dn</code></h3>
<p><code>jacobi_dn U, M</code> — Jacobi elliptic dn(u, m). Reduces to 1 at m = 0.</p>
</article>
<article class="doc-entry" id="doc-jacobi-am">
<h3><a class="doc-anchor" href="#doc-jacobi-am">#</a> <code>jacobi_am</code></h3>
<p><code>jacobi_am U, M</code> — Jacobi amplitude φ such that sn(u, m) = sin(φ).</p>
</article>
<article class="doc-entry" id="doc-elliptic-theta">
<h3><a class="doc-anchor" href="#doc-elliptic-theta">#</a> <code>elliptic_theta</code></h3>
<p><code>elliptic_theta J, Z, Q</code> — Jacobi theta θ_j(z, q) for j ∈ {1, 2, 3, 4}, |q| < 1.</p>
</article>
<article class="doc-entry" id="doc-weierstrass-p">
<h3><a class="doc-anchor" href="#doc-weierstrass-p">#</a> <code>weierstrass_p</code></h3>
<p><code>weierstrass_p Z, G2, G3</code> — Weierstrass ℘(z; g₂, g₃) via Laurent series. Pole at z = 0.</p>
</article>
<article class="doc-entry" id="doc-weierstrass-zeta">
<h3><a class="doc-anchor" href="#doc-weierstrass-zeta">#</a> <code>weierstrass_zeta</code></h3>
<p><code>weierstrass_zeta Z, G2, G3</code> — Weierstrass ζ(z; g₂, g₃).</p>
</article>
<article class="doc-entry" id="doc-weierstrass-sigma">
<h3><a class="doc-anchor" href="#doc-weierstrass-sigma">#</a> <code>weierstrass_sigma</code></h3>
<p><code>weierstrass_sigma Z, G2, G3</code> — Weierstrass σ(z; g₂, g₃).</p>
</article>
<article class="doc-entry" id="doc-inverse-jacobi-sn">
<h3><a class="doc-anchor" href="#doc-inverse-jacobi-sn">#</a> <code>inverse_jacobi_sn</code></h3>
<p><code>inverse_jacobi_sn X, M</code> — inverse of <code>jacobi_sn</code>: returns u with sn(u, m) = x.</p>
</article>
</section>
<section class="tutorial-section" id="ch-zeta-polylog-lerch">
<h2>Zeta / Polylog / Lerch</h2>
<p class="chapter-meta">9 topics</p>
<article class="doc-entry" id="doc-zeta">
<h3><a class="doc-anchor" href="#doc-zeta">#</a> <code>zeta</code></h3>
<p><code>zeta S</code> — Riemann ζ(s) via Euler-Maclaurin (s > 0.5) or reflection identity.</p>
<pre><code class="lang-perl">p zeta(2) # π²/6 ≈ 1.6449
p zeta(4) # ≈ 1.0823
p zeta(-1) # -1/12
</code></pre>
</article>
<article class="doc-entry" id="doc-hurwitz-zeta">
<h3><a class="doc-anchor" href="#doc-hurwitz-zeta">#</a> <code>hurwitz_zeta</code></h3>
<p><code>hurwitz_zeta S, A</code> — Hurwitz ζ(s, a). <code>hurwitz_zeta(s, 1)</code> ≡ <code>zeta(s)</code>.</p>
</article>
<article class="doc-entry" id="doc-polylog">
<h3><a class="doc-anchor" href="#doc-polylog">#</a> <code>polylog</code></h3>
<p><code>polylog N, Z</code> — Polylogarithm Li_n(z) = Σ z^k / k^n for |z| ≤ 1.</p>
<pre><code class="lang-perl">p polylog(2, 1) # π²/6
</code></pre>
</article>
<article class="doc-entry" id="doc-dilog">
<h3><a class="doc-anchor" href="#doc-dilog">#</a> <code>dilog</code></h3>
<p><code>dilog Z</code> — Dilogarithm Li_2(z). Convenience alias for <code>polylog(2, z)</code>.</p>
</article>
<article class="doc-entry" id="doc-lerch-phi">
<h3><a class="doc-anchor" href="#doc-lerch-phi">#</a> <code>lerch_phi</code></h3>
<p><code>lerch_phi Z, S, A</code> — Lerch transcendent Φ(z, s, a) = Σ z^k / (a+k)^s.</p>
</article>
<article class="doc-entry" id="doc-riemann-siegel-z">
<h3><a class="doc-anchor" href="#doc-riemann-siegel-z">#</a> <code>riemann_siegel_z</code></h3>
<p><code>riemann_siegel_z T</code> — Riemann-Siegel Z(t) on the critical line.</p>
</article>
<article class="doc-entry" id="doc-riemann-siegel-theta">
<h3><a class="doc-anchor" href="#doc-riemann-siegel-theta">#</a> <code>riemann_siegel_theta</code></h3>
<p><code>riemann_siegel_theta T</code> — Riemann-Siegel θ(t) (asymptotic Stirling form).</p>
</article>
<article class="doc-entry" id="doc-dirichlet-eta">
<h3><a class="doc-anchor" href="#doc-dirichlet-eta">#</a> <code>dirichlet_eta</code></h3>
<p><code>dirichlet_eta S</code> — Dirichlet η(s) = (1 − 2^(1−s)) ζ(s).</p>
</article>
<article class="doc-entry" id="doc-dirichlet-beta">
<h3><a class="doc-anchor" href="#doc-dirichlet-beta">#</a> <code>dirichlet_beta</code></h3>
<p><code>dirichlet_beta S</code> — Dirichlet β(s) = Σ (-1)^k / (2k+1)^s.</p>
<pre><code class="lang-perl">p dirichlet_beta(1) # π/4 (Catalan-like)
p dirichlet_beta(2) # Catalan's constant ≈ 0.9160
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-hypergeometric">
<h2>Hypergeometric</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-hypergeometric-2f1">
<h3><a class="doc-anchor" href="#doc-hypergeometric-2f1">#</a> <code>hypergeometric_2f1</code></h3>
<p><code>hypergeometric_2f1 A, B, C, Z</code> — ₂F₁(a, b; c; z) Gauss hypergeometric. Series convergent for |z| < 1.</p>
<pre><code class="lang-perl">p hypergeometric_2f1(0.5, 0.5, 1, 0.5) # ≈ 1.1803
</code></pre>
</article>
<article class="doc-entry" id="doc-hypergeometric-1f1">
<h3><a class="doc-anchor" href="#doc-hypergeometric-1f1">#</a> <code>hypergeometric_1f1</code></h3>
<p><code>hypergeometric_1f1 A, B, Z</code> — ₁F₁(a; b; z) Kummer / confluent hypergeometric.</p>
</article>
<article class="doc-entry" id="doc-hypergeometric-0f1">
<h3><a class="doc-anchor" href="#doc-hypergeometric-0f1">#</a> <code>hypergeometric_0f1</code></h3>
<p><code>hypergeometric_0f1 B, Z</code> — ₀F₁(; b; z). Related to Bessel: J_ν(x) = (x/2)^ν / Γ(ν+1) · ₀F₁(; ν+1; -x²/4).</p>
</article>
<article class="doc-entry" id="doc-hypergeometric-pfq">
<h3><a class="doc-anchor" href="#doc-hypergeometric-pfq">#</a> <code>hypergeometric_pfq</code></h3>
<p><code>hypergeometric_pfq AS, BS, Z</code> — generalised _pF_q. AS, BS are arrays of upper/lower parameters.</p>
</article>
<article class="doc-entry" id="doc-hypergeometric-u">
<h3><a class="doc-anchor" href="#doc-hypergeometric-u">#</a> <code>hypergeometric_u</code></h3>
<p><code>hypergeometric_u A, B, Z</code> — Tricomi's confluent U(a, b, z).</p>
</article>
</section>
<section class="tutorial-section" id="ch-modular-forms">
<h2>Modular Forms</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-dedekind-eta">
<h3><a class="doc-anchor" href="#doc-dedekind-eta">#</a> <code>dedekind_eta</code></h3>
<p><code>dedekind_eta Y</code> — Dedekind η(iy) on the imaginary axis. Real-valued q-series with q = exp(-2π y).</p>
</article>
<article class="doc-entry" id="doc-klein-j">
<h3><a class="doc-anchor" href="#doc-klein-j">#</a> <code>klein_j</code></h3>
<p><code>klein_j Y</code> — Klein j-invariant j(iy) = E_4³ / Δ.</p>
</article>
<article class="doc-entry" id="doc-modular-lambda">
<h3><a class="doc-anchor" href="#doc-modular-lambda">#</a> <code>modular_lambda</code></h3>
<p><code>modular_lambda Y</code> — Modular λ(iy) = θ_2(0, q)^4 / θ_3(0, q)^4.</p>
</article>
<article class="doc-entry" id="doc-ramanujan-tau">
<h3><a class="doc-anchor" href="#doc-ramanujan-tau">#</a> <code>ramanujan_tau</code></h3>
<p><code>ramanujan_tau N</code> — τ(n), the nth coefficient of Δ(τ) = η(τ)^24. Returns an integer.</p>
<pre><code class="lang-perl">p ramanujan_tau(1) # 1
p ramanujan_tau(2) # -24
p ramanujan_tau(3) # 252
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-si-ci-ei-li-fresnel-integrals">
<h2>Si / Ci / Ei / Li / Fresnel Integrals</h2>
<p class="chapter-meta">9 topics</p>
<article class="doc-entry" id="doc-sin-integral">
<h3><a class="doc-anchor" href="#doc-sin-integral">#</a> <code>sin_integral</code></h3>
<p><code>sin_integral X</code> — Si(x) = ∫₀ˣ sin(t)/t dt. Si(∞) = π/2.</p>
<pre><code class="lang-perl">p sin_integral(1) # ≈ 0.9461
p sin_integral(10) # ≈ 1.6583
</code></pre>
</article>
<article class="doc-entry" id="doc-cos-integral">
<h3><a class="doc-anchor" href="#doc-cos-integral">#</a> <code>cos_integral</code></h3>
<p><code>cos_integral X</code> — Ci(x) = γ + ln(x) + ∫₀ˣ (cos(t)−1)/t dt. NaN for x ≤ 0.</p>
</article>
<article class="doc-entry" id="doc-sinh-integral">
<h3><a class="doc-anchor" href="#doc-sinh-integral">#</a> <code>sinh_integral</code></h3>
<p><code>sinh_integral X</code> — Shi(x) = ∫₀ˣ sinh(t)/t dt.</p>
</article>
<article class="doc-entry" id="doc-cosh-integral">
<h3><a class="doc-anchor" href="#doc-cosh-integral">#</a> <code>cosh_integral</code></h3>
<p><code>cosh_integral X</code> — Chi(x) = γ + ln(x) + ∫₀ˣ (cosh(t)−1)/t dt.</p>
</article>
<article class="doc-entry" id="doc-exp-integral-e">
<h3><a class="doc-anchor" href="#doc-exp-integral-e">#</a> <code>exp_integral_e</code></h3>
<p><code>exp_integral_e N, X</code> — generalised exponential integral E_n(x) = ∫_1^∞ e^{-x t} / t^n dt.</p>
</article>
<article class="doc-entry" id="doc-exp-integral-ei">
<h3><a class="doc-anchor" href="#doc-exp-integral-ei">#</a> <code>exp_integral_ei</code></h3>
<p><code>exp_integral_ei X</code> — Ei(x). For x > 0 uses series + asymptotic split.</p>
</article>
<article class="doc-entry" id="doc-log-integral">
<h3><a class="doc-anchor" href="#doc-log-integral">#</a> <code>log_integral</code></h3>
<p><code>log_integral X</code> — li(x) = Ei(ln x). Approximates the prime-counting function near <code>prime_pi</code>.</p>
<pre><code class="lang-perl">p log_integral(1000) # ≈ 178
</code></pre>
</article>
<article class="doc-entry" id="doc-fresnel-s">
<h3><a class="doc-anchor" href="#doc-fresnel-s">#</a> <code>fresnel_s</code></h3>
<p><code>fresnel_s X</code> — Fresnel S(x) = ∫₀ˣ sin(π t² / 2) dt.</p>
</article>
<article class="doc-entry" id="doc-fresnel-c">
<h3><a class="doc-anchor" href="#doc-fresnel-c">#</a> <code>fresnel_c</code></h3>
<p><code>fresnel_c X</code> — Fresnel C(x) = ∫₀ˣ cos(π t² / 2) dt.</p>
</article>
</section>
<section class="tutorial-section" id="ch-number-theory-wolfram-parity">
<h2>Number Theory (Wolfram Parity)</h2>
<p class="chapter-meta">13 topics</p>
<article class="doc-entry" id="doc-jacobi-symbol">
<h3><a class="doc-anchor" href="#doc-jacobi-symbol">#</a> <code>jacobi_symbol</code></h3>
<p><code>jacobi_symbol A, N</code> — Jacobi symbol (a/n) for positive odd n. Returns -1, 0, or 1.</p>
<pre><code class="lang-perl">p jacobi_symbol(2, 7) # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-kronecker-symbol">
<h3><a class="doc-anchor" href="#doc-kronecker-symbol">#</a> <code>kronecker_symbol</code></h3>
<p><code>kronecker_symbol A, N</code> — Extension of the Jacobi symbol to all integers n.</p>
</article>
<article class="doc-entry" id="doc-primitive-root">
<h3><a class="doc-anchor" href="#doc-primitive-root">#</a> <code>primitive_root</code></h3>
<p><code>primitive_root P</code> — Smallest primitive root mod p (p prime). <code>undef</code> if none.</p>
</article>
<article class="doc-entry" id="doc-multiplicative-order">
<h3><a class="doc-anchor" href="#doc-multiplicative-order">#</a> <code>multiplicative_order</code></h3>
<p><code>multiplicative_order A, N</code> — smallest k > 0 with a^k ≡ 1 (mod n). <code>undef</code> if gcd(a, n) ≠ 1.</p>
</article>
<article class="doc-entry" id="doc-mangoldt-lambda">
<h3><a class="doc-anchor" href="#doc-mangoldt-lambda">#</a> <code>mangoldt_lambda</code></h3>
<p><code>mangoldt_lambda N</code> — von Mangoldt Λ(n) = ln(p) if n = p^k, else 0.</p>
</article>
<article class="doc-entry" id="doc-carmichael-lambda">
<h3><a class="doc-anchor" href="#doc-carmichael-lambda">#</a> <code>carmichael_lambda</code></h3>
<p><code>carmichael_lambda N</code> — Carmichael λ(n), the exponent of (Z/nZ)*.</p>
<pre><code class="lang-perl">p carmichael_lambda(15) # 4
</code></pre>
</article>
<article class="doc-entry" id="doc-squares-r">
<h3><a class="doc-anchor" href="#doc-squares-r">#</a> <code>squares_r</code></h3>
<p><code>squares_r K, N</code> — number of representations of n as a sum of k squares (signed, ordered).</p>
<pre><code class="lang-perl">p squares_r(2, 5) # 8 (e.g. ±1²+±2²)
</code></pre>
</article>
<article class="doc-entry" id="doc-thue-morse">
<h3><a class="doc-anchor" href="#doc-thue-morse">#</a> <code>thue_morse</code></h3>
<p><code>thue_morse N</code> — Thue-Morse t(n) = popcount(n) mod 2.</p>
</article>
<article class="doc-entry" id="doc-rudin-shapiro">
<h3><a class="doc-anchor" href="#doc-rudin-shapiro">#</a> <code>rudin_shapiro</code></h3>
<p><code>rudin_shapiro N</code> — Rudin-Shapiro sequence, ±1 = (-1)^a(n) where a(n) counts "11" patterns in binary(n).</p>
</article>
<article class="doc-entry" id="doc-farey-sequence">
<h3><a class="doc-anchor" href="#doc-farey-sequence">#</a> <code>farey_sequence</code></h3>
<p><code>farey_sequence N</code> — Farey sequence F_n. Returns array of <code>[a, b]</code> pairs.</p>
<pre><code class="lang-perl">p farey_sequence(3) # [[0,1],[1,3],[1,2],[2,3],[1,1]]
</code></pre>
</article>
<article class="doc-entry" id="doc-frobenius-number">
<h3><a class="doc-anchor" href="#doc-frobenius-number">#</a> <code>frobenius_number</code></h3>
<p><code>frobenius_number COINS</code> — largest amount NOT representable as a non-negative combination of <code>COINS</code>. Closed form for two coprime denominations.</p>
<pre><code class="lang-perl">p frobenius_number([3, 5]) # 7
</code></pre>
</article>
<article class="doc-entry" id="doc-frobenius-solve">
<h3><a class="doc-anchor" href="#doc-frobenius-solve">#</a> <code>frobenius_solve</code></h3>
<p><code>frobenius_solve COINS, N</code> — number of ways to make change for N using <code>COINS</code>.</p>
</article>
<article class="doc-entry" id="doc-stern-brocot">
<h3><a class="doc-anchor" href="#doc-stern-brocot">#</a> <code>stern_brocot</code></h3>
<p><code>stern_brocot N</code> — Stern-Brocot tree node N (1-indexed) as <code>[a, b]</code> (Calkin-Wilf order).</p>
</article>
</section>
<section class="tutorial-section" id="ch-combinatorics-wolfram-parity">
<h2>Combinatorics (Wolfram Parity)</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-stirling-s1">
<h3><a class="doc-anchor" href="#doc-stirling-s1">#</a> <code>stirling_s1</code></h3>
<p><code>stirling_s1 N, K</code> — unsigned Stirling number of the first kind |s(n,k)|.</p>
</article>
<article class="doc-entry" id="doc-bell-polynomial-b">
<h3><a class="doc-anchor" href="#doc-bell-polynomial-b">#</a> <code>bell_polynomial_b</code></h3>
<p><code>bell_polynomial_b N, K, XS</code> — partial Bell polynomial B_{n,k}(x_1, …, x_{n-k+1}).</p>
</article>
<article class="doc-entry" id="doc-clebsch-gordan">
<h3><a class="doc-anchor" href="#doc-clebsch-gordan">#</a> <code>clebsch_gordan</code></h3>
<p><code>clebsch_gordan J1, J2, J, M1, M2 [, M]</code> — Clebsch-Gordan coefficient. M defaults to M1 + M2.</p>
</article>
<article class="doc-entry" id="doc-three-j-symbol">
<h3><a class="doc-anchor" href="#doc-three-j-symbol">#</a> <code>three_j_symbol</code></h3>
<p><code>three_j_symbol J1, J2, J3, M1, M2, M3</code> — Wigner 3-j symbol.</p>
</article>
<article class="doc-entry" id="doc-six-j-symbol">
<h3><a class="doc-anchor" href="#doc-six-j-symbol">#</a> <code>six_j_symbol</code></h3>
<p><code>six_j_symbol J1 J2 J3 J4 J5 J6</code> — Wigner 6-j symbol.</p>
</article>
<article class="doc-entry" id="doc-nine-j-symbol">
<h3><a class="doc-anchor" href="#doc-nine-j-symbol">#</a> <code>nine_j_symbol</code></h3>
<p><code>nine_j_symbol</code> (9 args) — Wigner 9-j as a single sum over 6-j.</p>
</article>
<article class="doc-entry" id="doc-debruijn-sequence">
<h3><a class="doc-anchor" href="#doc-debruijn-sequence">#</a> <code>debruijn_sequence</code></h3>
<p><code>debruijn_sequence K, N</code> — De Bruijn B(k, n) as an array of k^n integers.</p>
</article>
<article class="doc-entry" id="doc-wigner-d">
<h3><a class="doc-anchor" href="#doc-wigner-d">#</a> <code>wigner_d</code></h3>
<p><code>wigner_d J, M1, M2, BETA</code> — small Wigner d-matrix d^j_{m1, m2}(β).</p>
</article>
</section>
<section class="tutorial-section" id="ch-q-series-mittag-leffler-coulomb">
<h2>q-Series, Mittag-Leffler, Coulomb</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-q-pochhammer">
<h3><a class="doc-anchor" href="#doc-q-pochhammer">#</a> <code>q_pochhammer</code></h3>
<p><code>q_pochhammer A, Q [, N]</code> — (a; q)_n. Omit N for the infinite product (|q| < 1).</p>
</article>
<article class="doc-entry" id="doc-q-factorial">
<h3><a class="doc-anchor" href="#doc-q-factorial">#</a> <code>q_factorial</code></h3>
<p><code>q_factorial N, Q</code> — q-factorial [n]_q!.</p>
</article>
<article class="doc-entry" id="doc-q-binomial">
<h3><a class="doc-anchor" href="#doc-q-binomial">#</a> <code>q_binomial</code></h3>
<p><code>q_binomial N, K, Q</code> — Gaussian binomial [n choose k]_q.</p>
</article>
<article class="doc-entry" id="doc-q-hypergeometric-pfq">
<h3><a class="doc-anchor" href="#doc-q-hypergeometric-pfq">#</a> <code>q_hypergeometric_pfq</code></h3>
<p><code>q_hypergeometric_pfq AS, BS, Q, Z</code> — basic-hypergeometric series.</p>
</article>
<article class="doc-entry" id="doc-mittag-leffler-e">
<h3><a class="doc-anchor" href="#doc-mittag-leffler-e">#</a> <code>mittag_leffler_e</code></h3>
<p><code>mittag_leffler_e ALPHA, BETA, Z</code> — E_{α,β}(z) = Σ z^k / Γ(α k + β). Generalises exp / cosh / Mittag-Leffler.</p>
</article>
<article class="doc-entry" id="doc-coulomb-wave-f">
<h3><a class="doc-anchor" href="#doc-coulomb-wave-f">#</a> <code>coulomb_wave_f</code></h3>
<p><code>coulomb_wave_f L, ETA, RHO</code> — regular Coulomb wave F_L(η, ρ) via the confluent-hypergeometric representation.</p>
</article>
<article class="doc-entry" id="doc-coulomb-wave-g">
<h3><a class="doc-anchor" href="#doc-coulomb-wave-g">#</a> <code>coulomb_wave_g</code></h3>
<p><code>coulomb_wave_g L, ETA, RHO</code> — irregular partner G_L. Currently returns NaN; faithful Bardin/Goesnig port pending.</p>
</article>
</section>
<section class="tutorial-section" id="ch-inverse-special-functions">
<h2>Inverse Special Functions</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-inverse-erf">
<h3><a class="doc-anchor" href="#doc-inverse-erf">#</a> <code>inverse_erf</code></h3>
<p><code>inverse_erf Y</code> — inverse error function. Solves erf(x) = y.</p>
<pre><code class="lang-perl">p inverse_erf(0.5) # ≈ 0.4769
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-erfc">
<h3><a class="doc-anchor" href="#doc-inverse-erfc">#</a> <code>inverse_erfc</code></h3>
<p><code>inverse_erfc Y</code> — inverse complementary error function.</p>
</article>
<article class="doc-entry" id="doc-inverse-gamma-regularized">
<h3><a class="doc-anchor" href="#doc-inverse-gamma-regularized">#</a> <code>inverse_gamma_regularized</code></h3>
<p><code>inverse_gamma_regularized A, Y</code> — solves P(a, x) = y for x.</p>
</article>
<article class="doc-entry" id="doc-inverse-beta-regularized">
<h3><a class="doc-anchor" href="#doc-inverse-beta-regularized">#</a> <code>inverse_beta_regularized</code></h3>
<p><code>inverse_beta_regularized A, B, Y</code> — solves I_x(a, b) = y for x via bisection.</p>
</article>
</section>
<section class="tutorial-section" id="ch-piecewise-symbolic-primitives">
<h2>Piecewise & Symbolic Primitives</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-dirac-delta">
<h3><a class="doc-anchor" href="#doc-dirac-delta">#</a> <code>dirac_delta</code></h3>
<p><code>dirac_delta X [, EPS]</code> — finite-width discrete approximation: 1/eps if |x| < eps/2 else 0. EPS defaults to 1e-3.</p>
</article>
<article class="doc-entry" id="doc-heaviside-theta">
<h3><a class="doc-anchor" href="#doc-heaviside-theta">#</a> <code>heaviside_theta</code></h3>
<p><code>heaviside_theta X</code> — Heaviside step function: 1 (x > 0), 0 (x < 0), 0.5 (x = 0).</p>
</article>
<article class="doc-entry" id="doc-unit-box">
<h3><a class="doc-anchor" href="#doc-unit-box">#</a> <code>unit_box</code></h3>
<p><code>unit_box X</code> — 1 if |x| ≤ 1/2 else 0.</p>
</article>
<article class="doc-entry" id="doc-unit-triangle">
<h3><a class="doc-anchor" href="#doc-unit-triangle">#</a> <code>unit_triangle</code></h3>
<p><code>unit_triangle X</code> — max(1 − |x|, 0).</p>
</article>
<article class="doc-entry" id="doc-square-wave">
<h3><a class="doc-anchor" href="#doc-square-wave">#</a> <code>square_wave</code></h3>
<p><code>square_wave X [, PERIOD]</code> — alternates +1/-1 with the given period (default 1).</p>
</article>
<article class="doc-entry" id="doc-triangle-wave">
<h3><a class="doc-anchor" href="#doc-triangle-wave">#</a> <code>triangle_wave</code></h3>
<p><code>triangle_wave X [, PERIOD]</code> — periodic triangle wave on [-1, 1].</p>
</article>
<article class="doc-entry" id="doc-sawtooth-wave">
<h3><a class="doc-anchor" href="#doc-sawtooth-wave">#</a> <code>sawtooth_wave</code></h3>
<p><code>sawtooth_wave X [, PERIOD]</code> — periodic sawtooth on [-1, 1].</p>
</article>
<article class="doc-entry" id="doc-dirac-comb">
<h3><a class="doc-anchor" href="#doc-dirac-comb">#</a> <code>dirac_comb</code></h3>
<p><code>dirac_comb X, T [, EPS]</code> — sum of Dirac deltas at multiples of T (discrete approximation).</p>
</article>
</section>
<section class="tutorial-section" id="ch-number-theory-wolfram-parity-ii">
<h2>Number Theory (Wolfram Parity II)</h2>
<p class="chapter-meta">14 topics</p>
<article class="doc-entry" id="doc-liouville-lambda">
<h3><a class="doc-anchor" href="#doc-liouville-lambda">#</a> <code>liouville_lambda</code></h3>
<p><code>liouville_lambda N</code> — Liouville λ(n) = (-1)^Ω(n).</p>
</article>
<article class="doc-entry" id="doc-jordan-totient">
<h3><a class="doc-anchor" href="#doc-jordan-totient">#</a> <code>jordan_totient</code></h3>
<p><code>jordan_totient K, N</code> — Jordan totient J_k(n) = n^k Π_{p | n} (1 - p^{-k}).</p>
</article>
<article class="doc-entry" id="doc-ramanujan-sum">
<h3><a class="doc-anchor" href="#doc-ramanujan-sum">#</a> <code>ramanujan_sum</code></h3>
<p><code>ramanujan_sum Q, N</code> — c_q(n) = Σ_{d | gcd(q,n)} μ(q/d) d.</p>
</article>
<article class="doc-entry" id="doc-cyclotomic-polynomial">
<h3><a class="doc-anchor" href="#doc-cyclotomic-polynomial">#</a> <code>cyclotomic_polynomial</code></h3>
<p><code>cyclotomic_polynomial N</code> — coefficient list of Φ_n(x).</p>
<pre><code class="lang-perl">p cyclotomic_polynomial(6) # [1, -1, 1] = x²-x+1
</code></pre>
</article>
<article class="doc-entry" id="doc-legendre-symbol">
<h3><a class="doc-anchor" href="#doc-legendre-symbol">#</a> <code>legendre_symbol</code></h3>
<p><code>legendre_symbol A, P</code> — Legendre symbol (a/p) for prime p. -1, 0, or 1.</p>
</article>
<article class="doc-entry" id="doc-pythagorean-triple-q">
<h3><a class="doc-anchor" href="#doc-pythagorean-triple-q">#</a> <code>pythagorean_triple_q</code></h3>
<p><code>pythagorean_triple_q A, B, C</code> — 1 if a² + b² = c² (any order/sign).</p>
</article>
<article class="doc-entry" id="doc-gen-pythagorean-triple">
<h3><a class="doc-anchor" href="#doc-gen-pythagorean-triple">#</a> <code>gen_pythagorean_triple</code></h3>
<p><code>gen_pythagorean_triple M, N</code> — Euclid formula: returns [m²-n², 2mn, m²+n²].</p>
</article>
<article class="doc-entry" id="doc-sophie-germain-q">
<h3><a class="doc-anchor" href="#doc-sophie-germain-q">#</a> <code>sophie_germain_q</code></h3>
<p><code>sophie_germain_q P</code> — 1 if both p and 2p+1 are prime.</p>
</article>
<article class="doc-entry" id="doc-mersenne-q">
<h3><a class="doc-anchor" href="#doc-mersenne-q">#</a> <code>mersenne_q</code></h3>
<p><code>mersenne_q N</code> — 1 if 2^n - 1 is a Mersenne prime (Lucas-Lehmer).</p>
</article>
<article class="doc-entry" id="doc-lucas-lehmer-test">
<h3><a class="doc-anchor" href="#doc-lucas-lehmer-test">#</a> <code>lucas_lehmer_test</code></h3>
<p><code>lucas_lehmer_test P</code> — Lucas-Lehmer primality test for 2^p - 1.</p>
</article>
<article class="doc-entry" id="doc-continued-fraction">
<h3><a class="doc-anchor" href="#doc-continued-fraction">#</a> <code>continued_fraction</code></h3>
<p><code>continued_fraction X [, N]</code> — first N coefficients of the simple continued-fraction expansion. N defaults to 12.</p>
</article>
<article class="doc-entry" id="doc-from-continued-fraction">
<h3><a class="doc-anchor" href="#doc-from-continued-fraction">#</a> <code>from_continued_fraction</code></h3>
<p><code>from_continued_fraction COEFFS</code> — evaluate [a0; a1, a2, …] back to a real number.</p>
</article>
<article class="doc-entry" id="doc-convergents">
<h3><a class="doc-anchor" href="#doc-convergents">#</a> <code>convergents</code></h3>
<p><code>convergents X [, N]</code> — N successive [num, denom] convergents.</p>
</article>
<article class="doc-entry" id="doc-best-rational-approximation">
<h3><a class="doc-anchor" href="#doc-best-rational-approximation">#</a> <code>best_rational_approximation</code></h3>
<p><code>best_rational_approximation X, MAX_DENOM</code> — closest fraction p/q with q ≤ MAX_DENOM. Returns [p, q].</p>
</article>
</section>
<section class="tutorial-section" id="ch-combinatorial-sequences">
<h2>Combinatorial Sequences</h2>
<p class="chapter-meta">12 topics</p>
<article class="doc-entry" id="doc-motzkin-number">
<h3><a class="doc-anchor" href="#doc-motzkin-number">#</a> <code>motzkin_number</code></h3>
<p><code>motzkin_number N</code> — # paths on (0..n) using → ↗ ↘ steps (no crossings).</p>
</article>
<article class="doc-entry" id="doc-narayana-number">
<h3><a class="doc-anchor" href="#doc-narayana-number">#</a> <code>narayana_number</code></h3>
<p><code>narayana_number N, K</code> — N(n, k) = (1/n) C(n,k) C(n,k-1).</p>
</article>
<article class="doc-entry" id="doc-delannoy-number">
<h3><a class="doc-anchor" href="#doc-delannoy-number">#</a> <code>delannoy_number</code></h3>
<p><code>delannoy_number M, N</code> — # paths in (m+1)×(n+1) grid using → ↑ ↗.</p>
</article>
<article class="doc-entry" id="doc-schroder-number">
<h3><a class="doc-anchor" href="#doc-schroder-number">#</a> <code>schroder_number</code></h3>
<p><code>schroder_number N</code> — large Schröder number.</p>
</article>
<article class="doc-entry" id="doc-small-schroder-number">
<h3><a class="doc-anchor" href="#doc-small-schroder-number">#</a> <code>small_schroder_number</code></h3>
<p><code>small_schroder_number N</code> — small Schröder s_n = S_n / 2 (n ≥ 1).</p>
</article>
<article class="doc-entry" id="doc-eulerian-number">
<h3><a class="doc-anchor" href="#doc-eulerian-number">#</a> <code>eulerian_number</code></h3>
<p><code>eulerian_number N, K</code> — ⟨n k⟩, # permutations of [n] with k ascents.</p>
</article>
<article class="doc-entry" id="doc-bernoulli-polynomial">
<h3><a class="doc-anchor" href="#doc-bernoulli-polynomial">#</a> <code>bernoulli_polynomial</code></h3>
<p><code>bernoulli_polynomial N, X</code> — B_n(x).</p>
</article>
<article class="doc-entry" id="doc-euler-polynomial">
<h3><a class="doc-anchor" href="#doc-euler-polynomial">#</a> <code>euler_polynomial</code></h3>
<p><code>euler_polynomial N, X</code> — E_n(x).</p>
</article>
<article class="doc-entry" id="doc-pell-number">
<h3><a class="doc-anchor" href="#doc-pell-number">#</a> <code>pell_number</code></h3>
<p><code>pell_number N</code> — Pell number P_n.</p>
</article>
<article class="doc-entry" id="doc-pell-lucas-number">
<h3><a class="doc-anchor" href="#doc-pell-lucas-number">#</a> <code>pell_lucas_number</code></h3>
<p><code>pell_lucas_number N</code> — companion Pell-Lucas Q_n.</p>
</article>
<article class="doc-entry" id="doc-perrin-number">
<h3><a class="doc-anchor" href="#doc-perrin-number">#</a> <code>perrin_number</code></h3>
<p><code>perrin_number N</code> — Perrin sequence P(n) = P(n-2) + P(n-3).</p>
</article>
<article class="doc-entry" id="doc-padovan-number">
<h3><a class="doc-anchor" href="#doc-padovan-number">#</a> <code>padovan_number</code></h3>
<p><code>padovan_number N</code> — Padovan sequence (same recurrence, different seeds).</p>
</article>
</section>
<section class="tutorial-section" id="ch-linear-algebra-extended">
<h2>Linear Algebra (Extended)</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-kronecker-product">
<h3><a class="doc-anchor" href="#doc-kronecker-product">#</a> <code>kronecker_product</code></h3>
<p><code>kronecker_product A, B</code> — A ⊗ B (block-by-block outer product).</p>
</article>
<article class="doc-entry" id="doc-tensor-product">
<h3><a class="doc-anchor" href="#doc-tensor-product">#</a> <code>tensor_product</code></h3>
<p><code>tensor_product A, B</code> — outer product of two flat vectors → matrix A_i B_j.</p>
</article>
<article class="doc-entry" id="doc-tensor-contract">
<h3><a class="doc-anchor" href="#doc-tensor-contract">#</a> <code>tensor_contract</code></h3>
<p><code>tensor_contract A, B</code> — Frobenius inner product of two matrices.</p>
</article>
<article class="doc-entry" id="doc-matrix-rank">
<h3><a class="doc-anchor" href="#doc-matrix-rank">#</a> <code>matrix_rank</code></h3>
<p><code>matrix_rank A</code> — rank via Gaussian elimination with partial pivoting.</p>
</article>
<article class="doc-entry" id="doc-companion-matrix">
<h3><a class="doc-anchor" href="#doc-companion-matrix">#</a> <code>companion_matrix</code></h3>
<p><code>companion_matrix [a0, a1, …, a_{n-1}]</code> — companion of x^n + a_{n-1} x^{n-1} + … + a_0.</p>
</article>
<article class="doc-entry" id="doc-characteristic-polynomial">
<h3><a class="doc-anchor" href="#doc-characteristic-polynomial">#</a> <code>characteristic_polynomial</code></h3>
<p><code>characteristic_polynomial A</code> — coefficients [a_0, …, a_n] of det(xI − A) via Faddeev-LeVerrier.</p>
</article>
<article class="doc-entry" id="doc-singular-values">
<h3><a class="doc-anchor" href="#doc-singular-values">#</a> <code>singular_values</code></h3>
<p><code>singular_values A</code> — sorted SVDs of A (eigenvalues of A^T A, square-rooted).</p>
</article>
<article class="doc-entry" id="doc-nullspace">
<h3><a class="doc-anchor" href="#doc-nullspace">#</a> <code>nullspace</code></h3>
<p><code>nullspace A</code> — basis vectors of A's null space (zero singular values of A^T A).</p>
</article>
</section>
<section class="tutorial-section" id="ch-polynomial-algebra">
<h2>Polynomial Algebra</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-polynomial-gcd">
<h3><a class="doc-anchor" href="#doc-polynomial-gcd">#</a> <code>polynomial_gcd</code></h3>
<p><code>polynomial_gcd P, Q</code> — Euclidean GCD over real coefficients (monic).</p>
<pre><code class="lang-perl">p polygcd([-1, 0, 1], [-1, 1]) # x - 1
</code></pre>
</article>
<article class="doc-entry" id="doc-polynomial-quotient">
<h3><a class="doc-anchor" href="#doc-polynomial-quotient">#</a> <code>polynomial_quotient</code></h3>
<p><code>polynomial_quotient P, Q</code> — quotient of synthetic division.</p>
</article>
<article class="doc-entry" id="doc-polynomial-remainder">
<h3><a class="doc-anchor" href="#doc-polynomial-remainder">#</a> <code>polynomial_remainder</code></h3>
<p><code>polynomial_remainder P, Q</code> — remainder of synthetic division.</p>
</article>
<article class="doc-entry" id="doc-polynomial-resultant">
<h3><a class="doc-anchor" href="#doc-polynomial-resultant">#</a> <code>polynomial_resultant</code></h3>
<p><code>polynomial_resultant P, Q</code> — Sylvester-matrix determinant.</p>
</article>
<article class="doc-entry" id="doc-polynomial-discriminant">
<h3><a class="doc-anchor" href="#doc-polynomial-discriminant">#</a> <code>polynomial_discriminant</code></h3>
<p><code>polynomial_discriminant P</code> — disc(p) = (-1)^{n(n-1)/2} / a_n · res(p, p').</p>
</article>
<article class="doc-entry" id="doc-polynomial-roots">
<h3><a class="doc-anchor" href="#doc-polynomial-roots">#</a> <code>polynomial_roots</code></h3>
<p><code>polynomial_roots P</code> — real roots via deflation power iteration on companion matrix.</p>
</article>
</section>
<section class="tutorial-section" id="ch-distributions-extended">
<h2>Distributions (Extended)</h2>
<p class="chapter-meta">18 topics</p>
<article class="doc-entry" id="doc-gumbel-pdf">
<h3><a class="doc-anchor" href="#doc-gumbel-pdf">#</a> <code>gumbel_pdf</code></h3>
<p><code>gumbel_pdf X, MU, BETA</code> — Gumbel (Type I) extreme-value PDF.</p>
</article>
<article class="doc-entry" id="doc-gumbel-cdf">
<h3><a class="doc-anchor" href="#doc-gumbel-cdf">#</a> <code>gumbel_cdf</code></h3>
<p><code>gumbel_cdf X, MU, BETA</code> — Gumbel CDF.</p>
</article>
<article class="doc-entry" id="doc-gumbel-quantile">
<h3><a class="doc-anchor" href="#doc-gumbel-quantile">#</a> <code>gumbel_quantile</code></h3>
<p><code>gumbel_quantile P, MU, BETA</code> — Gumbel quantile.</p>
</article>
<article class="doc-entry" id="doc-frechet-pdf">
<h3><a class="doc-anchor" href="#doc-frechet-pdf">#</a> <code>frechet_pdf</code></h3>
<p><code>frechet_pdf X, ALPHA, S</code> — Fréchet (Type II) PDF.</p>
</article>
<article class="doc-entry" id="doc-frechet-cdf">
<h3><a class="doc-anchor" href="#doc-frechet-cdf">#</a> <code>frechet_cdf</code></h3>
<p><code>frechet_cdf X, ALPHA, S</code> — Fréchet CDF.</p>
</article>
<article class="doc-entry" id="doc-frechet-quantile">
<h3><a class="doc-anchor" href="#doc-frechet-quantile">#</a> <code>frechet_quantile</code></h3>
<p><code>frechet_quantile P, ALPHA, S</code> — Fréchet quantile.</p>
</article>
<article class="doc-entry" id="doc-logistic-pdf">
<h3><a class="doc-anchor" href="#doc-logistic-pdf">#</a> <code>logistic_pdf</code></h3>
<p><code>logistic_pdf X, MU, S</code> — Logistic PDF.</p>
</article>
<article class="doc-entry" id="doc-logistic-cdf">
<h3><a class="doc-anchor" href="#doc-logistic-cdf">#</a> <code>logistic_cdf</code></h3>
<p><code>logistic_cdf X, MU, S</code> — Logistic CDF.</p>
</article>
<article class="doc-entry" id="doc-logistic-quantile">
<h3><a class="doc-anchor" href="#doc-logistic-quantile">#</a> <code>logistic_quantile</code></h3>
<p><code>logistic_quantile P, MU, S</code> — Logistic quantile.</p>
</article>
<article class="doc-entry" id="doc-rayleigh-pdf">
<h3><a class="doc-anchor" href="#doc-rayleigh-pdf">#</a> <code>rayleigh_pdf</code></h3>
<p><code>rayleigh_pdf X, SIGMA</code> — Rayleigh PDF (x ≥ 0).</p>
</article>
<article class="doc-entry" id="doc-rayleigh-cdf">
<h3><a class="doc-anchor" href="#doc-rayleigh-cdf">#</a> <code>rayleigh_cdf</code></h3>
<p><code>rayleigh_cdf X, SIGMA</code> — Rayleigh CDF.</p>
</article>
<article class="doc-entry" id="doc-rayleigh-quantile">
<h3><a class="doc-anchor" href="#doc-rayleigh-quantile">#</a> <code>rayleigh_quantile</code></h3>
<p><code>rayleigh_quantile P, SIGMA</code> — Rayleigh quantile.</p>
</article>
<article class="doc-entry" id="doc-inverse-gamma-pdf">
<h3><a class="doc-anchor" href="#doc-inverse-gamma-pdf">#</a> <code>inverse_gamma_pdf</code></h3>
<p><code>inverse_gamma_pdf X, ALPHA, BETA</code> — inverse-gamma PDF.</p>
</article>
<article class="doc-entry" id="doc-inverse-gamma-cdf">
<h3><a class="doc-anchor" href="#doc-inverse-gamma-cdf">#</a> <code>inverse_gamma_cdf</code></h3>
<p><code>inverse_gamma_cdf X, ALPHA, BETA</code> — inverse-gamma CDF.</p>
</article>
<article class="doc-entry" id="doc-inverse-gamma-quantile">
<h3><a class="doc-anchor" href="#doc-inverse-gamma-quantile">#</a> <code>inverse_gamma_quantile</code></h3>
<p><code>inverse_gamma_quantile P, ALPHA, BETA</code> — inverse-gamma quantile.</p>
</article>
<article class="doc-entry" id="doc-kumaraswamy-pdf">
<h3><a class="doc-anchor" href="#doc-kumaraswamy-pdf">#</a> <code>kumaraswamy_pdf</code></h3>
<p><code>kumaraswamy_pdf X, A, B</code> — Kumaraswamy PDF on (0, 1).</p>
</article>
<article class="doc-entry" id="doc-kumaraswamy-cdf">
<h3><a class="doc-anchor" href="#doc-kumaraswamy-cdf">#</a> <code>kumaraswamy_cdf</code></h3>
<p><code>kumaraswamy_cdf X, A, B</code> — Kumaraswamy CDF.</p>
</article>
<article class="doc-entry" id="doc-kumaraswamy-quantile">
<h3><a class="doc-anchor" href="#doc-kumaraswamy-quantile">#</a> <code>kumaraswamy_quantile</code></h3>
<p><code>kumaraswamy_quantile P, A, B</code> — Kumaraswamy quantile.</p>
</article>
</section>
<section class="tutorial-section" id="ch-mathieu-heun">
<h2>Mathieu / Heun</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-mathieu-a">
<h3><a class="doc-anchor" href="#doc-mathieu-a">#</a> <code>mathieu_a</code></h3>
<p><code>mathieu_a Q, N</code> — Mathieu characteristic value a_n(q) (Hill-matrix eigenvalue).</p>
</article>
<article class="doc-entry" id="doc-mathieu-ce">
<h3><a class="doc-anchor" href="#doc-mathieu-ce">#</a> <code>mathieu_ce</code></h3>
<p><code>mathieu_ce N, X, Q</code> — even Mathieu function ce_n(x, q) (perturbative form for small q).</p>
</article>
<article class="doc-entry" id="doc-mathieu-se">
<h3><a class="doc-anchor" href="#doc-mathieu-se">#</a> <code>mathieu_se</code></h3>
<p><code>mathieu_se N, X, Q</code> — odd Mathieu function se_n(x, q).</p>
</article>
<article class="doc-entry" id="doc-heun-g">
<h3><a class="doc-anchor" href="#doc-heun-g">#</a> <code>heun_g</code></h3>
<p><code>heun_g Z, A, Q, ALPHA, BETA, GAMMA, DELTA</code> — general Heun H_l via Frobenius series. Requires |z| < min(1, |a|).</p>
</article>
</section>
<section class="tutorial-section" id="ch-wavelets">
<h2>Wavelets</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-haar-transform">
<h3><a class="doc-anchor" href="#doc-haar-transform">#</a> <code>haar_transform</code></h3>
<p><code>haar_transform XS</code> — single-level Haar DWT. Returns [approx…, detail…].</p>
</article>
<article class="doc-entry" id="doc-haar-inverse">
<h3><a class="doc-anchor" href="#doc-haar-inverse">#</a> <code>haar_inverse</code></h3>
<p><code>haar_inverse XS</code> — inverse single-level Haar.</p>
</article>
<article class="doc-entry" id="doc-daubechies-db4">
<h3><a class="doc-anchor" href="#doc-daubechies-db4">#</a> <code>daubechies_db4</code></h3>
<p><code>daubechies_db4 XS</code> — single-level Daubechies-4 DWT (length must be even ≥ 4).</p>
</article>
<article class="doc-entry" id="doc-daubechies-db4-inverse">
<h3><a class="doc-anchor" href="#doc-daubechies-db4-inverse">#</a> <code>daubechies_db4_inverse</code></h3>
<p><code>daubechies_db4_inverse XS</code> — inverse single-level db4.</p>
</article>
</section>
<section class="tutorial-section" id="ch-graph-algorithms-extended">
<h2>Graph Algorithms (Extended)</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-topo-sort-adj">
<h3><a class="doc-anchor" href="#doc-topo-sort-adj">#</a> <code>topo_sort_adj</code></h3>
<p><code>topo_sort_adj ADJ</code> — Kahn's algorithm on adjacency-list graph. Returns ordering or <code>[]</code> on cycle. (Edge-list input → use <code>topological_sort</code> instead.)</p>
</article>
<article class="doc-entry" id="doc-scc-tarjan">
<h3><a class="doc-anchor" href="#doc-scc-tarjan">#</a> <code>scc_tarjan</code></h3>
<p><code>scc_tarjan ADJ</code> — Tarjan strongly-connected components. Returns array of components.</p>
</article>
<article class="doc-entry" id="doc-bipartite-q">
<h3><a class="doc-anchor" href="#doc-bipartite-q">#</a> <code>bipartite_q</code></h3>
<p><code>bipartite_q ADJ</code> — 1 if graph is 2-colourable (BFS), 0 otherwise.</p>
</article>
<article class="doc-entry" id="doc-max-flow-edmonds-karp">
<h3><a class="doc-anchor" href="#doc-max-flow-edmonds-karp">#</a> <code>max_flow_edmonds_karp</code></h3>
<p><code>max_flow_edmonds_karp CAP, S, T</code> — max flow on capacity matrix from S to T.</p>
</article>
<article class="doc-entry" id="doc-min-cut">
<h3><a class="doc-anchor" href="#doc-min-cut">#</a> <code>min_cut</code></h3>
<p><code>min_cut CAP, S, T</code> — min-cut value (= max-flow).</p>
</article>
<article class="doc-entry" id="doc-eccentricity">
<h3><a class="doc-anchor" href="#doc-eccentricity">#</a> <code>eccentricity</code></h3>
<p><code>eccentricity ADJ, V</code> — max BFS distance from V (unweighted).</p>
</article>
<article class="doc-entry" id="doc-graph-diameter">
<h3><a class="doc-anchor" href="#doc-graph-diameter">#</a> <code>graph_diameter</code></h3>
<p><code>graph_diameter ADJ</code> — max eccentricity over all vertices.</p>
</article>
<article class="doc-entry" id="doc-graph-radius">
<h3><a class="doc-anchor" href="#doc-graph-radius">#</a> <code>graph_radius</code></h3>
<p><code>graph_radius ADJ</code> — min eccentricity over all vertices.</p>
</article>
</section>
<section class="tutorial-section" id="ch-number-theoretic-sums-constants">
<h2>Number-Theoretic Sums & Constants</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-stieltjes-constant">
<h3><a class="doc-anchor" href="#doc-stieltjes-constant">#</a> <code>stieltjes_constant</code></h3>
<p><code>stieltjes_constant K</code> — kth Stieltjes constant γ_k. γ_0 = γ (Euler-Mascheroni).</p>
</article>
<article class="doc-entry" id="doc-gauss-sum">
<h3><a class="doc-anchor" href="#doc-gauss-sum">#</a> <code>gauss_sum</code></h3>
<p><code>gauss_sum A, P</code> — quadratic Gauss sum G(a, p) as <code>[Re, Im]</code>.</p>
</article>
<article class="doc-entry" id="doc-kloosterman-sum">
<h3><a class="doc-anchor" href="#doc-kloosterman-sum">#</a> <code>kloosterman_sum</code></h3>
<p><code>kloosterman_sum A, B, M</code> — K(a, b; m) as <code>[Re, Im]</code>.</p>
</article>
<article class="doc-entry" id="doc-eta-quotient">
<h3><a class="doc-anchor" href="#doc-eta-quotient">#</a> <code>eta_quotient</code></h3>
<p><code>eta_quotient PAIRS, Y</code> — Π η(d·iy)^{r_d} for [[d, r_d], …].</p>
</article>
<article class="doc-entry" id="doc-root-approximant">
<h3><a class="doc-anchor" href="#doc-root-approximant">#</a> <code>root_approximant</code></h3>
<p><code>root_approximant X [, MAX_DENOM]</code> — best rational approximant (alias for <code>best_rational_approximation</code>).</p>
</article>
</section>
<section class="tutorial-section" id="ch-vector-calculus">
<h2>Vector Calculus</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-numerical-gradient">
<h3><a class="doc-anchor" href="#doc-numerical-gradient">#</a> <code>numerical_gradient</code></h3>
<p><code>numerical_gradient F, POINT [, H]</code> — central-difference ∇f. F receives a single arrayref <code>$_[0]</code>.</p>
<pre><code class="lang-perl">fn quad { my @y = @{$_[0]}; $y[0]**2 + 2*$y[1]**2 }
my @g = ngrad(\&quad, [3, 4]) # (6, 16)
</code></pre>
</article>
<article class="doc-entry" id="doc-numerical-jacobian">
<h3><a class="doc-anchor" href="#doc-numerical-jacobian">#</a> <code>numerical_jacobian</code></h3>
<p><code>numerical_jacobian F, POINT [, H]</code> — Jacobian of vector-valued F.</p>
</article>
<article class="doc-entry" id="doc-numerical-hessian">
<h3><a class="doc-anchor" href="#doc-numerical-hessian">#</a> <code>numerical_hessian</code></h3>
<p><code>numerical_hessian F, POINT [, H]</code> — symmetric Hessian via mixed second differences.</p>
</article>
<article class="doc-entry" id="doc-numerical-divergence">
<h3><a class="doc-anchor" href="#doc-numerical-divergence">#</a> <code>numerical_divergence</code></h3>
<p><code>numerical_divergence F, POINT [, H]</code> — div of vector field F.</p>
</article>
<article class="doc-entry" id="doc-numerical-curl">
<h3><a class="doc-anchor" href="#doc-numerical-curl">#</a> <code>numerical_curl</code></h3>
<p><code>numerical_curl F, POINT [, H]</code> — 3-D curl returned as <code>[c_x, c_y, c_z]</code>.</p>
</article>
<article class="doc-entry" id="doc-numerical-laplacian">
<h3><a class="doc-anchor" href="#doc-numerical-laplacian">#</a> <code>numerical_laplacian</code></h3>
<p><code>numerical_laplacian F, POINT [, H]</code> — ∇²f.</p>
</article>
</section>
<section class="tutorial-section" id="ch-optimization">
<h2>Optimization</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-nelder-mead">
<h3><a class="doc-anchor" href="#doc-nelder-mead">#</a> <code>nelder_mead</code></h3>
<p><code>nelder_mead F, X0 [, MAX_ITER, TOL]</code> — Nelder-Mead simplex minimisation. Returns <code>[x*, f(x*)]</code>.</p>
</article>
<article class="doc-entry" id="doc-gradient-descent">
<h3><a class="doc-anchor" href="#doc-gradient-descent">#</a> <code>gradient_descent</code></h3>
<p><code>gradient_descent F, GRAD, X0 [, STEP, ITERS]</code> — fixed-step descent.</p>
</article>
<article class="doc-entry" id="doc-bfgs-minimize">
<h3><a class="doc-anchor" href="#doc-bfgs-minimize">#</a> <code>bfgs_minimize</code></h3>
<p><code>bfgs_minimize F, GRAD, X0 [, MAX_ITER, TOL]</code> — BFGS quasi-Newton with Armijo line search.</p>
</article>
<article class="doc-entry" id="doc-levenberg-marquardt">
<h3><a class="doc-anchor" href="#doc-levenberg-marquardt">#</a> <code>levenberg_marquardt</code></h3>
<p><code>levenberg_marquardt F_RESID, X0 [, MAX_ITER, TOL]</code> — nonlinear LSQ. F returns the residual vector.</p>
</article>
<article class="doc-entry" id="doc-conjugate-gradient">
<h3><a class="doc-anchor" href="#doc-conjugate-gradient">#</a> <code>conjugate_gradient</code></h3>
<p><code>conjugate_gradient A, B</code> — CG for symmetric positive definite A x = b.</p>
</article>
<article class="doc-entry" id="doc-least-squares">
<h3><a class="doc-anchor" href="#doc-least-squares">#</a> <code>least_squares</code></h3>
<p><code>least_squares A, B</code> — solves A^T A x = A^T b.</p>
</article>
</section>
<section class="tutorial-section" id="ch-numerical-integration">
<h2>Numerical Integration</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-romberg">
<h3><a class="doc-anchor" href="#doc-romberg">#</a> <code>romberg</code></h3>
<p><code>romberg F, A, B [, LEVELS]</code> — Romberg integration. Doubles trapezoid then Richardson-extrapolates.</p>
</article>
<article class="doc-entry" id="doc-gauss-legendre-quad">
<h3><a class="doc-anchor" href="#doc-gauss-legendre-quad">#</a> <code>gauss_legendre_quad</code></h3>
<p><code>gauss_legendre_quad F, A, B [, N]</code> — N-point Gauss-Legendre quadrature on [a, b] (default N=10).</p>
</article>
<article class="doc-entry" id="doc-monte-carlo-integrate">
<h3><a class="doc-anchor" href="#doc-monte-carlo-integrate">#</a> <code>monte_carlo_integrate</code></h3>
<p><code>monte_carlo_integrate F, A, B [, N]</code> — uniform Monte Carlo over [a, b] with N samples (default 10 000).</p>
</article>
<article class="doc-entry" id="doc-adaptive-simpson">
<h3><a class="doc-anchor" href="#doc-adaptive-simpson">#</a> <code>adaptive_simpson</code></h3>
<p><code>adaptive_simpson F, A, B [, TOL, MAX_DEPTH]</code> — adaptive Simpson with Richardson tail.</p>
</article>
</section>
<section class="tutorial-section" id="ch-linear-algebra-numeric">
<h2>Linear Algebra (Numeric)</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-lu-decompose">
<h3><a class="doc-anchor" href="#doc-lu-decompose">#</a> <code>lu_decompose</code></h3>
<p><code>lu_decompose A</code> → <code>[L, U, P]</code> with P A = L U; P stored as a row-permutation vector.</p>
</article>
<article class="doc-entry" id="doc-qr-decompose">
<h3><a class="doc-anchor" href="#doc-qr-decompose">#</a> <code>qr_decompose</code></h3>
<p><code>qr_decompose A</code> → <code>[Q, R]</code> via Gram-Schmidt.</p>
</article>
<article class="doc-entry" id="doc-householder-reflector">
<h3><a class="doc-anchor" href="#doc-householder-reflector">#</a> <code>householder_reflector</code></h3>
<p><code>householder_reflector V</code> → I − 2 v v^T / (v · v).</p>
</article>
<article class="doc-entry" id="doc-givens-rotation">
<h3><a class="doc-anchor" href="#doc-givens-rotation">#</a> <code>givens_rotation</code></h3>
<p><code>givens_rotation A, B</code> → <code>[c, s]</code> such that the rotation [c -s; s c] zeros the second component.</p>
</article>
<article class="doc-entry" id="doc-forward-substitute">
<h3><a class="doc-anchor" href="#doc-forward-substitute">#</a> <code>forward_substitute</code></h3>
<p><code>forward_substitute L, B</code> — solve L x = b for lower-triangular L.</p>
</article>
<article class="doc-entry" id="doc-back-substitute">
<h3><a class="doc-anchor" href="#doc-back-substitute">#</a> <code>back_substitute</code></h3>
<p><code>back_substitute U, B</code> — solve U x = b for upper-triangular U.</p>
</article>
<article class="doc-entry" id="doc-hessenberg-reduce">
<h3><a class="doc-anchor" href="#doc-hessenberg-reduce">#</a> <code>hessenberg_reduce</code></h3>
<p><code>hessenberg_reduce A</code> — orthogonal Hessenberg form via Householder reflections.</p>
</article>
</section>
<section class="tutorial-section" id="ch-polynomial-helpers">
<h2>Polynomial Helpers</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-poly-derivative">
<h3><a class="doc-anchor" href="#doc-poly-derivative">#</a> <code>poly_derivative</code></h3>
<p><code>poly_derivative P</code> — coefficient-list derivative of polynomial P (low-to-high order).</p>
</article>
<article class="doc-entry" id="doc-poly-integrate">
<h3><a class="doc-anchor" href="#doc-poly-integrate">#</a> <code>poly_integrate</code></h3>
<p><code>poly_integrate P [, C]</code> — antiderivative with constant C (default 0).</p>
</article>
<article class="doc-entry" id="doc-poly-compose">
<h3><a class="doc-anchor" href="#doc-poly-compose">#</a> <code>poly_compose</code></h3>
<p><code>poly_compose P, Q</code> → coefficients of P(Q(x)).</p>
</article>
<article class="doc-entry" id="doc-poly-eval-horner">
<h3><a class="doc-anchor" href="#doc-poly-eval-horner">#</a> <code>poly_eval_horner</code></h3>
<p><code>poly_eval_horner P, X</code> — Horner-rule polynomial evaluation.</p>
</article>
<article class="doc-entry" id="doc-pade-approximant">
<h3><a class="doc-anchor" href="#doc-pade-approximant">#</a> <code>pade_approximant</code></h3>
<p><code>pade_approximant TAYLOR, M, N</code> → <code>[num, den]</code> Padé approximation.</p>
</article>
</section>
<section class="tutorial-section" id="ch-quaternions-3d-rotations">
<h2>Quaternions & 3D Rotations</h2>
<p class="chapter-meta">12 topics</p>
<article class="doc-entry" id="doc-quat-mul">
<h3><a class="doc-anchor" href="#doc-quat-mul">#</a> <code>quat_mul</code></h3>
<p><code>quat_mul A, B</code> — Hamilton product (w, x, y, z).</p>
</article>
<article class="doc-entry" id="doc-quat-conj">
<h3><a class="doc-anchor" href="#doc-quat-conj">#</a> <code>quat_conj</code></h3>
<p><code>quat_conj Q</code> — conjugate (w, -x, -y, -z).</p>
</article>
<article class="doc-entry" id="doc-quat-norm">
<h3><a class="doc-anchor" href="#doc-quat-norm">#</a> <code>quat_norm</code></h3>
<p><code>quat_norm Q</code> — Euclidean norm.</p>
</article>
<article class="doc-entry" id="doc-quat-inv">
<h3><a class="doc-anchor" href="#doc-quat-inv">#</a> <code>quat_inv</code></h3>
<p><code>quat_inv Q</code> — inverse Q* / |Q|².</p>
</article>
<article class="doc-entry" id="doc-quat-from-axis-angle">
<h3><a class="doc-anchor" href="#doc-quat-from-axis-angle">#</a> <code>quat_from_axis_angle</code></h3>
<p><code>quat_from_axis_angle AXIS, THETA</code> — unit quaternion encoding rotation about AXIS by THETA radians.</p>
</article>
<article class="doc-entry" id="doc-quat-to-axis-angle">
<h3><a class="doc-anchor" href="#doc-quat-to-axis-angle">#</a> <code>quat_to_axis_angle</code></h3>
<p><code>quat_to_axis_angle Q</code> → <code>[axis, theta]</code>.</p>
</article>
<article class="doc-entry" id="doc-quat-to-matrix">
<h3><a class="doc-anchor" href="#doc-quat-to-matrix">#</a> <code>quat_to_matrix</code></h3>
<p><code>quat_to_matrix Q</code> → 3×3 rotation matrix.</p>
</article>
<article class="doc-entry" id="doc-quat-from-matrix">
<h3><a class="doc-anchor" href="#doc-quat-from-matrix">#</a> <code>quat_from_matrix</code></h3>
<p><code>quat_from_matrix R</code> — Shepherd's algorithm.</p>
</article>
<article class="doc-entry" id="doc-quat-slerp">
<h3><a class="doc-anchor" href="#doc-quat-slerp">#</a> <code>quat_slerp</code></h3>
<p><code>quat_slerp A, B, T</code> — spherical-linear interpolation between two unit quaternions.</p>
</article>
<article class="doc-entry" id="doc-euler-zyx-to-matrix">
<h3><a class="doc-anchor" href="#doc-euler-zyx-to-matrix">#</a> <code>euler_zyx_to_matrix</code></h3>
<p><code>euler_zyx_to_matrix YAW, PITCH, ROLL</code> — intrinsic Z-Y-X Euler rotation.</p>
</article>
<article class="doc-entry" id="doc-matrix-to-euler-zyx">
<h3><a class="doc-anchor" href="#doc-matrix-to-euler-zyx">#</a> <code>matrix_to_euler_zyx</code></h3>
<p><code>matrix_to_euler_zyx R</code> → <code>[yaw, pitch, roll]</code>.</p>
</article>
<article class="doc-entry" id="doc-rotate-3d-vec">
<h3><a class="doc-anchor" href="#doc-rotate-3d-vec">#</a> <code>rotate_3d_vec</code></h3>
<p><code>rotate_3d_vec Q, V</code> — apply quaternion rotation to a 3-vector.</p>
</article>
</section>
<section class="tutorial-section" id="ch-information-theory">
<h2>Information Theory</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-kl-divergence">
<h3><a class="doc-anchor" href="#doc-kl-divergence">#</a> <code>kl_divergence</code></h3>
<p><code>kl_divergence P, Q</code> — D_KL(P || Q) in nats.</p>
</article>
<article class="doc-entry" id="doc-js-divergence">
<h3><a class="doc-anchor" href="#doc-js-divergence">#</a> <code>js_divergence</code></h3>
<p><code>js_divergence P, Q</code> — Jensen-Shannon divergence.</p>
</article>
<article class="doc-entry" id="doc-mutual-information">
<h3><a class="doc-anchor" href="#doc-mutual-information">#</a> <code>mutual_information</code></h3>
<p><code>mutual_information JOINT</code> — I(X; Y) from a joint-probability matrix.</p>
</article>
<article class="doc-entry" id="doc-cross-entropy-arr">
<h3><a class="doc-anchor" href="#doc-cross-entropy-arr">#</a> <code>cross_entropy_arr</code></h3>
<p><code>cross_entropy_arr P, Q</code> — H(P, Q) = -Σ p log q.</p>
</article>
<article class="doc-entry" id="doc-renyi-entropy">
<h3><a class="doc-anchor" href="#doc-renyi-entropy">#</a> <code>renyi_entropy</code></h3>
<p><code>renyi_entropy P [, ALPHA]</code> — Rényi entropy of order α (default 2).</p>
</article>
<article class="doc-entry" id="doc-tsallis-entropy">
<h3><a class="doc-anchor" href="#doc-tsallis-entropy">#</a> <code>tsallis_entropy</code></h3>
<p><code>tsallis_entropy P [, Q]</code> — Tsallis entropy of order q (default 2).</p>
</article>
</section>
<section class="tutorial-section" id="ch-quantum-primitives">
<h2>Quantum Primitives</h2>
<p class="chapter-meta">11 topics</p>
<article class="doc-entry" id="doc-pauli-x">
<h3><a class="doc-anchor" href="#doc-pauli-x">#</a> <code>pauli_x</code></h3>
<p><code>pauli_x</code> — 2×2 σ_x matrix.</p>
</article>
<article class="doc-entry" id="doc-pauli-y">
<h3><a class="doc-anchor" href="#doc-pauli-y">#</a> <code>pauli_y</code></h3>
<p><code>pauli_y</code> — 2×2 σ_y matrix encoded with [Re, Im] entries (since stryke matrices are real).</p>
</article>
<article class="doc-entry" id="doc-pauli-z">
<h3><a class="doc-anchor" href="#doc-pauli-z">#</a> <code>pauli_z</code></h3>
<p><code>pauli_z</code> — 2×2 σ_z matrix.</p>
</article>
<article class="doc-entry" id="doc-pauli-id">
<h3><a class="doc-anchor" href="#doc-pauli-id">#</a> <code>pauli_id</code></h3>
<p><code>pauli_id</code> — 2×2 identity.</p>
</article>
<article class="doc-entry" id="doc-ket-bra">
<h3><a class="doc-anchor" href="#doc-ket-bra">#</a> <code>ket_bra</code></h3>
<p><code>ket_bra PSI, PHI</code> → outer product |ψ⟩⟨φ| of two real vectors.</p>
</article>
<article class="doc-entry" id="doc-density-matrix">
<h3><a class="doc-anchor" href="#doc-density-matrix">#</a> <code>density_matrix</code></h3>
<p><code>density_matrix PSI</code> → ρ = |ψ⟩⟨ψ| (real-valued).</p>
</article>
<article class="doc-entry" id="doc-expectation-value">
<h3><a class="doc-anchor" href="#doc-expectation-value">#</a> <code>expectation_value</code></h3>
<p><code>expectation_value OP, PSI</code> → ⟨ψ|O|ψ⟩.</p>
</article>
<article class="doc-entry" id="doc-commutator">
<h3><a class="doc-anchor" href="#doc-commutator">#</a> <code>commutator</code></h3>
<p><code>commutator A, B</code> — [A, B] = AB − BA.</p>
</article>
<article class="doc-entry" id="doc-anticommutator">
<h3><a class="doc-anchor" href="#doc-anticommutator">#</a> <code>anticommutator</code></h3>
<p><code>anticommutator A, B</code> — {A, B} = AB + BA.</p>
</article>
<article class="doc-entry" id="doc-partial-trace">
<h3><a class="doc-anchor" href="#doc-partial-trace">#</a> <code>partial_trace</code></h3>
<p><code>partial_trace RHO, DIMS, KEEP</code> — partial trace over subsystems whose indices are not in KEEP.</p>
</article>
<article class="doc-entry" id="doc-von-neumann-entropy">
<h3><a class="doc-anchor" href="#doc-von-neumann-entropy">#</a> <code>von_neumann_entropy</code></h3>
<p><code>von_neumann_entropy RHO</code> — S(ρ) = -tr(ρ log ρ) for symmetric ρ.</p>
</article>
</section>
<section class="tutorial-section" id="ch-statistical-mechanics">
<h2>Statistical Mechanics</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-bose-einstein">
<h3><a class="doc-anchor" href="#doc-bose-einstein">#</a> <code>bose_einstein</code></h3>
<p><code>bose_einstein E, MU, KT</code> — 1 / (exp((E - μ)/kT) - 1).</p>
</article>
<article class="doc-entry" id="doc-fermi-dirac">
<h3><a class="doc-anchor" href="#doc-fermi-dirac">#</a> <code>fermi_dirac</code></h3>
<p><code>fermi_dirac E, MU, KT</code> — 1 / (exp((E - μ)/kT) + 1).</p>
</article>
<article class="doc-entry" id="doc-maxwell-boltzmann-speed">
<h3><a class="doc-anchor" href="#doc-maxwell-boltzmann-speed">#</a> <code>maxwell_boltzmann_speed</code></h3>
<p><code>maxwell_boltzmann_speed V, M, KT</code> — Maxwell-Boltzmann speed PDF.</p>
</article>
<article class="doc-entry" id="doc-partition-function">
<h3><a class="doc-anchor" href="#doc-partition-function">#</a> <code>partition_function</code></h3>
<p><code>partition_function ENERGIES, KT</code> — Z = Σ exp(-E_i / kT).</p>
</article>
<article class="doc-entry" id="doc-helmholtz-free-energy">
<h3><a class="doc-anchor" href="#doc-helmholtz-free-energy">#</a> <code>helmholtz_free_energy</code></h3>
<p><code>helmholtz_free_energy Z, KT</code> — F = -kT ln Z.</p>
</article>
<article class="doc-entry" id="doc-boltzmann-factor">
<h3><a class="doc-anchor" href="#doc-boltzmann-factor">#</a> <code>boltzmann_factor</code></h3>
<p><code>boltzmann_factor E, KT</code> — exp(-E / kT).</p>
</article>
<article class="doc-entry" id="doc-einstein-specific-heat">
<h3><a class="doc-anchor" href="#doc-einstein-specific-heat">#</a> <code>einstein_specific_heat</code></h3>
<p><code>einstein_specific_heat T, THETA_E</code> — Einstein heat-capacity model (J / mol·K).</p>
</article>
</section>
<section class="tutorial-section" id="ch-optics">
<h2>Optics</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-fresnel-reflection-te">
<h3><a class="doc-anchor" href="#doc-fresnel-reflection-te">#</a> <code>fresnel_reflection_te</code></h3>
<p><code>fresnel_reflection_te THETA_I, N1, N2</code> — TE (s-polarisation) reflection coefficient.</p>
</article>
<article class="doc-entry" id="doc-fresnel-reflection-tm">
<h3><a class="doc-anchor" href="#doc-fresnel-reflection-tm">#</a> <code>fresnel_reflection_tm</code></h3>
<p><code>fresnel_reflection_tm THETA_I, N1, N2</code> — TM (p-polarisation) reflection.</p>
</article>
<article class="doc-entry" id="doc-fresnel-transmission-te">
<h3><a class="doc-anchor" href="#doc-fresnel-transmission-te">#</a> <code>fresnel_transmission_te</code></h3>
<p><code>fresnel_transmission_te THETA_I, N1, N2</code> — TE transmission.</p>
</article>
<article class="doc-entry" id="doc-fresnel-transmission-tm">
<h3><a class="doc-anchor" href="#doc-fresnel-transmission-tm">#</a> <code>fresnel_transmission_tm</code></h3>
<p><code>fresnel_transmission_tm THETA_I, N1, N2</code> — TM transmission.</p>
</article>
<article class="doc-entry" id="doc-abcd-thin-lens">
<h3><a class="doc-anchor" href="#doc-abcd-thin-lens">#</a> <code>abcd_thin_lens</code></h3>
<p><code>abcd_thin_lens F</code> — ABCD ray matrix for a thin lens of focal length F.</p>
</article>
<article class="doc-entry" id="doc-abcd-free-space">
<h3><a class="doc-anchor" href="#doc-abcd-free-space">#</a> <code>abcd_free_space</code></h3>
<p><code>abcd_free_space D</code> — ABCD matrix for free-space propagation D.</p>
</article>
<article class="doc-entry" id="doc-gaussian-beam-q">
<h3><a class="doc-anchor" href="#doc-gaussian-beam-q">#</a> <code>gaussian_beam_q</code></h3>
<p><code>gaussian_beam_q Z, W0, LAMBDA</code> → <code>[Re(q), Im(q)]</code> for a Gaussian beam at distance Z.</p>
</article>
</section>
<section class="tutorial-section" id="ch-astrodynamics">
<h2>Astrodynamics</h2>
<p class="chapter-meta">9 topics</p>
<article class="doc-entry" id="doc-kepler-solve">
<h3><a class="doc-anchor" href="#doc-kepler-solve">#</a> <code>kepler_solve</code></h3>
<p><code>kepler_solve M, E</code> — solve Kepler's equation M = E - e sin(E) by Newton iteration.</p>
</article>
<article class="doc-entry" id="doc-true-to-eccentric">
<h3><a class="doc-anchor" href="#doc-true-to-eccentric">#</a> <code>true_to_eccentric</code></h3>
<p><code>true_to_eccentric NU, E</code> → eccentric anomaly E.</p>
</article>
<article class="doc-entry" id="doc-eccentric-to-mean">
<h3><a class="doc-anchor" href="#doc-eccentric-to-mean">#</a> <code>eccentric_to_mean</code></h3>
<p><code>eccentric_to_mean E, ECC</code> → mean anomaly M.</p>
</article>
<article class="doc-entry" id="doc-julian-date">
<h3><a class="doc-anchor" href="#doc-julian-date">#</a> <code>julian_date</code></h3>
<p><code>julian_date Y, M, D, H, MN, S</code> — Julian date (Meeus formula).</p>
</article>
<article class="doc-entry" id="doc-jd-to-gregorian">
<h3><a class="doc-anchor" href="#doc-jd-to-gregorian">#</a> <code>jd_to_gregorian</code></h3>
<p><code>jd_to_gregorian JD</code> → <code>[Y, M, D.dd]</code>.</p>
</article>
<article class="doc-entry" id="doc-sidereal-time-gmst">
<h3><a class="doc-anchor" href="#doc-sidereal-time-gmst">#</a> <code>sidereal_time_gmst</code></h3>
<p><code>sidereal_time_gmst JD</code> — Greenwich Mean Sidereal Time in radians.</p>
</article>
<article class="doc-entry" id="doc-vis-viva">
<h3><a class="doc-anchor" href="#doc-vis-viva">#</a> <code>vis_viva</code></h3>
<p><code>vis_viva R, A, MU</code> — orbital speed from vis-viva equation.</p>
</article>
<article class="doc-entry" id="doc-orbital-period-kepler">
<h3><a class="doc-anchor" href="#doc-orbital-period-kepler">#</a> <code>orbital_period_kepler</code></h3>
<p><code>orbital_period_kepler A, MU</code> — T = 2π √(a³ / μ).</p>
</article>
<article class="doc-entry" id="doc-orbital-elements-to-state">
<h3><a class="doc-anchor" href="#doc-orbital-elements-to-state">#</a> <code>orbital_elements_to_state</code></h3>
<p><code>orbital_elements_to_state A, E, I, OM, W, NU, MU</code> → <code>[r_x, r_y, r_z, v_x, v_y, v_z]</code>.</p>
</article>
</section>
<section class="tutorial-section" id="ch-time-series">
<h2>Time Series</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-kalman-step">
<h3><a class="doc-anchor" href="#doc-kalman-step">#</a> <code>kalman_step</code></h3>
<p><code>kalman_step X, P, F, H, Q, R, Z</code> → <code>[X', P']</code> — single Kalman predict-and-update step.</p>
</article>
<article class="doc-entry" id="doc-exponential-smoothing">
<h3><a class="doc-anchor" href="#doc-exponential-smoothing">#</a> <code>exponential_smoothing</code></h3>
<p><code>exponential_smoothing XS, ALPHA</code> — first-order EMA.</p>
</article>
<article class="doc-entry" id="doc-holt-winters">
<h3><a class="doc-anchor" href="#doc-holt-winters">#</a> <code>holt_winters</code></h3>
<p><code>holt_winters XS, ALPHA, BETA, GAMMA, PERIOD</code> — additive triple exponential smoothing.</p>
</article>
<article class="doc-entry" id="doc-arma-yw-fit">
<h3><a class="doc-anchor" href="#doc-arma-yw-fit">#</a> <code>arma_yw_fit</code></h3>
<p><code>arma_yw_fit XS, P</code> — Yule-Walker AR(p) coefficients via Levinson-Durbin.</p>
</article>
</section>
<section class="tutorial-section" id="ch-graph-centrality">
<h2>Graph Centrality</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-pagerank">
<h3><a class="doc-anchor" href="#doc-pagerank">#</a> <code>pagerank</code></h3>
<p><code>pagerank ADJ [, DAMPING, ITERS]</code> — PageRank via power iteration. Default damping 0.85, 100 iters.</p>
</article>
<article class="doc-entry" id="doc-betweenness-centrality">
<h3><a class="doc-anchor" href="#doc-betweenness-centrality">#</a> <code>betweenness_centrality</code></h3>
<p><code>betweenness_centrality ADJ</code> — Brandes' algorithm (unweighted).</p>
</article>
<article class="doc-entry" id="doc-closeness-centrality">
<h3><a class="doc-anchor" href="#doc-closeness-centrality">#</a> <code>closeness_centrality</code></h3>
<p><code>closeness_centrality ADJ</code> — closeness centrality. 0 for disconnected vertices.</p>
</article>
<article class="doc-entry" id="doc-eigenvector-centrality">
<h3><a class="doc-anchor" href="#doc-eigenvector-centrality">#</a> <code>eigenvector_centrality</code></h3>
<p><code>eigenvector_centrality ADJ</code> — power iteration on the adjacency matrix.</p>
</article>
<article class="doc-entry" id="doc-degree-centrality">
<h3><a class="doc-anchor" href="#doc-degree-centrality">#</a> <code>degree_centrality</code></h3>
<p><code>degree_centrality ADJ</code> — degree / (n - 1).</p>
</article>
<article class="doc-entry" id="doc-triangle-count">
<h3><a class="doc-anchor" href="#doc-triangle-count">#</a> <code>triangle_count</code></h3>
<p><code>triangle_count ADJ</code> — number of triangles incident at each vertex.</p>
</article>
</section>
<section class="tutorial-section" id="ch-random-samplers-extended">
<h2>Random Samplers (Extended)</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-rgumbel">
<h3><a class="doc-anchor" href="#doc-rgumbel">#</a> <code>rgumbel</code></h3>
<p><code>rgumbel MU, BETA</code> — Gumbel sample.</p>
</article>
<article class="doc-entry" id="doc-rfrechet">
<h3><a class="doc-anchor" href="#doc-rfrechet">#</a> <code>rfrechet</code></h3>
<p><code>rfrechet ALPHA, S</code> — Fréchet sample.</p>
</article>
<article class="doc-entry" id="doc-rrayleigh">
<h3><a class="doc-anchor" href="#doc-rrayleigh">#</a> <code>rrayleigh</code></h3>
<p><code>rrayleigh SIGMA</code> — Rayleigh sample.</p>
</article>
<article class="doc-entry" id="doc-rlogistic">
<h3><a class="doc-anchor" href="#doc-rlogistic">#</a> <code>rlogistic</code></h3>
<p><code>rlogistic MU, S</code> — logistic sample.</p>
</article>
<article class="doc-entry" id="doc-rkumaraswamy">
<h3><a class="doc-anchor" href="#doc-rkumaraswamy">#</a> <code>rkumaraswamy</code></h3>
<p><code>rkumaraswamy A, B</code> — Kumaraswamy sample on (0, 1).</p>
</article>
<article class="doc-entry" id="doc-rinverse-gamma">
<h3><a class="doc-anchor" href="#doc-rinverse-gamma">#</a> <code>rinverse_gamma</code></h3>
<p><code>rinverse_gamma ALPHA, BETA</code> — inverse-gamma sample (Marsaglia-Tsang).</p>
</article>
</section>
<section class="tutorial-section" id="ch-2-d-geometry">
<h2>2-D Geometry</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-graham-scan">
<h3><a class="doc-anchor" href="#doc-graham-scan">#</a> <code>graham_scan</code></h3>
<p><code>graham_scan POINTS</code> — 2-D convex hull (CCW).</p>
</article>
<article class="doc-entry" id="doc-line-line-intersect-2d">
<h3><a class="doc-anchor" href="#doc-line-line-intersect-2d">#</a> <code>line_line_intersect_2d</code></h3>
<p><code>line_line_intersect_2d P1, P2, P3, P4</code> → intersection <code>[x, y]</code> or undef when parallel.</p>
</article>
<article class="doc-entry" id="doc-point-segment-distance">
<h3><a class="doc-anchor" href="#doc-point-segment-distance">#</a> <code>point_segment_distance</code></h3>
<p><code>point_segment_distance P, A, B</code> — Euclidean distance from P to segment AB.</p>
</article>
</section>
<section class="tutorial-section" id="ch-auto-differentiation">
<h2>Auto-Differentiation</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-forward-diff">
<h3><a class="doc-anchor" href="#doc-forward-diff">#</a> <code>forward_diff</code></h3>
<p><code>forward_diff F, X</code> — derivative of scalar f at scalar x (Julia ForwardDiff style; central-difference fallback).</p>
</article>
<article class="doc-entry" id="doc-forward-diff-grad">
<h3><a class="doc-anchor" href="#doc-forward-diff-grad">#</a> <code>forward_diff_grad</code></h3>
<p><code>forward_diff_grad F, X_VEC</code> — gradient at vector x; alias for <code>numerical_gradient</code>.</p>
</article>
</section>
<section class="tutorial-section" id="ch-statistical-tests-r-parity">
<h2>Statistical Tests (R parity)</h2>
<p class="chapter-meta">12 topics</p>
<article class="doc-entry" id="doc-bartlett-test">
<h3><a class="doc-anchor" href="#doc-bartlett-test">#</a> <code>bartlett_test</code></h3>
<p><code>bartlett_test GROUPS</code> — Bartlett's k-sample variance equality test. Returns <code>[chi², df, p]</code>.</p>
</article>
<article class="doc-entry" id="doc-levene-test">
<h3><a class="doc-anchor" href="#doc-levene-test">#</a> <code>levene_test</code></h3>
<p><code>levene_test GROUPS</code> — Levene's variance-equality test. Returns <code>[F, df1, df2, p]</code>.</p>
</article>
<article class="doc-entry" id="doc-fishers-exact-test-2x2">
<h3><a class="doc-anchor" href="#doc-fishers-exact-test-2x2">#</a> <code>fishers_exact_test_2x2</code></h3>
<p><code>fishers_exact_test_2x2 [[a, b], [c, d]]</code> — two-sided p-value.</p>
</article>
<article class="doc-entry" id="doc-mcnemar-test">
<h3><a class="doc-anchor" href="#doc-mcnemar-test">#</a> <code>mcnemar_test</code></h3>
<p><code>mcnemar_test [[a, b], [c, d]]</code> — paired 2×2 table with continuity correction. Returns <code>[chi², p]</code>.</p>
</article>
<article class="doc-entry" id="doc-runs-test">
<h3><a class="doc-anchor" href="#doc-runs-test">#</a> <code>runs_test</code></h3>
<p><code>runs_test SEQ</code> — Wald-Wolfowitz runs test on a binary sequence. Returns <code>[Z, p]</code>.</p>
</article>
<article class="doc-entry" id="doc-friedman-test">
<h3><a class="doc-anchor" href="#doc-friedman-test">#</a> <code>friedman_test</code></h3>
<p><code>friedman_test BLOCKS_BY_TREATMENTS</code> — non-parametric ANOVA on ranks. Returns <code>[Q, df, p]</code>.</p>
</article>
<article class="doc-entry" id="doc-kruskal-wallis-test">
<h3><a class="doc-anchor" href="#doc-kruskal-wallis-test">#</a> <code>kruskal_wallis_test</code></h3>
<p><code>kruskal_wallis_test GROUPS</code> — non-parametric ANOVA. Returns <code>[H, df, p]</code>.</p>
</article>
<article class="doc-entry" id="doc-sign-test">
<h3><a class="doc-anchor" href="#doc-sign-test">#</a> <code>sign_test</code></h3>
<p><code>sign_test PAIRS</code> — paired sign test. Returns <code>[N+, p]</code>.</p>
</article>
<article class="doc-entry" id="doc-anderson-darling-normality">
<h3><a class="doc-anchor" href="#doc-anderson-darling-normality">#</a> <code>anderson_darling_normality</code></h3>
<p><code>anderson_darling_normality XS</code> — A² statistic. > 0.752 → reject normality at α=0.05.</p>
</article>
<article class="doc-entry" id="doc-jarque-bera-test">
<h3><a class="doc-anchor" href="#doc-jarque-bera-test">#</a> <code>jarque_bera_test</code></h3>
<p><code>jarque_bera_test XS</code> — normality test from sample skewness + kurtosis.</p>
</article>
<article class="doc-entry" id="doc-ljung-box-test">
<h3><a class="doc-anchor" href="#doc-ljung-box-test">#</a> <code>ljung_box_test</code></h3>
<p><code>ljung_box_test XS [, H]</code> — autocorrelation test. Returns <code>[Q, h, p]</code>.</p>
</article>
<article class="doc-entry" id="doc-durbin-watson-stat">
<h3><a class="doc-anchor" href="#doc-durbin-watson-stat">#</a> <code>durbin_watson_stat</code></h3>
<p><code>durbin_watson_stat RESID</code> — DW autocorrelation statistic on residuals.</p>
</article>
</section>
<section class="tutorial-section" id="ch-distance-metrics-distances-jl-parity">
<h2>Distance Metrics (Distances.jl parity)</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-mahalanobis-distance">
<h3><a class="doc-anchor" href="#doc-mahalanobis-distance">#</a> <code>mahalanobis_distance</code></h3>
<p><code>mahalanobis_distance X, MU, SIGMA</code> — √((x-μ)ᵀ Σ⁻¹ (x-μ)).</p>
</article>
<article class="doc-entry" id="doc-cosine-distance">
<h3><a class="doc-anchor" href="#doc-cosine-distance">#</a> <code>cosine_distance</code></h3>
<p><code>cosine_distance A, B</code> — 1 − cos(A, B).</p>
</article>
<article class="doc-entry" id="doc-canberra-distance">
<h3><a class="doc-anchor" href="#doc-canberra-distance">#</a> <code>canberra_distance</code></h3>
<p><code>canberra_distance A, B</code> — Σ |a-b| / (|a|+|b|).</p>
</article>
<article class="doc-entry" id="doc-bray-curtis-distance">
<h3><a class="doc-anchor" href="#doc-bray-curtis-distance">#</a> <code>bray_curtis_distance</code></h3>
<p><code>bray_curtis_distance A, B</code> — Σ|a-b| / Σ(a+b).</p>
</article>
<article class="doc-entry" id="doc-l1-distance">
<h3><a class="doc-anchor" href="#doc-l1-distance">#</a> <code>l1_distance</code></h3>
<p><code>l1_distance A, B</code> — Manhattan / taxi-cab distance.</p>
</article>
<article class="doc-entry" id="doc-chi-squared-distance">
<h3><a class="doc-anchor" href="#doc-chi-squared-distance">#</a> <code>chi_squared_distance</code></h3>
<p><code>chi_squared_distance A, B</code> — ½ Σ (a-b)² / (a+b).</p>
</article>
</section>
<section class="tutorial-section" id="ch-multivariate-non-central-distributions">
<h2>Multivariate / Non-Central Distributions</h2>
<p class="chapter-meta">9 topics</p>
<article class="doc-entry" id="doc-multivariate-normal-pdf">
<h3><a class="doc-anchor" href="#doc-multivariate-normal-pdf">#</a> <code>multivariate_normal_pdf</code></h3>
<p><code>multivariate_normal_pdf X, MU, SIGMA</code> — multivariate Gaussian PDF.</p>
</article>
<article class="doc-entry" id="doc-multivariate-normal-sample">
<h3><a class="doc-anchor" href="#doc-multivariate-normal-sample">#</a> <code>multivariate_normal_sample</code></h3>
<p><code>multivariate_normal_sample MU, SIGMA</code> — sample from MVN via Cholesky.</p>
</article>
<article class="doc-entry" id="doc-dirichlet-pdf">
<h3><a class="doc-anchor" href="#doc-dirichlet-pdf">#</a> <code>dirichlet_pdf</code></h3>
<p><code>dirichlet_pdf X, ALPHA</code> — Dirichlet PDF on the simplex.</p>
</article>
<article class="doc-entry" id="doc-dirichlet-sample">
<h3><a class="doc-anchor" href="#doc-dirichlet-sample">#</a> <code>dirichlet_sample</code></h3>
<p><code>dirichlet_sample ALPHA</code> — sample via independent Gamma draws.</p>
</article>
<article class="doc-entry" id="doc-skellam-pmf">
<h3><a class="doc-anchor" href="#doc-skellam-pmf">#</a> <code>skellam_pmf</code></h3>
<p><code>skellam_pmf K, MU1, MU2</code> — difference of two independent Poisson(μ) variates.</p>
</article>
<article class="doc-entry" id="doc-inverse-gaussian-pdf">
<h3><a class="doc-anchor" href="#doc-inverse-gaussian-pdf">#</a> <code>inverse_gaussian_pdf</code></h3>
<p><code>inverse_gaussian_pdf X, MU, LAMBDA</code> — Wald PDF.</p>
</article>
<article class="doc-entry" id="doc-inverse-gaussian-cdf">
<h3><a class="doc-anchor" href="#doc-inverse-gaussian-cdf">#</a> <code>inverse_gaussian_cdf</code></h3>
<p><code>inverse_gaussian_cdf X, MU, LAMBDA</code> — Wald CDF.</p>
</article>
<article class="doc-entry" id="doc-inverse-gaussian-sample">
<h3><a class="doc-anchor" href="#doc-inverse-gaussian-sample">#</a> <code>inverse_gaussian_sample</code></h3>
<p><code>inverse_gaussian_sample MU, LAMBDA</code> — Michael-Schucany-Haas.</p>
</article>
<article class="doc-entry" id="doc-non-central-chi2-pdf">
<h3><a class="doc-anchor" href="#doc-non-central-chi2-pdf">#</a> <code>non_central_chi2_pdf</code></h3>
<p><code>non_central_chi2_pdf X, K, LAMBDA</code> — Series-form non-central χ² PDF.</p>
</article>
</section>
<section class="tutorial-section" id="ch-matrix-functions">
<h2>Matrix Functions</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-matrix-exp">
<h3><a class="doc-anchor" href="#doc-matrix-exp">#</a> <code>matrix_exp</code></h3>
<p><code>matrix_exp A</code> — e^A via 13-term Padé + scaling-and-squaring.</p>
</article>
<article class="doc-entry" id="doc-matrix-log">
<h3><a class="doc-anchor" href="#doc-matrix-log">#</a> <code>matrix_log</code></h3>
<p><code>matrix_log A</code> — ln A via inverse scaling (Denman-Beavers SQRT) + Padé log.</p>
</article>
<article class="doc-entry" id="doc-matrix-sqrt">
<h3><a class="doc-anchor" href="#doc-matrix-sqrt">#</a> <code>matrix_sqrt</code></h3>
<p><code>matrix_sqrt A</code> — A^(1/2) via Denman-Beavers iteration.</p>
</article>
<article class="doc-entry" id="doc-matrix-sin">
<h3><a class="doc-anchor" href="#doc-matrix-sin">#</a> <code>matrix_sin</code></h3>
<p><code>matrix_sin A</code> — series form Σ (-1)^k A^(2k+1) / (2k+1)!.</p>
</article>
<article class="doc-entry" id="doc-matrix-cos">
<h3><a class="doc-anchor" href="#doc-matrix-cos">#</a> <code>matrix_cos</code></h3>
<p><code>matrix_cos A</code> — series form Σ (-1)^k A^(2k) / (2k)!.</p>
</article>
</section>
<section class="tutorial-section" id="ch-adaptive-ode-solvers">
<h2>Adaptive ODE Solvers</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-rk45-dormand-prince">
<h3><a class="doc-anchor" href="#doc-rk45-dormand-prince">#</a> <code>rk45_dormand_prince</code></h3>
<p><code>rk45_dormand_prince F, Y0, T0, T1, H0 [, TOL]</code> — adaptive Dormand-Prince. F receives <code>[t, y0, …]</code>.</p>
</article>
<article class="doc-entry" id="doc-midpoint-step">
<h3><a class="doc-anchor" href="#doc-midpoint-step">#</a> <code>midpoint_step</code></h3>
<p><code>midpoint_step F, Y, T, H</code> — single explicit-midpoint step.</p>
</article>
<article class="doc-entry" id="doc-heun-step">
<h3><a class="doc-anchor" href="#doc-heun-step">#</a> <code>heun_step</code></h3>
<p><code>heun_step F, Y, T, H</code> — improved-Euler / Heun step.</p>
</article>
<article class="doc-entry" id="doc-verlet-step">
<h3><a class="doc-anchor" href="#doc-verlet-step">#</a> <code>verlet_step</code></h3>
<p><code>verlet_step ACCEL, Q, P, T, H</code> — velocity-Verlet symplectic step.</p>
</article>
</section>
<section class="tutorial-section" id="ch-generalized-linear-models">
<h2>Generalized Linear Models</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-logistic-regression">
<h3><a class="doc-anchor" href="#doc-logistic-regression">#</a> <code>logistic_regression</code></h3>
<p><code>logistic_regression X, Y</code> — IRLS (no intercept added — supply column of ones).</p>
</article>
<article class="doc-entry" id="doc-poisson-regression">
<h3><a class="doc-anchor" href="#doc-poisson-regression">#</a> <code>poisson_regression</code></h3>
<p><code>poisson_regression X, Y</code> — IRLS with log link.</p>
</article>
<article class="doc-entry" id="doc-ridge-regression">
<h3><a class="doc-anchor" href="#doc-ridge-regression">#</a> <code>ridge_regression</code></h3>
<p><code>ridge_regression X, Y [, LAMBDA]</code> — Tikhonov-regularised LSQ.</p>
</article>
<article class="doc-entry" id="doc-lasso-coord">
<h3><a class="doc-anchor" href="#doc-lasso-coord">#</a> <code>lasso_coord</code></h3>
<p><code>lasso_coord X, Y [, LAMBDA, MAX_ITER]</code> — coordinate-descent LASSO.</p>
</article>
</section>
<section class="tutorial-section" id="ch-bootstrap-resampling">
<h2>Bootstrap & Resampling</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-bootstrap-mean-ci">
<h3><a class="doc-anchor" href="#doc-bootstrap-mean-ci">#</a> <code>bootstrap_mean_ci</code></h3>
<p><code>bootstrap_mean_ci DATA [, B, ALPHA]</code> — percentile CI for the mean.</p>
</article>
<article class="doc-entry" id="doc-jackknife-estimate">
<h3><a class="doc-anchor" href="#doc-jackknife-estimate">#</a> <code>jackknife_estimate</code></h3>
<p><code>jackknife_estimate DATA</code> — leave-one-out SE of the mean.</p>
</article>
<article class="doc-entry" id="doc-permutation-test-diff">
<h3><a class="doc-anchor" href="#doc-permutation-test-diff">#</a> <code>permutation_test_diff</code></h3>
<p><code>permutation_test_diff A, B [, N_ITER]</code> — two-sided p of mean difference.</p>
</article>
</section>
<section class="tutorial-section" id="ch-time-series-operators">
<h2>Time Series Operators</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-acf-at-lag">
<h3><a class="doc-anchor" href="#doc-acf-at-lag">#</a> <code>acf_at_lag</code></h3>
<p><code>acf_at_lag XS, LAG</code> — autocorrelation at one lag.</p>
</article>
<article class="doc-entry" id="doc-diff-op">
<h3><a class="doc-anchor" href="#doc-diff-op">#</a> <code>diff_op</code></h3>
<p><code>diff_op XS [, LAG]</code> — y_t − y_{t-lag}.</p>
</article>
<article class="doc-entry" id="doc-lag-op">
<h3><a class="doc-anchor" href="#doc-lag-op">#</a> <code>lag_op</code></h3>
<p><code>lag_op XS [, K]</code> — shift by k (NaN-pad).</p>
</article>
<article class="doc-entry" id="doc-decompose-classical">
<h3><a class="doc-anchor" href="#doc-decompose-classical">#</a> <code>decompose_classical</code></h3>
<p><code>decompose_classical XS [, PERIOD]</code> — additive [trend, season, residual].</p>
</article>
</section>
<section class="tutorial-section" id="ch-combinatorial-generators">
<h2>Combinatorial Generators</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-combinations-list">
<h3><a class="doc-anchor" href="#doc-combinations-list">#</a> <code>combinations_list</code></h3>
<p><code>combinations_list N, K</code> — all k-subsets of 0..n in lex order.</p>
</article>
<article class="doc-entry" id="doc-permutations-list">
<h3><a class="doc-anchor" href="#doc-permutations-list">#</a> <code>permutations_list</code></h3>
<p><code>permutations_list N</code> — all permutations of 0..n via Heap's algorithm.</p>
</article>
<article class="doc-entry" id="doc-cyclic-permutations">
<h3><a class="doc-anchor" href="#doc-cyclic-permutations">#</a> <code>cyclic_permutations</code></h3>
<p><code>cyclic_permutations ARR</code> — all rotations.</p>
</article>
<article class="doc-entry" id="doc-subsets-of-size">
<h3><a class="doc-anchor" href="#doc-subsets-of-size">#</a> <code>subsets_of_size</code></h3>
<p><code>subsets_of_size ARR, K</code> — all k-subsets of an arbitrary array.</p>
</article>
</section>
<section class="tutorial-section" id="ch-dynamic-programming">
<h2>Dynamic Programming</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-longest-increasing-subseq">
<h3><a class="doc-anchor" href="#doc-longest-increasing-subseq">#</a> <code>longest_increasing_subseq</code></h3>
<p><code>longest_increasing_subseq XS</code> — length only (O(n log n)).</p>
</article>
<article class="doc-entry" id="doc-knapsack-01">
<h3><a class="doc-anchor" href="#doc-knapsack-01">#</a> <code>knapsack_01</code></h3>
<p><code>knapsack_01 ITEMS, CAPACITY</code> — items as <code>[[w, v], …]</code>.</p>
</article>
<article class="doc-entry" id="doc-subset-sum-target">
<h3><a class="doc-anchor" href="#doc-subset-sum-target">#</a> <code>subset_sum_target</code></h3>
<p><code>subset_sum_target ARR, T</code> — 1 if any subset sums to T.</p>
</article>
<article class="doc-entry" id="doc-coin-change-min">
<h3><a class="doc-anchor" href="#doc-coin-change-min">#</a> <code>coin_change_min</code></h3>
<p><code>coin_change_min COINS, N</code> — min number of coins to make N (-1 if impossible).</p>
</article>
<article class="doc-entry" id="doc-edit-distance-levenshtein">
<h3><a class="doc-anchor" href="#doc-edit-distance-levenshtein">#</a> <code>edit_distance_levenshtein</code></h3>
<p><code>edit_distance A, B</code> — Levenshtein distance.</p>
</article>
</section>
<section class="tutorial-section" id="ch-ml-metrics">
<h2>ML Metrics</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-one-hot-encode">
<h3><a class="doc-anchor" href="#doc-one-hot-encode">#</a> <code>one_hot_encode</code></h3>
<p><code>one_hot_encode LABELS [, N_CLASSES]</code> → n×K matrix.</p>
</article>
<article class="doc-entry" id="doc-label-encode">
<h3><a class="doc-anchor" href="#doc-label-encode">#</a> <code>label_encode</code></h3>
<p><code>label_encode ARR</code> → <code>[indices, classes]</code>.</p>
</article>
<article class="doc-entry" id="doc-categorical-cross-entropy">
<h3><a class="doc-anchor" href="#doc-categorical-cross-entropy">#</a> <code>categorical_cross_entropy</code></h3>
<p><code>categorical_cross_entropy Y_TRUE, Y_PRED</code> — averaged over batch.</p>
</article>
<article class="doc-entry" id="doc-classification-metrics">
<h3><a class="doc-anchor" href="#doc-classification-metrics">#</a> <code>classification_metrics</code></h3>
<p><code>classification_metrics TP, FP, FN, TN</code> → <code>[acc, prec, recall, f1]</code>.</p>
</article>
<article class="doc-entry" id="doc-roc-auc">
<h3><a class="doc-anchor" href="#doc-roc-auc">#</a> <code>roc_auc</code></h3>
<p><code>roc_auc SCORES, LABELS</code> — Mann-Whitney U / (n+ n−).</p>
</article>
</section>
<section class="tutorial-section" id="ch-dsp-image-filters">
<h2>DSP / Image Filters</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-gaussian-blur-kernel">
<h3><a class="doc-anchor" href="#doc-gaussian-blur-kernel">#</a> <code>gaussian_blur_kernel</code></h3>
<p><code>gaussian_blur_kernel SIGMA [, RADIUS]</code> — 1-D normalized kernel.</p>
</article>
<article class="doc-entry" id="doc-sobel-x">
<h3><a class="doc-anchor" href="#doc-sobel-x">#</a> <code>sobel_x</code></h3>
<p><code>sobel_x</code> — horizontal Sobel kernel.</p>
</article>
<article class="doc-entry" id="doc-sobel-y">
<h3><a class="doc-anchor" href="#doc-sobel-y">#</a> <code>sobel_y</code></h3>
<p><code>sobel_y</code> — vertical Sobel kernel.</p>
</article>
<article class="doc-entry" id="doc-prewitt-x">
<h3><a class="doc-anchor" href="#doc-prewitt-x">#</a> <code>prewitt_x</code></h3>
<p><code>prewitt_x</code> — horizontal Prewitt.</p>
</article>
<article class="doc-entry" id="doc-prewitt-y">
<h3><a class="doc-anchor" href="#doc-prewitt-y">#</a> <code>prewitt_y</code></h3>
<p><code>prewitt_y</code> — vertical Prewitt.</p>
</article>
<article class="doc-entry" id="doc-laplacian-of-gaussian">
<h3><a class="doc-anchor" href="#doc-laplacian-of-gaussian">#</a> <code>laplacian_of_gaussian</code></h3>
<p><code>laplacian_of_gaussian SIGMA</code> — 2-D LoG kernel.</p>
</article>
</section>
<section class="tutorial-section" id="ch-stochastic-processes">
<h2>Stochastic Processes</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-brownian-path">
<h3><a class="doc-anchor" href="#doc-brownian-path">#</a> <code>brownian_path</code></h3>
<p><code>brownian_path T, N</code> — discrete Wiener path on [0, T].</p>
</article>
<article class="doc-entry" id="doc-geometric-brownian-path">
<h3><a class="doc-anchor" href="#doc-geometric-brownian-path">#</a> <code>geometric_brownian_path</code></h3>
<p><code>geometric_brownian_path S0, MU, SIGMA, T, N</code> — GBM sample path.</p>
</article>
<article class="doc-entry" id="doc-poisson-process">
<h3><a class="doc-anchor" href="#doc-poisson-process">#</a> <code>poisson_process</code></h3>
<p><code>poisson_process LAMBDA, T</code> — homogeneous Poisson arrival times.</p>
</article>
<article class="doc-entry" id="doc-random-walk-1d">
<h3><a class="doc-anchor" href="#doc-random-walk-1d">#</a> <code>random_walk_1d</code></h3>
<p><code>random_walk_1d N [, P]</code> — ±1 walk over N steps.</p>
</article>
</section>
<section class="tutorial-section" id="ch-compression-information-complexity">
<h2>Compression / Information Complexity</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-lempel-ziv-complexity">
<h3><a class="doc-anchor" href="#doc-lempel-ziv-complexity">#</a> <code>lempel_ziv_complexity</code></h3>
<p><code>lempel_ziv_complexity SEQ</code> — LZ76 production count.</p>
</article>
<article class="doc-entry" id="doc-huffman-code-lengths">
<h3><a class="doc-anchor" href="#doc-huffman-code-lengths">#</a> <code>huffman_code_lengths</code></h3>
<p><code>huffman_code_lengths FREQS</code> — code-length per symbol.</p>
</article>
<article class="doc-entry" id="doc-shannon-entropy-rate">
<h3><a class="doc-anchor" href="#doc-shannon-entropy-rate">#</a> <code>shannon_entropy_rate</code></h3>
<p><code>shannon_entropy_rate SEQ [, M]</code> — H_m − H_{m-1} block estimate.</p>
</article>
</section>
<section class="tutorial-section" id="ch-physics-quantum-extended">
<h2>Physics & Quantum (Extended)</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-planck-blackbody">
<h3><a class="doc-anchor" href="#doc-planck-blackbody">#</a> <code>planck_blackbody</code></h3>
<p><code>planck_blackbody LAMBDA, T</code> — spectral radiance B(λ, T).</p>
</article>
<article class="doc-entry" id="doc-rayleigh-jeans">
<h3><a class="doc-anchor" href="#doc-rayleigh-jeans">#</a> <code>rayleigh_jeans</code></h3>
<p><code>rayleigh_jeans LAMBDA, T</code> — long-wavelength approx.</p>
</article>
<article class="doc-entry" id="doc-compton-shift">
<h3><a class="doc-anchor" href="#doc-compton-shift">#</a> <code>compton_shift</code></h3>
<p><code>compton_shift THETA</code> — photon wavelength shift Δλ = (h/m_e c)(1-cosθ).</p>
</article>
<article class="doc-entry" id="doc-rydberg-energy">
<h3><a class="doc-anchor" href="#doc-rydberg-energy">#</a> <code>rydberg_energy</code></h3>
<p><code>rydberg_energy N</code> — hydrogen level energy −13.605693/n² eV.</p>
</article>
<article class="doc-entry" id="doc-hydrogen-radial-wavefunction">
<h3><a class="doc-anchor" href="#doc-hydrogen-radial-wavefunction">#</a> <code>hydrogen_radial_wavefunction</code></h3>
<p><code>hydrogen_radial_wavefunction N, L, R</code> — atomic-units R_{n,l}(r).</p>
</article>
</section>
<section class="tutorial-section" id="ch-number-theory-algebra-extended">
<h2>Number Theory & Algebra (Extended)</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-integer-log">
<h3><a class="doc-anchor" href="#doc-integer-log">#</a> <code>integer_log</code></h3>
<p><code>integer_log N [, BASE]</code> — largest k with base^k ≤ n.</p>
</article>
<article class="doc-entry" id="doc-aks-primality">
<h3><a class="doc-anchor" href="#doc-aks-primality">#</a> <code>aks_primality</code></h3>
<p><code>aks_primality N</code> — deterministic primality (perfect-power + small-factor + Miller-Rabin fallback).</p>
</article>
<article class="doc-entry" id="doc-elliptic-curve-add">
<h3><a class="doc-anchor" href="#doc-elliptic-curve-add">#</a> <code>elliptic_curve_add</code></h3>
<p><code>elliptic_curve_add P, Q, A, B</code> — group law on y² = x³ + a x + b. Identity = <code>[NaN, NaN]</code>.</p>
</article>
<article class="doc-entry" id="doc-berlekamp-massey">
<h3><a class="doc-anchor" href="#doc-berlekamp-massey">#</a> <code>berlekamp_massey</code></h3>
<p><code>berlekamp_massey SEQ</code> — minimal-LFSR connection-polynomial coefficients.</p>
</article>
<article class="doc-entry" id="doc-bezout-coefficients">
<h3><a class="doc-anchor" href="#doc-bezout-coefficients">#</a> <code>bezout_coefficients</code></h3>
<p><code>bezout_coefficients A, B</code> → <code>[gcd, x, y]</code> with a x + b y = gcd.</p>
</article>
</section>
<section class="tutorial-section" id="ch-cas-lite">
<h2>CAS-Lite</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-factor-quadratic">
<h3><a class="doc-anchor" href="#doc-factor-quadratic">#</a> <code>factor_quadratic</code></h3>
<p><code>factor_quadratic A, B, C</code> — real roots of a x² + b x + c = 0.</p>
</article>
<article class="doc-entry" id="doc-complete-square">
<h3><a class="doc-anchor" href="#doc-complete-square">#</a> <code>complete_square</code></h3>
<p><code>complete_square A, B, C</code> → <code>[h, k]</code> for a (x-h)² + k.</p>
</article>
<article class="doc-entry" id="doc-partial-fraction-simple">
<h3><a class="doc-anchor" href="#doc-partial-fraction-simple">#</a> <code>partial_fraction_simple</code></h3>
<p><code>partial_fraction_simple NUM, ROOTS</code> — Heaviside cover-up residues.</p>
</article>
</section>
<section class="tutorial-section" id="ch-quadrature-specialised">
<h2>Quadrature (Specialised)</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-gauss-chebyshev-quad">
<h3><a class="doc-anchor" href="#doc-gauss-chebyshev-quad">#</a> <code>gauss_chebyshev_quad</code></h3>
<p><code>gauss_chebyshev_quad F [, N]</code> — ∫_{-1}^1 f(x)/√(1-x²) dx (default N=16).</p>
</article>
<article class="doc-entry" id="doc-gauss-hermite-quad">
<h3><a class="doc-anchor" href="#doc-gauss-hermite-quad">#</a> <code>gauss_hermite_quad</code></h3>
<p><code>gauss_hermite_quad F [, N]</code> — ∫_{-∞}^∞ f(x) e^{-x²} dx (default N=20).</p>
</article>
<article class="doc-entry" id="doc-gauss-laguerre-quad">
<h3><a class="doc-anchor" href="#doc-gauss-laguerre-quad">#</a> <code>gauss_laguerre_quad</code></h3>
<p><code>gauss_laguerre_quad F [, N]</code> — ∫_0^∞ f(x) e^{-x} dx (default N=20).</p>
</article>
<article class="doc-entry" id="doc-clenshaw-curtis-quad">
<h3><a class="doc-anchor" href="#doc-clenshaw-curtis-quad">#</a> <code>clenshaw_curtis_quad</code></h3>
<p><code>clenshaw_curtis_quad F, A, B [, N]</code> — Chebyshev-node quadrature.</p>
</article>
<article class="doc-entry" id="doc-tanh-sinh-quad">
<h3><a class="doc-anchor" href="#doc-tanh-sinh-quad">#</a> <code>tanh_sinh_quad</code></h3>
<p><code>tanh_sinh_quad F, A, B [, LEVELS]</code> — double-exponential quadrature.</p>
</article>
<article class="doc-entry" id="doc-gauss-legendre-2d">
<h3><a class="doc-anchor" href="#doc-gauss-legendre-2d">#</a> <code>gauss_legendre_2d</code></h3>
<p><code>gauss_legendre_2d F, AX, BX, AY, BY [, N]</code> — Cartesian-product GL.</p>
</article>
<article class="doc-entry" id="doc-monte-carlo-2d">
<h3><a class="doc-anchor" href="#doc-monte-carlo-2d">#</a> <code>monte_carlo_2d</code></h3>
<p><code>monte_carlo_2d F, AX, BX, AY, BY [, N]</code> — uniform Monte Carlo on a rectangle.</p>
</article>
</section>
<section class="tutorial-section" id="ch-optimization-heuristic">
<h2>Optimization (Heuristic)</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-simulated-annealing">
<h3><a class="doc-anchor" href="#doc-simulated-annealing">#</a> <code>simulated_annealing</code></h3>
<p><code>simulated_annealing F, X0 [, T0, COOL, ITERS, STEP]</code> — Metropolis-Hastings minimisation.</p>
</article>
<article class="doc-entry" id="doc-simplex-lp">
<h3><a class="doc-anchor" href="#doc-simplex-lp">#</a> <code>simplex_lp</code></h3>
<p><code>simplex_lp C, A, B</code> — max cᵀx s.t. Ax ≤ b, x ≥ 0. Returns <code>[x, value]</code>.</p>
</article>
<article class="doc-entry" id="doc-particle-swarm">
<h3><a class="doc-anchor" href="#doc-particle-swarm">#</a> <code>particle_swarm</code></h3>
<p><code>particle_swarm F, BOUNDS, SWARM, ITERS</code> — constriction-coefficient PSO.</p>
</article>
</section>
<section class="tutorial-section" id="ch-distributions-tail-mixture-categorical">
<h2>Distributions (Tail / Mixture / Categorical)</h2>
<p class="chapter-meta">14 topics</p>
<article class="doc-entry" id="doc-gev-pdf">
<h3><a class="doc-anchor" href="#doc-gev-pdf">#</a> <code>gev_pdf</code></h3>
<p><code>gev_pdf X, MU, SIGMA, XI</code> — Generalised Extreme Value PDF.</p>
</article>
<article class="doc-entry" id="doc-gev-cdf">
<h3><a class="doc-anchor" href="#doc-gev-cdf">#</a> <code>gev_cdf</code></h3>
<p><code>gev_cdf X, MU, SIGMA, XI</code> — GEV CDF.</p>
</article>
<article class="doc-entry" id="doc-gev-sample">
<h3><a class="doc-anchor" href="#doc-gev-sample">#</a> <code>gev_sample</code></h3>
<p><code>gev_sample MU, SIGMA, XI</code> — GEV sample.</p>
</article>
<article class="doc-entry" id="doc-gen-pareto-pdf">
<h3><a class="doc-anchor" href="#doc-gen-pareto-pdf">#</a> <code>gen_pareto_pdf</code></h3>
<p><code>gen_pareto_pdf X, MU, SIGMA, XI</code> — Generalised Pareto PDF.</p>
</article>
<article class="doc-entry" id="doc-gen-pareto-cdf">
<h3><a class="doc-anchor" href="#doc-gen-pareto-cdf">#</a> <code>gen_pareto_cdf</code></h3>
<p><code>gen_pareto_cdf X, MU, SIGMA, XI</code> — GP CDF.</p>
</article>
<article class="doc-entry" id="doc-gen-pareto-sample">
<h3><a class="doc-anchor" href="#doc-gen-pareto-sample">#</a> <code>gen_pareto_sample</code></h3>
<p><code>gen_pareto_sample MU, SIGMA, XI</code> — GP sample.</p>
</article>
<article class="doc-entry" id="doc-skew-normal-pdf">
<h3><a class="doc-anchor" href="#doc-skew-normal-pdf">#</a> <code>skew_normal_pdf</code></h3>
<p><code>skew_normal_pdf X, XI, OMEGA, ALPHA</code> — Azzalini skew-normal PDF.</p>
</article>
<article class="doc-entry" id="doc-skew-normal-cdf">
<h3><a class="doc-anchor" href="#doc-skew-normal-cdf">#</a> <code>skew_normal_cdf</code></h3>
<p><code>skew_normal_cdf X, XI, OMEGA, ALPHA</code> — skew-normal CDF (numeric integration).</p>
</article>
<article class="doc-entry" id="doc-mixture-normal-pdf">
<h3><a class="doc-anchor" href="#doc-mixture-normal-pdf">#</a> <code>mixture_normal_pdf</code></h3>
<p><code>mixture_normal_pdf X, WEIGHTS, MEANS, STDS</code> — Gaussian-mixture PDF.</p>
</article>
<article class="doc-entry" id="doc-categorical-sample">
<h3><a class="doc-anchor" href="#doc-categorical-sample">#</a> <code>categorical_sample</code></h3>
<p><code>categorical_sample PROBS</code> — sample category index.</p>
</article>
<article class="doc-entry" id="doc-multinomial-pmf">
<h3><a class="doc-anchor" href="#doc-multinomial-pmf">#</a> <code>multinomial_pmf</code></h3>
<p><code>multinomial_pmf COUNTS, PROBS</code> — multinomial PMF.</p>
</article>
<article class="doc-entry" id="doc-multinomial-sample">
<h3><a class="doc-anchor" href="#doc-multinomial-sample">#</a> <code>multinomial_sample</code></h3>
<p><code>multinomial_sample N, PROBS</code> — multinomial counts vector.</p>
</article>
<article class="doc-entry" id="doc-truncated-normal-pdf">
<h3><a class="doc-anchor" href="#doc-truncated-normal-pdf">#</a> <code>truncated_normal_pdf</code></h3>
<p><code>truncated_normal_pdf X, MU, SIGMA, LO, HI</code> — truncated-normal PDF.</p>
</article>
<article class="doc-entry" id="doc-truncated-normal-sample">
<h3><a class="doc-anchor" href="#doc-truncated-normal-sample">#</a> <code>truncated_normal_sample</code></h3>
<p><code>truncated_normal_sample MU, SIGMA, LO, HI</code> — rejection sampler.</p>
</article>
</section>
<section class="tutorial-section" id="ch-clustering-dimensionality-reduction">
<h2>Clustering & Dimensionality Reduction</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-dbscan">
<h3><a class="doc-anchor" href="#doc-dbscan">#</a> <code>dbscan</code></h3>
<p><code>dbscan POINTS, EPS, MIN_PTS</code> — density-based clustering. Returns label per point (-1 = noise).</p>
</article>
<article class="doc-entry" id="doc-gmm-em-1d">
<h3><a class="doc-anchor" href="#doc-gmm-em-1d">#</a> <code>gmm_em_1d</code></h3>
<p><code>gmm_em_1d DATA, K [, MAX_ITER]</code> — 1-D Gaussian-mixture EM. Returns <code>[π, μ, σ]</code>.</p>
</article>
<article class="doc-entry" id="doc-silhouette-score">
<h3><a class="doc-anchor" href="#doc-silhouette-score">#</a> <code>silhouette_score</code></h3>
<p><code>silhouette_score POINTS, LABELS</code> — mean silhouette coefficient.</p>
</article>
<article class="doc-entry" id="doc-davies-bouldin-index">
<h3><a class="doc-anchor" href="#doc-davies-bouldin-index">#</a> <code>davies_bouldin_index</code></h3>
<p><code>davies_bouldin_index POINTS, LABELS</code> — lower is better.</p>
</article>
<article class="doc-entry" id="doc-calinski-harabasz-index">
<h3><a class="doc-anchor" href="#doc-calinski-harabasz-index">#</a> <code>calinski_harabasz_index</code></h3>
<p><code>calinski_harabasz_index POINTS, LABELS</code> — higher is better.</p>
</article>
<article class="doc-entry" id="doc-mds-2d">
<h3><a class="doc-anchor" href="#doc-mds-2d">#</a> <code>mds_2d</code></h3>
<p><code>mds_2d D</code> — classical multidimensional scaling on a distance matrix → 2-D coords.</p>
</article>
<article class="doc-entry" id="doc-mean-shift">
<h3><a class="doc-anchor" href="#doc-mean-shift">#</a> <code>mean_shift</code></h3>
<p><code>mean_shift POINTS [, BANDWIDTH, MAX_ITER]</code> — non-parametric mode-seeking.</p>
</article>
</section>
<section class="tutorial-section" id="ch-neural-net-primitives">
<h2>Neural-Net Primitives</h2>
<p class="chapter-meta">11 topics</p>
<article class="doc-entry" id="doc-batch-norm">
<h3><a class="doc-anchor" href="#doc-batch-norm">#</a> <code>batch_norm</code></h3>
<p><code>batch_norm XS [, EPS]</code> — zero-mean unit-variance normalisation.</p>
</article>
<article class="doc-entry" id="doc-layer-norm">
<h3><a class="doc-anchor" href="#doc-layer-norm">#</a> <code>layer_norm</code></h3>
<p><code>layer_norm XS [, EPS]</code> — alias for batch_norm (per-sample reuse).</p>
</article>
<article class="doc-entry" id="doc-dropout-mask">
<h3><a class="doc-anchor" href="#doc-dropout-mask">#</a> <code>dropout_mask</code></h3>
<p><code>dropout_mask N [, P]</code> — Bernoulli dropout mask scaled by 1/(1−p).</p>
</article>
<article class="doc-entry" id="doc-max-pool-1d">
<h3><a class="doc-anchor" href="#doc-max-pool-1d">#</a> <code>max_pool_1d</code></h3>
<p><code>max_pool_1d XS [, WIN]</code> — non-overlapping max-pool.</p>
</article>
<article class="doc-entry" id="doc-avg-pool-1d">
<h3><a class="doc-anchor" href="#doc-avg-pool-1d">#</a> <code>avg_pool_1d</code></h3>
<p><code>avg_pool_1d XS [, WIN]</code> — non-overlapping average-pool.</p>
</article>
<article class="doc-entry" id="doc-attention-softmax">
<h3><a class="doc-anchor" href="#doc-attention-softmax">#</a> <code>attention_softmax</code></h3>
<p><code>attention_softmax XS</code> — numerically stable softmax.</p>
</article>
<article class="doc-entry" id="doc-positional-encoding">
<h3><a class="doc-anchor" href="#doc-positional-encoding">#</a> <code>positional_encoding</code></h3>
<p><code>positional_encoding LENGTH, D_MODEL</code> — sinusoidal Transformer encoding.</p>
</article>
<article class="doc-entry" id="doc-glorot-init">
<h3><a class="doc-anchor" href="#doc-glorot-init">#</a> <code>glorot_init</code></h3>
<p><code>glorot_init FAN_IN, FAN_OUT</code> — Glorot uniform.</p>
</article>
<article class="doc-entry" id="doc-he-init">
<h3><a class="doc-anchor" href="#doc-he-init">#</a> <code>he_init</code></h3>
<p><code>he_init FAN_IN, FAN_OUT</code> — Gaussian (std = √(2/fan_in)).</p>
</article>
<article class="doc-entry" id="doc-adam-step">
<h3><a class="doc-anchor" href="#doc-adam-step">#</a> <code>adam_step</code></h3>
<p><code>adam_step PARAM, GRAD, M, V, LR, B1, B2, EPS, T</code> → <code>[param', m', v']</code>.</p>
</article>
<article class="doc-entry" id="doc-rmsprop-step">
<h3><a class="doc-anchor" href="#doc-rmsprop-step">#</a> <code>rmsprop_step</code></h3>
<p><code>rmsprop_step PARAM, GRAD, V, LR, DECAY, EPS</code> → <code>[param', v']</code>.</p>
</article>
</section>
<section class="tutorial-section" id="ch-time-series-spectral">
<h2>Time Series (Spectral)</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-ewma">
<h3><a class="doc-anchor" href="#doc-ewma">#</a> <code>ewma</code></h3>
<p><code>ewma XS [, ALPHA]</code> — exponentially-weighted moving average.</p>
</article>
<article class="doc-entry" id="doc-ccf">
<h3><a class="doc-anchor" href="#doc-ccf">#</a> <code>ccf</code></h3>
<p><code>ccf XS, YS [, MAX_LAG]</code> — sample cross-correlation function over -L..L lags.</p>
</article>
<article class="doc-entry" id="doc-periodogram">
<h3><a class="doc-anchor" href="#doc-periodogram">#</a> <code>periodogram</code></h3>
<p><code>periodogram XS</code> — squared-magnitude DFT / N (one-sided spectrum).</p>
</article>
<article class="doc-entry" id="doc-welch-psd">
<h3><a class="doc-anchor" href="#doc-welch-psd">#</a> <code>welch_psd</code></h3>
<p><code>welch_psd XS [, SEG_LEN, OVERLAP]</code> — Welch's PSD via Hann segments.</p>
</article>
<article class="doc-entry" id="doc-lag-features">
<h3><a class="doc-anchor" href="#doc-lag-features">#</a> <code>lag_features</code></h3>
<p><code>lag_features XS, P</code> — design matrix of P lagged features.</p>
</article>
</section>
<section class="tutorial-section" id="ch-image-processing">
<h2>Image Processing</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-median-filter-2d">
<h3><a class="doc-anchor" href="#doc-median-filter-2d">#</a> <code>median_filter_2d</code></h3>
<p><code>median_filter_2d IMG [, RADIUS]</code> — denoising median filter.</p>
</article>
<article class="doc-entry" id="doc-threshold-otsu">
<h3><a class="doc-anchor" href="#doc-threshold-otsu">#</a> <code>threshold_otsu</code></h3>
<p><code>threshold_otsu IMG</code> — Otsu's optimal threshold for 0..255 grayscale.</p>
</article>
<article class="doc-entry" id="doc-histogram-equalize">
<h3><a class="doc-anchor" href="#doc-histogram-equalize">#</a> <code>histogram_equalize</code></h3>
<p><code>histogram_equalize IMG</code> — global histogram equalisation.</p>
</article>
<article class="doc-entry" id="doc-erode-2d">
<h3><a class="doc-anchor" href="#doc-erode-2d">#</a> <code>erode_2d</code></h3>
<p><code>erode_2d IMG [, RADIUS]</code> — morphological erosion (square structuring element).</p>
</article>
<article class="doc-entry" id="doc-dilate-2d">
<h3><a class="doc-anchor" href="#doc-dilate-2d">#</a> <code>dilate_2d</code></h3>
<p><code>dilate_2d IMG [, RADIUS]</code> — morphological dilation.</p>
</article>
</section>
<section class="tutorial-section" id="ch-loss-functions">
<h2>Loss Functions</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-mse-loss">
<h3><a class="doc-anchor" href="#doc-mse-loss">#</a> <code>mse_loss</code></h3>
<p><code>mse_loss A, B</code> — mean-squared error.</p>
</article>
<article class="doc-entry" id="doc-mae-loss">
<h3><a class="doc-anchor" href="#doc-mae-loss">#</a> <code>mae_loss</code></h3>
<p><code>mae_loss A, B</code> — mean-absolute error.</p>
</article>
<article class="doc-entry" id="doc-huber-loss">
<h3><a class="doc-anchor" href="#doc-huber-loss">#</a> <code>huber_loss</code></h3>
<p><code>huber_loss A, B [, DELTA]</code> — Huber loss (default δ=1).</p>
</article>
</section>
<section class="tutorial-section" id="ch-spatial-geographic">
<h2>Spatial / Geographic</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-vincenty-distance">
<h3><a class="doc-anchor" href="#doc-vincenty-distance">#</a> <code>vincenty_distance</code></h3>
<p><code>vincenty_distance LAT1, LON1, LAT2, LON2</code> — geodesic distance on WGS-84.</p>
</article>
<article class="doc-entry" id="doc-mercator-project">
<h3><a class="doc-anchor" href="#doc-mercator-project">#</a> <code>mercator_project</code></h3>
<p><code>mercator_project LAT, LON [, R]</code> → <code>[x, y]</code> Mercator metres.</p>
</article>
<article class="doc-entry" id="doc-destination-from-bearing">
<h3><a class="doc-anchor" href="#doc-destination-from-bearing">#</a> <code>destination_from_bearing</code></h3>
<p><code>destination_from_bearing LAT, LON, BEARING_DEG, DIST_M [, R]</code> — spherical great-circle target.</p>
</article>
</section>
<section class="tutorial-section" id="ch-integer-sequences">
<h2>Integer Sequences</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-recaman">
<h3><a class="doc-anchor" href="#doc-recaman">#</a> <code>recaman</code></h3>
<p><code>recaman N</code> — first N terms of Recamán's sequence.</p>
</article>
<article class="doc-entry" id="doc-sylvester">
<h3><a class="doc-anchor" href="#doc-sylvester">#</a> <code>sylvester</code></h3>
<p><code>sylvester N</code> — Sylvester's sequence (a_n = a_{n-1}² − a_{n-1} + 1).</p>
</article>
<article class="doc-entry" id="doc-happy-q">
<h3><a class="doc-anchor" href="#doc-happy-q">#</a> <code>happy_q</code></h3>
<p><code>happy_q N</code> — 1 if N is a happy number.</p>
</article>
<article class="doc-entry" id="doc-amicable-pair-q">
<h3><a class="doc-anchor" href="#doc-amicable-pair-q">#</a> <code>amicable_pair_q</code></h3>
<p><code>amicable_pair_q A, B</code> — 1 if (a, b) is an amicable pair.</p>
</article>
<article class="doc-entry" id="doc-aliquot-sequence">
<h3><a class="doc-anchor" href="#doc-aliquot-sequence">#</a> <code>aliquot_sequence</code></h3>
<p><code>aliquot_sequence N [, MAX_STEPS]</code> — sum-of-proper-divisors trajectory.</p>
</article>
<article class="doc-entry" id="doc-magic-constant">
<h3><a class="doc-anchor" href="#doc-magic-constant">#</a> <code>magic_constant</code></h3>
<p><code>magic_constant N</code> — n(n²+1)/2 (sum of any line of an n×n magic square).</p>
</article>
</section>
<section class="tutorial-section" id="ch-graph-link-cluster-metrics">
<h2>Graph Link & Cluster Metrics</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-clustering-coefficient-local">
<h3><a class="doc-anchor" href="#doc-clustering-coefficient-local">#</a> <code>clustering_coefficient_local</code></h3>
<p><code>clustering_coefficient_local ADJ</code> — local CC per vertex.</p>
</article>
<article class="doc-entry" id="doc-clustering-coefficient-global">
<h3><a class="doc-anchor" href="#doc-clustering-coefficient-global">#</a> <code>clustering_coefficient_global</code></h3>
<p><code>clustering_coefficient_global ADJ</code> — mean local CC.</p>
</article>
<article class="doc-entry" id="doc-assortativity">
<h3><a class="doc-anchor" href="#doc-assortativity">#</a> <code>assortativity</code></h3>
<p><code>assortativity ADJ</code> — degree-degree correlation coefficient.</p>
</article>
<article class="doc-entry" id="doc-common-neighbors">
<h3><a class="doc-anchor" href="#doc-common-neighbors">#</a> <code>common_neighbors</code></h3>
<p><code>common_neighbors ADJ, U, V</code> — count.</p>
</article>
<article class="doc-entry" id="doc-jaccard-neighbors">
<h3><a class="doc-anchor" href="#doc-jaccard-neighbors">#</a> <code>jaccard_neighbors</code></h3>
<p><code>jaccard_neighbors ADJ, U, V</code> — |Γ(u) ∩ Γ(v)| / |Γ(u) ∪ Γ(v)|.</p>
</article>
<article class="doc-entry" id="doc-adamic-adar">
<h3><a class="doc-anchor" href="#doc-adamic-adar">#</a> <code>adamic_adar</code></h3>
<p><code>adamic_adar ADJ, U, V</code> — Σ 1/log(deg(w)) over common neighbours w.</p>
</article>
<article class="doc-entry" id="doc-preferential-attachment-score">
<h3><a class="doc-anchor" href="#doc-preferential-attachment-score">#</a> <code>preferential_attachment_score</code></h3>
<p><code>preferential_attachment_score ADJ, U, V</code> — deg(u)·deg(v).</p>
</article>
</section>
<section class="tutorial-section" id="ch-3-d-geometry">
<h2>3-D Geometry</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-triangle-3d-normal">
<h3><a class="doc-anchor" href="#doc-triangle-3d-normal">#</a> <code>triangle_3d_normal</code></h3>
<p><code>triangle_3d_normal P1, P2, P3</code> — unit normal.</p>
</article>
<article class="doc-entry" id="doc-triangle-3d-area">
<h3><a class="doc-anchor" href="#doc-triangle-3d-area">#</a> <code>triangle_3d_area</code></h3>
<p><code>triangle_3d_area P1, P2, P3</code> — area via cross product.</p>
</article>
<article class="doc-entry" id="doc-tetrahedron-volume">
<h3><a class="doc-anchor" href="#doc-tetrahedron-volume">#</a> <code>tetrahedron_volume</code></h3>
<p><code>tetrahedron_volume A, B, C, D</code> — |det(B-A, C-A, D-A)|/6.</p>
</article>
<article class="doc-entry" id="doc-plane-from-3-points">
<h3><a class="doc-anchor" href="#doc-plane-from-3-points">#</a> <code>plane_from_3_points</code></h3>
<p><code>plane_from_3_points P1, P2, P3</code> → <code>[a, b, c, d]</code> (a x + b y + c z + d = 0).</p>
</article>
<article class="doc-entry" id="doc-point-to-plane-distance">
<h3><a class="doc-anchor" href="#doc-point-to-plane-distance">#</a> <code>point_to_plane_distance</code></h3>
<p><code>point_to_plane_distance P, [a, b, c, d]</code>.</p>
</article>
<article class="doc-entry" id="doc-ray-triangle-intersect">
<h3><a class="doc-anchor" href="#doc-ray-triangle-intersect">#</a> <code>ray_triangle_intersect</code></h3>
<p><code>ray_triangle_intersect O, D, A, B, C</code> — Möller-Trumbore. Returns t or NaN.</p>
</article>
<article class="doc-entry" id="doc-ray-sphere-intersect">
<h3><a class="doc-anchor" href="#doc-ray-sphere-intersect">#</a> <code>ray_sphere_intersect</code></h3>
<p><code>ray_sphere_intersect O, D, CENTER, RADIUS</code> — nearest non-negative t.</p>
</article>
<article class="doc-entry" id="doc-aabb-overlap">
<h3><a class="doc-anchor" href="#doc-aabb-overlap">#</a> <code>aabb_overlap</code></h3>
<p><code>aabb_overlap A_MIN, A_MAX, B_MIN, B_MAX</code> — 1 if 3-D AABBs overlap.</p>
</article>
</section>
<section class="tutorial-section" id="ch-iterative-solvers">
<h2>Iterative Solvers</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-gauss-seidel">
<h3><a class="doc-anchor" href="#doc-gauss-seidel">#</a> <code>gauss_seidel</code></h3>
<p><code>gauss_seidel A, B [, MAX_ITER, TOL]</code> — Gauss-Seidel iterative solver.</p>
</article>
<article class="doc-entry" id="doc-jacobi-iteration">
<h3><a class="doc-anchor" href="#doc-jacobi-iteration">#</a> <code>jacobi_iteration</code></h3>
<p><code>jacobi_iteration A, B [, MAX_ITER, TOL]</code> — Jacobi iteration.</p>
</article>
<article class="doc-entry" id="doc-sor-solve">
<h3><a class="doc-anchor" href="#doc-sor-solve">#</a> <code>sor_solve</code></h3>
<p><code>sor_solve A, B [, OMEGA, MAX_ITER, TOL]</code> — Successive Over-Relaxation.</p>
</article>
<article class="doc-entry" id="doc-thomas-tridiag-solve">
<h3><a class="doc-anchor" href="#doc-thomas-tridiag-solve">#</a> <code>thomas_tridiag_solve</code></h3>
<p><code>thomas_tridiag_solve A_SUB, B_MAIN, C_SUP, D</code> — tridiagonal direct solve.</p>
</article>
<article class="doc-entry" id="doc-richardson-extrapolation">
<h3><a class="doc-anchor" href="#doc-richardson-extrapolation">#</a> <code>richardson_extrapolation</code></h3>
<p><code>richardson_extrapolation F, H0 [, LEVELS]</code> — Romberg-style extrapolation.</p>
</article>
<article class="doc-entry" id="doc-finite-difference-5pt">
<h3><a class="doc-anchor" href="#doc-finite-difference-5pt">#</a> <code>finite_difference_5pt</code></h3>
<p><code>finite_difference_5pt F, X [, H]</code> — five-point central derivative.</p>
</article>
</section>
<section class="tutorial-section" id="ch-crypto-modular-algebra">
<h2>Crypto / Modular Algebra</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-tonelli-shanks-sqrt">
<h3><a class="doc-anchor" href="#doc-tonelli-shanks-sqrt">#</a> <code>tonelli_shanks_sqrt</code></h3>
<p><code>tonelli_shanks_sqrt N, P</code> — modular square root mod prime p.</p>
</article>
<article class="doc-entry" id="doc-baby-step-giant-step">
<h3><a class="doc-anchor" href="#doc-baby-step-giant-step">#</a> <code>baby_step_giant_step</code></h3>
<p><code>baby_step_giant_step G, H, P</code> — discrete logarithm mod p.</p>
</article>
<article class="doc-entry" id="doc-pollard-rho-factor">
<h3><a class="doc-anchor" href="#doc-pollard-rho-factor">#</a> <code>pollard_rho_factor</code></h3>
<p><code>pollard_rho_factor N</code> — return a non-trivial factor of N.</p>
</article>
<article class="doc-entry" id="doc-modular-lcm">
<h3><a class="doc-anchor" href="#doc-modular-lcm">#</a> <code>modular_lcm</code></h3>
<p><code>modular_lcm XS</code> — LCM via gcd.</p>
</article>
<article class="doc-entry" id="doc-crt-general">
<h3><a class="doc-anchor" href="#doc-crt-general">#</a> <code>crt_general</code></h3>
<p><code>crt_general REMAINDERS, MODULI</code> — CRT over arbitrary (not coprime) moduli; -1 if infeasible.</p>
</article>
</section>
<section class="tutorial-section" id="ch-physics-chemistry">
<h2>Physics & Chemistry</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-van-der-waals-p">
<h3><a class="doc-anchor" href="#doc-van-der-waals-p">#</a> <code>van_der_waals_p</code></h3>
<p><code>van_der_waals_p N, T, V, A, B</code> — pressure from Van der Waals equation.</p>
</article>
<article class="doc-entry" id="doc-nernst-equation">
<h3><a class="doc-anchor" href="#doc-nernst-equation">#</a> <code>nernst_equation</code></h3>
<p><code>nernst_equation E0, N, T, Q</code> — half-cell potential.</p>
</article>
<article class="doc-entry" id="doc-arrhenius-rate">
<h3><a class="doc-anchor" href="#doc-arrhenius-rate">#</a> <code>arrhenius_rate</code></h3>
<p><code>arrhenius_rate A, EA, T</code> — k = A exp(-Ea / RT).</p>
</article>
<article class="doc-entry" id="doc-reduced-mass">
<h3><a class="doc-anchor" href="#doc-reduced-mass">#</a> <code>reduced_mass</code></h3>
<p><code>reduced_mass M1, M2</code> — μ = m1 m2 / (m1 + m2).</p>
</article>
<article class="doc-entry" id="doc-ph-to-concentration">
<h3><a class="doc-anchor" href="#doc-ph-to-concentration">#</a> <code>ph_to_concentration</code></h3>
<p><code>ph_to_concentration PH</code> — [H⁺] = 10^{-pH}.</p>
</article>
</section>
<section class="tutorial-section" id="ch-mcmc-sdes">
<h2>MCMC & SDEs</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-metropolis-hastings">
<h3><a class="doc-anchor" href="#doc-metropolis-hastings">#</a> <code>metropolis_hastings</code></h3>
<p><code>metropolis_hastings LOG_PI, X0, SIGMA, ITERS [, BURN_IN]</code> — random-walk MH.</p>
</article>
<article class="doc-entry" id="doc-gibbs-sampler-step">
<h3><a class="doc-anchor" href="#doc-gibbs-sampler-step">#</a> <code>gibbs_sampler_step</code></h3>
<p><code>gibbs_sampler_step COND_SAMPLERS, X</code> — one Gibbs sweep over coordinates.</p>
</article>
<article class="doc-entry" id="doc-euler-maruyama">
<h3><a class="doc-anchor" href="#doc-euler-maruyama">#</a> <code>euler_maruyama</code></h3>
<p><code>euler_maruyama MU, SIGMA, X0, T0, T_END, N_STEPS</code> — Euler-Maruyama SDE integrator.</p>
</article>
<article class="doc-entry" id="doc-milstein">
<h3><a class="doc-anchor" href="#doc-milstein">#</a> <code>milstein</code></h3>
<p><code>milstein MU, SIGMA, SIGMA_X, X0, T0, T_END, N_STEPS</code> — Milstein scheme.</p>
</article>
<article class="doc-entry" id="doc-ornstein-uhlenbeck-path">
<h3><a class="doc-anchor" href="#doc-ornstein-uhlenbeck-path">#</a> <code>ornstein_uhlenbeck_path</code></h3>
<p><code>ornstein_uhlenbeck_path THETA, MU, SIGMA, X0, T, N</code> — exact OU sample path.</p>
</article>
</section>
<section class="tutorial-section" id="ch-hidden-markov-models">
<h2>Hidden Markov Models</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-hmm-forward">
<h3><a class="doc-anchor" href="#doc-hmm-forward">#</a> <code>hmm_forward</code></h3>
<p><code>hmm_forward PI, A, B, OBS</code> — log P(O | λ).</p>
</article>
<article class="doc-entry" id="doc-hmm-viterbi">
<h3><a class="doc-anchor" href="#doc-hmm-viterbi">#</a> <code>hmm_viterbi</code></h3>
<p><code>hmm_viterbi PI, A, B, OBS</code> — most-likely state path.</p>
</article>
<article class="doc-entry" id="doc-hmm-backward">
<h3><a class="doc-anchor" href="#doc-hmm-backward">#</a> <code>hmm_backward</code></h3>
<p><code>hmm_backward PI, A, B, OBS</code> — backward β matrix.</p>
</article>
</section>
<section class="tutorial-section" id="ch-survival-analysis">
<h2>Survival Analysis</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-kaplan-meier">
<h3><a class="doc-anchor" href="#doc-kaplan-meier">#</a> <code>kaplan_meier</code></h3>
<p><code>kaplan_meier TIMES, EVENTS</code> → matrix of [t, S(t)].</p>
</article>
<article class="doc-entry" id="doc-log-rank-test">
<h3><a class="doc-anchor" href="#doc-log-rank-test">#</a> <code>log_rank_test</code></h3>
<p><code>log_rank_test T1, E1, T2, E2</code> → <code>[chi², p]</code>.</p>
</article>
</section>
<section class="tutorial-section" id="ch-sequence-alignment">
<h2>Sequence Alignment</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-needleman-wunsch">
<h3><a class="doc-anchor" href="#doc-needleman-wunsch">#</a> <code>needleman_wunsch</code></h3>
<p><code>needleman_wunsch A, B [, MATCH, MISMATCH, GAP]</code> — global alignment score.</p>
</article>
<article class="doc-entry" id="doc-smith-waterman">
<h3><a class="doc-anchor" href="#doc-smith-waterman">#</a> <code>smith_waterman</code></h3>
<p><code>smith_waterman A, B [, MATCH, MISMATCH, GAP]</code> — best local-alignment score.</p>
</article>
</section>
<section class="tutorial-section" id="ch-chemistry">
<h2>Chemistry</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-gibbs-free-energy">
<h3><a class="doc-anchor" href="#doc-gibbs-free-energy">#</a> <code>gibbs_free_energy</code></h3>
<p><code>gibbs_free_energy DH [, T, DS]</code> — ΔG = ΔH − TΔS.</p>
</article>
<article class="doc-entry" id="doc-henderson-hasselbalch">
<h3><a class="doc-anchor" href="#doc-henderson-hasselbalch">#</a> <code>henderson_hasselbalch</code></h3>
<p><code>henderson_hasselbalch PKA, A_CONJ, HA</code> — pH = pKa + log10([A⁻]/[HA]).</p>
</article>
<article class="doc-entry" id="doc-radioactive-decay">
<h3><a class="doc-anchor" href="#doc-radioactive-decay">#</a> <code>radioactive_decay</code></h3>
<p><code>radioactive_decay N0, LAMBDA, T</code> — N(t) = N₀ e^{-λt}.</p>
</article>
<article class="doc-entry" id="doc-half-life-to-constant">
<h3><a class="doc-anchor" href="#doc-half-life-to-constant">#</a> <code>half_life_to_constant</code></h3>
<p><code>half_life_to_constant T_HALF</code> — λ = ln 2 / t_½.</p>
</article>
</section>
<section class="tutorial-section" id="ch-control-theory">
<h2>Control Theory</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-pid-step">
<h3><a class="doc-anchor" href="#doc-pid-step">#</a> <code>pid_step</code></h3>
<p><code>pid_step STATE, KP, KI, KD, E, DT</code> → <code>[new_state, u]</code> (PID controller).</p>
</article>
<article class="doc-entry" id="doc-transfer-function-eval">
<h3><a class="doc-anchor" href="#doc-transfer-function-eval">#</a> <code>transfer_function_eval</code></h3>
<p><code>transfer_function_eval NUM, DEN, OMEGA</code> → <code>[Re, Im]</code> of H(jω).</p>
</article>
<article class="doc-entry" id="doc-bode-magnitude-db">
<h3><a class="doc-anchor" href="#doc-bode-magnitude-db">#</a> <code>bode_magnitude_db</code></h3>
<p><code>bode_magnitude_db NUM, DEN, OMEGA</code> — 20 log₁₀ |H(jω)|.</p>
</article>
<article class="doc-entry" id="doc-bode-phase-deg">
<h3><a class="doc-anchor" href="#doc-bode-phase-deg">#</a> <code>bode_phase_deg</code></h3>
<p><code>bode_phase_deg NUM, DEN, OMEGA</code> — phase of H(jω) in degrees.</p>
</article>
<article class="doc-entry" id="doc-lqr-2x2">
<h3><a class="doc-anchor" href="#doc-lqr-2x2">#</a> <code>lqr_2x2</code></h3>
<p><code>lqr_2x2 A, B, Q, R</code> — closed-form 2×2 continuous LQR. Returns <code>[K, P]</code>.</p>
</article>
</section>
<section class="tutorial-section" id="ch-game-theory">
<h2>Game Theory</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-nash-eq-2x2">
<h3><a class="doc-anchor" href="#doc-nash-eq-2x2">#</a> <code>nash_eq_2x2</code></h3>
<p><code>nash_eq_2x2 P1, P2</code> — pure Nash equilibria of a 2×2 bimatrix game.</p>
</article>
<article class="doc-entry" id="doc-shapley-value">
<h3><a class="doc-anchor" href="#doc-shapley-value">#</a> <code>shapley_value</code></h3>
<p><code>shapley_value N, V_TABLE</code> — Shapley values from characteristic-function vector.</p>
</article>
<article class="doc-entry" id="doc-expected-utility">
<h3><a class="doc-anchor" href="#doc-expected-utility">#</a> <code>expected_utility</code></h3>
<p><code>expected_utility PROBS, PAYOFFS</code> — Σ p·u.</p>
</article>
</section>
<section class="tutorial-section" id="ch-operations-research">
<h2>Operations Research</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-hungarian-assignment">
<h3><a class="doc-anchor" href="#doc-hungarian-assignment">#</a> <code>hungarian_assignment</code></h3>
<p><code>hungarian_assignment COST_MATRIX</code> — assignment + total cost. (Greedy heuristic; reduces to Hungarian for small instances.)</p>
</article>
<article class="doc-entry" id="doc-tsp-nearest-neighbor">
<h3><a class="doc-anchor" href="#doc-tsp-nearest-neighbor">#</a> <code>tsp_nearest_neighbor</code></h3>
<p><code>tsp_nearest_neighbor DIST_MATRIX</code> → <code>[tour, length]</code>.</p>
</article>
<article class="doc-entry" id="doc-vertex-cover-2approx">
<h3><a class="doc-anchor" href="#doc-vertex-cover-2approx">#</a> <code>vertex_cover_2approx</code></h3>
<p><code>vertex_cover_2approx ADJ</code> — 2-approximation greedy.</p>
</article>
</section>
<section class="tutorial-section" id="ch-numerical-pde">
<h2>Numerical PDE</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-heat-eq-1d">
<h3><a class="doc-anchor" href="#doc-heat-eq-1d">#</a> <code>heat_eq_1d</code></h3>
<p><code>heat_eq_1d F, A, B, NX, T, NT, ALPHA</code> — explicit FTCS heat-equation solver.</p>
</article>
<article class="doc-entry" id="doc-wave-eq-1d">
<h3><a class="doc-anchor" href="#doc-wave-eq-1d">#</a> <code>wave_eq_1d</code></h3>
<p><code>wave_eq_1d F, A, B, NX, T, NT, C</code> — explicit wave-equation solver.</p>
</article>
<article class="doc-entry" id="doc-laplace-2d-jacobi">
<h3><a class="doc-anchor" href="#doc-laplace-2d-jacobi">#</a> <code>laplace_2d_jacobi</code></h3>
<p><code>laplace_2d_jacobi GRID [, MAX_ITER, TOL]</code> — Jacobi smoother on a Dirichlet grid.</p>
</article>
</section>
<section class="tutorial-section" id="ch-bayesian-conjugate-updates">
<h2>Bayesian Conjugate Updates</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-beta-binomial-update">
<h3><a class="doc-anchor" href="#doc-beta-binomial-update">#</a> <code>beta_binomial_update</code></h3>
<p><code>beta_binomial_update ALPHA, BETA, N, K</code> → posterior <code>[α', β']</code>.</p>
</article>
<article class="doc-entry" id="doc-normal-normal-update">
<h3><a class="doc-anchor" href="#doc-normal-normal-update">#</a> <code>normal_normal_update</code></h3>
<p><code>normal_normal_update MU0, VAR0, N, YBAR, VAR_DATA</code> → <code>[μ_post, σ²_post]</code>.</p>
</article>
<article class="doc-entry" id="doc-gamma-poisson-update">
<h3><a class="doc-anchor" href="#doc-gamma-poisson-update">#</a> <code>gamma_poisson_update</code></h3>
<p><code>gamma_poisson_update ALPHA, BETA, N, TOTAL_EVENTS</code> → <code>[α', β']</code>.</p>
</article>
<article class="doc-entry" id="doc-dirichlet-multinomial-update">
<h3><a class="doc-anchor" href="#doc-dirichlet-multinomial-update">#</a> <code>dirichlet_multinomial_update</code></h3>
<p><code>dirichlet_multinomial_update ALPHA, COUNTS</code> → α + counts.</p>
</article>
</section>
<section class="tutorial-section" id="ch-quantum-computing-gates">
<h2>Quantum Computing Gates</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-hadamard-gate">
<h3><a class="doc-anchor" href="#doc-hadamard-gate">#</a> <code>hadamard_gate</code></h3>
<p><code>hadamard_gate</code> — 2×2 Hadamard.</p>
</article>
<article class="doc-entry" id="doc-cnot-gate">
<h3><a class="doc-anchor" href="#doc-cnot-gate">#</a> <code>cnot_gate</code></h3>
<p><code>cnot_gate</code> — 4×4 controlled-NOT.</p>
</article>
<article class="doc-entry" id="doc-swap-gate">
<h3><a class="doc-anchor" href="#doc-swap-gate">#</a> <code>swap_gate</code></h3>
<p><code>swap_gate</code> — 4×4 SWAP.</p>
</article>
<article class="doc-entry" id="doc-cz-gate">
<h3><a class="doc-anchor" href="#doc-cz-gate">#</a> <code>cz_gate</code></h3>
<p><code>cz_gate</code> — 4×4 controlled-Z.</p>
</article>
<article class="doc-entry" id="doc-qft-matrix">
<h3><a class="doc-anchor" href="#doc-qft-matrix">#</a> <code>qft_matrix</code></h3>
<p><code>qft_matrix N</code> → <code>[Re, Im]</code> of N×N QFT matrix.</p>
</article>
<article class="doc-entry" id="doc-phase-gate">
<h3><a class="doc-anchor" href="#doc-phase-gate">#</a> <code>phase_gate</code></h3>
<p><code>phase_gate PHI</code> → <code>[Re, Im]</code> of diag(1, e^iφ).</p>
</article>
<article class="doc-entry" id="doc-s-gate">
<h3><a class="doc-anchor" href="#doc-s-gate">#</a> <code>s_gate</code></h3>
<p><code>s_gate</code> — phase(π/2).</p>
</article>
<article class="doc-entry" id="doc-t-gate">
<h3><a class="doc-anchor" href="#doc-t-gate">#</a> <code>t_gate</code></h3>
<p><code>t_gate</code> — phase(π/4).</p>
</article>
</section>
<section class="tutorial-section" id="ch-splines-curves">
<h2>Splines & Curves</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-bezier-eval">
<h3><a class="doc-anchor" href="#doc-bezier-eval">#</a> <code>bezier_eval</code></h3>
<p><code>bezier_eval CONTROL_PTS, T</code> — de Casteljau evaluation.</p>
</article>
<article class="doc-entry" id="doc-catmull-rom-eval">
<h3><a class="doc-anchor" href="#doc-catmull-rom-eval">#</a> <code>catmull_rom_eval</code></h3>
<p><code>catmull_rom_eval P0, P1, P2, P3, T</code> — uniform Catmull-Rom.</p>
</article>
<article class="doc-entry" id="doc-cubic-hermite-eval">
<h3><a class="doc-anchor" href="#doc-cubic-hermite-eval">#</a> <code>cubic_hermite_eval</code></h3>
<p><code>cubic_hermite_eval P0, M0, P1, M1, T</code> — Hermite basis interpolation.</p>
</article>
<article class="doc-entry" id="doc-bspline-basis">
<h3><a class="doc-anchor" href="#doc-bspline-basis">#</a> <code>bspline_basis</code></h3>
<p><code>bspline_basis I, K, T, KNOTS</code> — Cox-de Boor B-spline basis.</p>
</article>
</section>
<section class="tutorial-section" id="ch-music-audio">
<h2>Music & Audio</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-freq-to-midi">
<h3><a class="doc-anchor" href="#doc-freq-to-midi">#</a> <code>freq_to_midi</code></h3>
<p><code>freq_to_midi F</code> — MIDI note number from frequency.</p>
</article>
<article class="doc-entry" id="doc-midi-to-freq">
<h3><a class="doc-anchor" href="#doc-midi-to-freq">#</a> <code>midi_to_freq</code></h3>
<p><code>midi_to_freq M</code> — frequency from MIDI note.</p>
</article>
<article class="doc-entry" id="doc-equal-temperament-freq">
<h3><a class="doc-anchor" href="#doc-equal-temperament-freq">#</a> <code>equal_temperament_freq</code></h3>
<p><code>equal_temperament_freq SEMITONES_ABOVE_A4</code> — 12-TET frequency.</p>
</article>
<article class="doc-entry" id="doc-cents-difference">
<h3><a class="doc-anchor" href="#doc-cents-difference">#</a> <code>cents_difference</code></h3>
<p><code>cents_difference F1, F2</code> — 1200 log₂(F2/F1).</p>
</article>
</section>
<section class="tutorial-section" id="ch-astronomy-cosmology">
<h2>Astronomy & Cosmology</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-redshift-z">
<h3><a class="doc-anchor" href="#doc-redshift-z">#</a> <code>redshift_z</code></h3>
<p><code>redshift_z LAMBDA_OBS, LAMBDA_EMIT</code> — z = λ_obs/λ_emit − 1.</p>
</article>
<article class="doc-entry" id="doc-hubble-distance">
<h3><a class="doc-anchor" href="#doc-hubble-distance">#</a> <code>hubble_distance</code></h3>
<p><code>hubble_distance H0</code> — c / H₀ in Mpc.</p>
</article>
<article class="doc-entry" id="doc-luminosity-distance">
<h3><a class="doc-anchor" href="#doc-luminosity-distance">#</a> <code>luminosity_distance</code></h3>
<p><code>luminosity_distance Z, H0, OMEGA_M, OMEGA_L</code> — flat ΛCDM (numeric).</p>
</article>
</section>
<section class="tutorial-section" id="ch-fluid-dynamics">
<h2>Fluid Dynamics</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-reynolds-number">
<h3><a class="doc-anchor" href="#doc-reynolds-number">#</a> <code>reynolds_number</code></h3>
<p><code>reynolds_number RHO, U, L, MU</code> — ρ U L / μ.</p>
</article>
<article class="doc-entry" id="doc-mach-number">
<h3><a class="doc-anchor" href="#doc-mach-number">#</a> <code>mach_number</code></h3>
<p><code>mach_number U, C</code> — U / c.</p>
</article>
<article class="doc-entry" id="doc-prandtl-number">
<h3><a class="doc-anchor" href="#doc-prandtl-number">#</a> <code>prandtl_number</code></h3>
<p><code>prandtl_number CP, MU, K</code> — c_p μ / k.</p>
</article>
<article class="doc-entry" id="doc-bernoulli-velocity">
<h3><a class="doc-anchor" href="#doc-bernoulli-velocity">#</a> <code>bernoulli_velocity</code></h3>
<p><code>bernoulli_velocity P1, P2, RHO</code> — √(2(p₁ − p₂)/ρ).</p>
</article>
</section>
<section class="tutorial-section" id="ch-distributions-discrete-circular">
<h2>Distributions (Discrete / Circular)</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-negative-binomial-pmf">
<h3><a class="doc-anchor" href="#doc-negative-binomial-pmf">#</a> <code>negative_binomial_pmf</code></h3>
<p><code>negative_binomial_pmf K, R, P</code> — failures-before-rth-success PMF.</p>
</article>
<article class="doc-entry" id="doc-hypergeometric-pmf">
<h3><a class="doc-anchor" href="#doc-hypergeometric-pmf">#</a> <code>hypergeometric_pmf</code></h3>
<p><code>hypergeometric_pmf N, K_POP, N_DRAWS, K_OBS</code> — finite-population PMF.</p>
</article>
<article class="doc-entry" id="doc-beta-binomial-pmf">
<h3><a class="doc-anchor" href="#doc-beta-binomial-pmf">#</a> <code>beta_binomial_pmf</code></h3>
<p><code>beta_binomial_pmf K, N, ALPHA, BETA</code> — beta-binomial PMF.</p>
</article>
<article class="doc-entry" id="doc-von-mises-pdf">
<h3><a class="doc-anchor" href="#doc-von-mises-pdf">#</a> <code>von_mises_pdf</code></h3>
<p><code>von_mises_pdf THETA, MU, KAPPA</code> — circular Gaussian.</p>
</article>
</section>
<section class="tutorial-section" id="ch-random-graph-generators">
<h2>Random Graph Generators</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-erdos-renyi-random">
<h3><a class="doc-anchor" href="#doc-erdos-renyi-random">#</a> <code>erdos_renyi_random</code></h3>
<p><code>erdos_renyi_random N, P</code> — G(n, p) Bernoulli edge model.</p>
</article>
<article class="doc-entry" id="doc-barabasi-albert-random">
<h3><a class="doc-anchor" href="#doc-barabasi-albert-random">#</a> <code>barabasi_albert_random</code></h3>
<p><code>barabasi_albert_random N, M</code> — preferential-attachment model.</p>
</article>
<article class="doc-entry" id="doc-watts-strogatz-random">
<h3><a class="doc-anchor" href="#doc-watts-strogatz-random">#</a> <code>watts_strogatz_random</code></h3>
<p><code>watts_strogatz_random N, K, P</code> — small-world rewiring.</p>
</article>
</section>
<section class="tutorial-section" id="ch-color-science">
<h2>Color Science</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-rgb-to-lab">
<h3><a class="doc-anchor" href="#doc-rgb-to-lab">#</a> <code>rgb_to_lab</code></h3>
<p><code>rgb_to_lab R, G, B</code> — sRGB → CIE Lab.</p>
</article>
<article class="doc-entry" id="doc-lab-to-rgb">
<h3><a class="doc-anchor" href="#doc-lab-to-rgb">#</a> <code>lab_to_rgb</code></h3>
<p><code>lab_to_rgb L, A, B</code> — CIE Lab → sRGB.</p>
</article>
<article class="doc-entry" id="doc-kelvin-to-rgb">
<h3><a class="doc-anchor" href="#doc-kelvin-to-rgb">#</a> <code>kelvin_to_rgb</code></h3>
<p><code>kelvin_to_rgb K</code> — black-body sRGB approximation (Tanner Helland).</p>
</article>
</section>
<section class="tutorial-section" id="ch-integer-sequences-combinatorial">
<h2>Integer Sequences (Combinatorial)</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-bell-triangle">
<h3><a class="doc-anchor" href="#doc-bell-triangle">#</a> <code>bell_triangle</code></h3>
<p><code>bell_triangle N</code> — first N+1 rows of the Bell / Aitken triangle.</p>
</article>
<article class="doc-entry" id="doc-surjection-count">
<h3><a class="doc-anchor" href="#doc-surjection-count">#</a> <code>surjection_count</code></h3>
<p><code>surjection_count N, K</code> — k! · S(n, k).</p>
</article>
<article class="doc-entry" id="doc-distinct-partition-count">
<h3><a class="doc-anchor" href="#doc-distinct-partition-count">#</a> <code>distinct_partition_count</code></h3>
<p><code>distinct_partition_count N</code> — partitions of N into distinct parts.</p>
</article>
<article class="doc-entry" id="doc-fibonacci-q">
<h3><a class="doc-anchor" href="#doc-fibonacci-q">#</a> <code>fibonacci_q</code></h3>
<p><code>fibonacci_q N</code> — 1 if N is a Fibonacci number.</p>
</article>
</section>
<section class="tutorial-section" id="ch-multiple-testing-corrections">
<h2>Multiple-Testing Corrections</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-bonferroni-correction">
<h3><a class="doc-anchor" href="#doc-bonferroni-correction">#</a> <code>bonferroni_correction</code></h3>
<p><code>bonferroni_correction PVALS</code> — Bonferroni-adjusted p-values (capped at 1).</p>
</article>
<article class="doc-entry" id="doc-benjamini-hochberg">
<h3><a class="doc-anchor" href="#doc-benjamini-hochberg">#</a> <code>benjamini_hochberg</code></h3>
<p><code>benjamini_hochberg PVALS</code> — BH FDR q-values.</p>
</article>
<article class="doc-entry" id="doc-tukey-hsd">
<h3><a class="doc-anchor" href="#doc-tukey-hsd">#</a> <code>tukey_hsd</code></h3>
<p><code>tukey_hsd ALPHA, K, DF, MSE, N</code> — Tukey honestly-significant-difference critical bound.</p>
</article>
</section>
<section class="tutorial-section" id="ch-probabilistic-distances">
<h2>Probabilistic Distances</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-hellinger-distance">
<h3><a class="doc-anchor" href="#doc-hellinger-distance">#</a> <code>hellinger_distance</code></h3>
<p><code>hellinger_distance P, Q</code> — √(½ Σ (√p − √q)²).</p>
</article>
<article class="doc-entry" id="doc-wasserstein-1d">
<h3><a class="doc-anchor" href="#doc-wasserstein-1d">#</a> <code>wasserstein_1d</code></h3>
<p><code>wasserstein_1d A, B</code> — earth-mover distance for sorted samples.</p>
</article>
<article class="doc-entry" id="doc-chi-squared-divergence">
<h3><a class="doc-anchor" href="#doc-chi-squared-divergence">#</a> <code>chi_squared_divergence</code></h3>
<p><code>chi_squared_divergence P, Q</code> — Σ (p − q)² / q.</p>
</article>
</section>
<section class="tutorial-section" id="ch-distributions-tail-inflated">
<h2>Distributions (Tail / Inflated)</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-beta-geometric-pmf">
<h3><a class="doc-anchor" href="#doc-beta-geometric-pmf">#</a> <code>beta_geometric_pmf</code></h3>
<p><code>beta_geometric_pmf K, ALPHA, BETA</code> — beta-geometric PMF.</p>
</article>
<article class="doc-entry" id="doc-generalized-gamma-pdf">
<h3><a class="doc-anchor" href="#doc-generalized-gamma-pdf">#</a> <code>generalized_gamma_pdf</code></h3>
<p><code>generalized_gamma_pdf X, A, D, P</code> — generalised-gamma PDF.</p>
</article>
<article class="doc-entry" id="doc-zip-pmf">
<h3><a class="doc-anchor" href="#doc-zip-pmf">#</a> <code>zip_pmf</code></h3>
<p><code>zip_pmf K, PI, LAMBDA</code> — zero-inflated Poisson.</p>
</article>
</section>
<section class="tutorial-section" id="ch-astrophysics-radiation">
<h2>Astrophysics & Radiation</h2>
<p class="chapter-meta">9 topics</p>
<article class="doc-entry" id="doc-stefan-boltzmann-luminosity">
<h3><a class="doc-anchor" href="#doc-stefan-boltzmann-luminosity">#</a> <code>stefan_boltzmann_luminosity</code></h3>
<p><code>stefan_boltzmann_luminosity R, T</code> — L = 4π R² σ T⁴.</p>
</article>
<article class="doc-entry" id="doc-photon-momentum">
<h3><a class="doc-anchor" href="#doc-photon-momentum">#</a> <code>photon_momentum</code></h3>
<p><code>photon_momentum LAMBDA</code> — h / λ.</p>
</article>
<article class="doc-entry" id="doc-photon-energy-ev">
<h3><a class="doc-anchor" href="#doc-photon-energy-ev">#</a> <code>photon_energy_ev</code></h3>
<p><code>photon_energy_ev LAMBDA</code> — hc / λ in eV.</p>
</article>
<article class="doc-entry" id="doc-dipole-radiation-power">
<h3><a class="doc-anchor" href="#doc-dipole-radiation-power">#</a> <code>dipole_radiation_power</code></h3>
<p><code>dipole_radiation_power Q, A</code> — Larmor formula.</p>
</article>
<article class="doc-entry" id="doc-parallax-to-distance">
<h3><a class="doc-anchor" href="#doc-parallax-to-distance">#</a> <code>parallax_to_distance</code></h3>
<p><code>parallax_to_distance P_ARCSEC</code> — parsecs from arcseconds.</p>
</article>
<article class="doc-entry" id="doc-hawking-temperature">
<h3><a class="doc-anchor" href="#doc-hawking-temperature">#</a> <code>hawking_temperature</code></h3>
<p><code>hawking_temperature M_KG</code> — black-hole temperature.</p>
</article>
<article class="doc-entry" id="doc-roche-limit">
<h3><a class="doc-anchor" href="#doc-roche-limit">#</a> <code>roche_limit</code></h3>
<p><code>roche_limit R, RHO_PRIMARY, RHO_SAT</code> — rigid-body Roche limit.</p>
</article>
<article class="doc-entry" id="doc-apparent-magnitude">
<h3><a class="doc-anchor" href="#doc-apparent-magnitude">#</a> <code>apparent_magnitude</code></h3>
<p><code>apparent_magnitude ABS_M, D_PC</code> — m = M + 5 log₁₀(d/10).</p>
</article>
<article class="doc-entry" id="doc-distance-modulus">
<h3><a class="doc-anchor" href="#doc-distance-modulus">#</a> <code>distance_modulus</code></h3>
<p><code>distance_modulus D_PC</code> — μ = 5 log d − 5.</p>
</article>
</section>
<section class="tutorial-section" id="ch-chemistry-beer-rate-colligative">
<h2>Chemistry (Beer / Rate / Colligative)</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-beer-lambert">
<h3><a class="doc-anchor" href="#doc-beer-lambert">#</a> <code>beer_lambert</code></h3>
<p><code>beer_lambert EPSILON, L, C</code> — A = ε·l·c.</p>
</article>
<article class="doc-entry" id="doc-rate-law-n">
<h3><a class="doc-anchor" href="#doc-rate-law-n">#</a> <code>rate_law_n</code></h3>
<p><code>rate_law_n A0, K, T, N</code> — concentration after time t for nth-order reaction.</p>
</article>
<article class="doc-entry" id="doc-freezing-point-depression">
<h3><a class="doc-anchor" href="#doc-freezing-point-depression">#</a> <code>freezing_point_depression</code></h3>
<p><code>freezing_point_depression KF, MOLALITY, I</code> — ΔT = K_f m i.</p>
</article>
</section>
<section class="tutorial-section" id="ch-mixed-strategy-game-theory">
<h2>Mixed-Strategy Game Theory</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-mixed-nash-2x2">
<h3><a class="doc-anchor" href="#doc-mixed-nash-2x2">#</a> <code>mixed_nash_2x2</code></h3>
<p><code>mixed_nash_2x2 P1, P2</code> → <code>[p, q]</code> mixed-strategy probabilities.</p>
</article>
<article class="doc-entry" id="doc-minimax-2x2">
<h3><a class="doc-anchor" href="#doc-minimax-2x2">#</a> <code>minimax_2x2</code></h3>
<p><code>minimax_2x2 M</code> — security level for the row player.</p>
</article>
</section>
<section class="tutorial-section" id="ch-computer-graphics">
<h2>Computer Graphics</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-barycentric-coords-2d">
<h3><a class="doc-anchor" href="#doc-barycentric-coords-2d">#</a> <code>barycentric_coords_2d</code></h3>
<p><code>barycentric_coords_2d P, A, B, C</code> → <code>[u, v, w]</code>.</p>
</article>
<article class="doc-entry" id="doc-bresenham-line">
<h3><a class="doc-anchor" href="#doc-bresenham-line">#</a> <code>bresenham_line</code></h3>
<p><code>bresenham_line X0, Y0, X1, Y1</code> → array of integer pixels.</p>
</article>
<article class="doc-entry" id="doc-bilinear-interp-2d">
<h3><a class="doc-anchor" href="#doc-bilinear-interp-2d">#</a> <code>bilinear_interp_2d</code></h3>
<p><code>bilinear_interp_2d F00, F10, F01, F11, U, V</code> — unit-square bilinear.</p>
</article>
<article class="doc-entry" id="doc-point-in-polygon-2d">
<h3><a class="doc-anchor" href="#doc-point-in-polygon-2d">#</a> <code>point_in_polygon_2d</code></h3>
<p><code>point_in_polygon_2d P, POLY</code> — ray-casting test.</p>
</article>
</section>
<section class="tutorial-section" id="ch-dsp-hilbert-cepstrum-filter-design">
<h2>DSP (Hilbert / Cepstrum / Filter Design)</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-hilbert-transform">
<h3><a class="doc-anchor" href="#doc-hilbert-transform">#</a> <code>hilbert_transform</code></h3>
<p><code>hilbert_transform XS</code> — discrete Hilbert via DFT.</p>
</article>
<article class="doc-entry" id="doc-cepstrum">
<h3><a class="doc-anchor" href="#doc-cepstrum">#</a> <code>cepstrum</code></h3>
<p><code>cepstrum XS</code> — real cepstrum ifft(log|fft|).</p>
</article>
<article class="doc-entry" id="doc-butterworth-lowpass-coeffs">
<h3><a class="doc-anchor" href="#doc-butterworth-lowpass-coeffs">#</a> <code>butterworth_lowpass_coeffs</code></h3>
<p><code>butterworth_lowpass_coeffs ORDER, CUTOFF</code> → <code>[b, a]</code> digital biquad-cascade.</p>
</article>
<article class="doc-entry" id="doc-savitzky-golay-coeffs">
<h3><a class="doc-anchor" href="#doc-savitzky-golay-coeffs">#</a> <code>savitzky_golay_coeffs</code></h3>
<p><code>savitzky_golay_coeffs NL, NR, M</code> — SG filter coefficients.</p>
</article>
<article class="doc-entry" id="doc-savitzky-golay-filter">
<h3><a class="doc-anchor" href="#doc-savitzky-golay-filter">#</a> <code>savitzky_golay_filter</code></h3>
<p><code>savitzky_golay_filter XS, COEFFS</code> — apply pre-computed SG coefficients.</p>
</article>
</section>
<section class="tutorial-section" id="ch-image-processing-edges-bilateral">
<h2>Image Processing (Edges / Bilateral)</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-canny-edge-intensity">
<h3><a class="doc-anchor" href="#doc-canny-edge-intensity">#</a> <code>canny_edge_intensity</code></h3>
<p><code>canny_edge_intensity IMG</code> — Sobel-magnitude edge map (caller thresholds).</p>
</article>
<article class="doc-entry" id="doc-bilateral-filter-basic">
<h3><a class="doc-anchor" href="#doc-bilateral-filter-basic">#</a> <code>bilateral_filter_basic</code></h3>
<p><code>bilateral_filter_basic IMG, RADIUS, SIGMA_S, SIGMA_R</code> — edge-preserving smoother.</p>
</article>
</section>
<section class="tutorial-section" id="ch-clustering-helpers">
<h2>Clustering Helpers</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-kmeans-pp-init">
<h3><a class="doc-anchor" href="#doc-kmeans-pp-init">#</a> <code>kmeans_pp_init</code></h3>
<p><code>kmeans_pp_init POINTS, K</code> — k-means++ seed centroids.</p>
</article>
<article class="doc-entry" id="doc-elbow-score">
<h3><a class="doc-anchor" href="#doc-elbow-score">#</a> <code>elbow_score</code></h3>
<p><code>elbow_score POINTS, LABELS</code> — within-cluster sum of squares.</p>
</article>
</section>
<section class="tutorial-section" id="ch-combinatorics-tableaux-boustrophedon">
<h2>Combinatorics (Tableaux / Boustrophedon)</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-young-tableaux-count">
<h3><a class="doc-anchor" href="#doc-young-tableaux-count">#</a> <code>young_tableaux_count</code></h3>
<p><code>young_tableaux_count LAMBDA</code> — hook-length formula.</p>
</article>
<article class="doc-entry" id="doc-euler-alt-permutation">
<h3><a class="doc-anchor" href="#doc-euler-alt-permutation">#</a> <code>euler_alt_permutation</code></h3>
<p><code>euler_alt_permutation N</code> — Euler / zigzag number A000111.</p>
</article>
<article class="doc-entry" id="doc-genocchi-number">
<h3><a class="doc-anchor" href="#doc-genocchi-number">#</a> <code>genocchi_number</code></h3>
<p><code>genocchi_number N</code> — G_n via Bernoulli identity.</p>
</article>
<article class="doc-entry" id="doc-lattice-paths-count">
<h3><a class="doc-anchor" href="#doc-lattice-paths-count">#</a> <code>lattice_paths_count</code></h3>
<p><code>lattice_paths_count M, N</code> — C(m+n, n) east/north paths.</p>
</article>
</section>
<section class="tutorial-section" id="ch-number-theory-tetration-smoothness">
<h2>Number Theory (Tetration / Smoothness)</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-tetration">
<h3><a class="doc-anchor" href="#doc-tetration">#</a> <code>tetration</code></h3>
<p><code>tetration A, N</code> — N-fold a-tower (overflow → ∞).</p>
</article>
<article class="doc-entry" id="doc-ackermann-limited">
<h3><a class="doc-anchor" href="#doc-ackermann-limited">#</a> <code>ackermann_limited</code></h3>
<p><code>ackermann_limited M, N</code> — depth-limited Ackermann (refuses past M=3 N=14).</p>
</article>
<article class="doc-entry" id="doc-perfect-power-q">
<h3><a class="doc-anchor" href="#doc-perfect-power-q">#</a> <code>perfect_power_q</code></h3>
<p><code>perfect_power_q N</code> — 1 if N = a^b for integers a, b ≥ 2.</p>
</article>
<article class="doc-entry" id="doc-b-smooth-q">
<h3><a class="doc-anchor" href="#doc-b-smooth-q">#</a> <code>b_smooth_q</code></h3>
<p><code>b_smooth_q N, B</code> — 1 if every prime factor of N is ≤ B.</p>
</article>
</section>
<section class="tutorial-section" id="ch-network-coreness-structure">
<h2>Network Coreness & Structure</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-k-core">
<h3><a class="doc-anchor" href="#doc-k-core">#</a> <code>k_core</code></h3>
<p><code>k_core ADJ</code> — vertex coreness.</p>
</article>
<article class="doc-entry" id="doc-rich-club-coefficient">
<h3><a class="doc-anchor" href="#doc-rich-club-coefficient">#</a> <code>rich_club_coefficient</code></h3>
<p><code>rich_club_coefficient ADJ, K</code> — fraction of edges among nodes with deg > k.</p>
</article>
</section>
<section class="tutorial-section" id="ch-crypto-helpers">
<h2>Crypto Helpers</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-rsa-basic-encrypt">
<h3><a class="doc-anchor" href="#doc-rsa-basic-encrypt">#</a> <code>rsa_basic_encrypt</code></h3>
<p><code>rsa_basic_encrypt M, E, N</code> — m^e mod n.</p>
</article>
<article class="doc-entry" id="doc-rsa-basic-decrypt">
<h3><a class="doc-anchor" href="#doc-rsa-basic-decrypt">#</a> <code>rsa_basic_decrypt</code></h3>
<p><code>rsa_basic_decrypt C, D, N</code> — c^d mod n.</p>
</article>
<article class="doc-entry" id="doc-dh-shared-secret">
<h3><a class="doc-anchor" href="#doc-dh-shared-secret">#</a> <code>dh_shared_secret</code></h3>
<p><code>dh_shared_secret PEER_PUB, PRIVATE, P</code> — Diffie-Hellman.</p>
</article>
</section>
<section class="tutorial-section" id="ch-quantum-entanglement">
<h2>Quantum Entanglement</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-bell-state-phi-plus">
<h3><a class="doc-anchor" href="#doc-bell-state-phi-plus">#</a> <code>bell_state_phi_plus</code></h3>
<p><code>bell_state_phi_plus</code> — Bell state (|00⟩+|11⟩)/√2.</p>
</article>
<article class="doc-entry" id="doc-bell-state-psi-minus">
<h3><a class="doc-anchor" href="#doc-bell-state-psi-minus">#</a> <code>bell_state_psi_minus</code></h3>
<p><code>bell_state_psi_minus</code> — singlet (|01⟩-|10⟩)/√2.</p>
</article>
<article class="doc-entry" id="doc-density-matrix-purity">
<h3><a class="doc-anchor" href="#doc-density-matrix-purity">#</a> <code>density_matrix_purity</code></h3>
<p><code>density_matrix_purity RHO</code> — tr(ρ²).</p>
</article>
<article class="doc-entry" id="doc-concurrence-2qubit">
<h3><a class="doc-anchor" href="#doc-concurrence-2qubit">#</a> <code>concurrence_2qubit</code></h3>
<p><code>concurrence_2qubit PSI</code> — 2|ad − bc| in real basis.</p>
</article>
</section>
<section class="tutorial-section" id="ch-2-d-geometry-polygons-circles">
<h2>2-D Geometry (Polygons & Circles)</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-point-in-circle">
<h3><a class="doc-anchor" href="#doc-point-in-circle">#</a> <code>point_in_circle</code></h3>
<p><code>point_in_circle P, CENTER, R</code> — 1 if inside.</p>
</article>
<article class="doc-entry" id="doc-circle-circle-intersect-2d">
<h3><a class="doc-anchor" href="#doc-circle-circle-intersect-2d">#</a> <code>circle_circle_intersect_2d</code></h3>
<p><code>circle_circle_intersect_2d C1, R1, C2, R2</code> — 0/1/2 intersection points.</p>
</article>
<article class="doc-entry" id="doc-polygon-centroid">
<h3><a class="doc-anchor" href="#doc-polygon-centroid">#</a> <code>polygon_centroid</code></h3>
<p><code>polygon_centroid POLY</code> — area-weighted centroid.</p>
</article>
<article class="doc-entry" id="doc-sutherland-hodgman-clip">
<h3><a class="doc-anchor" href="#doc-sutherland-hodgman-clip">#</a> <code>sutherland_hodgman_clip</code></h3>
<p><code>sutherland_hodgman_clip SUBJECT, CLIP</code> — clip against convex CCW polygon.</p>
</article>
</section>
<section class="tutorial-section" id="ch-time-series-smoothing">
<h2>Time-Series Smoothing</h2>
<p class="chapter-meta">1 topics</p>
<article class="doc-entry" id="doc-kalman-rts-smoother">
<h3><a class="doc-anchor" href="#doc-kalman-rts-smoother">#</a> <code>kalman_rts_smoother</code></h3>
<p><code>kalman_rts_smoother X_HAT, P, X_PRED, P_PRED, F</code> — RTS smoothed means.</p>
</article>
</section>
<section class="tutorial-section" id="ch-bioinformatics">
<h2>Bioinformatics</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-gc-content">
<h3><a class="doc-anchor" href="#doc-gc-content">#</a> <code>gc_content</code></h3>
<p><code>gc_content SEQ</code> — fraction of G + C in DNA / RNA string.</p>
</article>
<article class="doc-entry" id="doc-codon-to-aa">
<h3><a class="doc-anchor" href="#doc-codon-to-aa">#</a> <code>codon_to_aa</code></h3>
<p><code>codon_to_aa CODON</code> — single-letter amino-acid (or '*' / 'X').</p>
</article>
<article class="doc-entry" id="doc-reverse-complement-dna">
<h3><a class="doc-anchor" href="#doc-reverse-complement-dna">#</a> <code>reverse_complement_dna</code></h3>
<p><code>reverse_complement_dna SEQ</code> — DNA reverse complement.</p>
</article>
<article class="doc-entry" id="doc-hamming-dna">
<h3><a class="doc-anchor" href="#doc-hamming-dna">#</a> <code>hamming_dna</code></h3>
<p><code>hamming_dna A, B</code> — case-insensitive Hamming distance.</p>
</article>
<article class="doc-entry" id="doc-blosum62-pair-score">
<h3><a class="doc-anchor" href="#doc-blosum62-pair-score">#</a> <code>blosum62_pair_score</code></h3>
<p><code>blosum62_pair_score A, B</code> — BLOSUM62 substitution score.</p>
</article>
<article class="doc-entry" id="doc-kmer-count">
<h3><a class="doc-anchor" href="#doc-kmer-count">#</a> <code>kmer_count</code></h3>
<p><code>kmer_count SEQ, K</code> — total count of length-K windows.</p>
</article>
</section>
<section class="tutorial-section" id="ch-geographic-map-projection">
<h2>Geographic / Map Projection</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-great-circle-bearing">
<h3><a class="doc-anchor" href="#doc-great-circle-bearing">#</a> <code>great_circle_bearing</code></h3>
<p><code>great_circle_bearing LAT1, LON1, LAT2, LON2</code> — initial bearing in degrees.</p>
</article>
<article class="doc-entry" id="doc-midpoint-lat-lon">
<h3><a class="doc-anchor" href="#doc-midpoint-lat-lon">#</a> <code>midpoint_lat_lon</code></h3>
<p><code>midpoint_lat_lon LAT1, LON1, LAT2, LON2</code> — great-circle midpoint.</p>
</article>
<article class="doc-entry" id="doc-utm-zone-for">
<h3><a class="doc-anchor" href="#doc-utm-zone-for">#</a> <code>utm_zone_for</code></h3>
<p><code>utm_zone_for LON</code> — UTM zone (1..60).</p>
</article>
<article class="doc-entry" id="doc-area-polygon-lat-lon">
<h3><a class="doc-anchor" href="#doc-area-polygon-lat-lon">#</a> <code>area_polygon_lat_lon</code></h3>
<p><code>area_polygon_lat_lon POLY [, R]</code> — spherical-excess polygon area in m².</p>
</article>
</section>
<section class="tutorial-section" id="ch-fixed-income-finance">
<h2>Fixed-Income Finance</h2>
<p class="chapter-meta">5 topics</p>
<article class="doc-entry" id="doc-crr-binomial-option">
<h3><a class="doc-anchor" href="#doc-crr-binomial-option">#</a> <code>crr_binomial_option</code></h3>
<p><code>crr_binomial_option S0, K, T, R, SIGMA, N, IS_PUT</code> — Cox-Ross-Rubinstein price.</p>
</article>
<article class="doc-entry" id="doc-bond-price-clean">
<h3><a class="doc-anchor" href="#doc-bond-price-clean">#</a> <code>bond_price_clean</code></h3>
<p><code>bond_price_clean FACE, COUPON, N, PP_Y, YIELD</code> — present value.</p>
</article>
<article class="doc-entry" id="doc-bond-yield-to-maturity">
<h3><a class="doc-anchor" href="#doc-bond-yield-to-maturity">#</a> <code>bond_yield_to_maturity</code></h3>
<p><code>bond_yield_to_maturity PRICE, FACE, COUPON, N, PP_Y</code> — solve YTM by bisection.</p>
</article>
<article class="doc-entry" id="doc-modified-duration-bond">
<h3><a class="doc-anchor" href="#doc-modified-duration-bond">#</a> <code>modified_duration_bond</code></h3>
<p><code>modified_duration_bond FACE, COUPON, N, PP_Y, YIELD</code> — modified duration.</p>
</article>
<article class="doc-entry" id="doc-convexity-bond">
<h3><a class="doc-anchor" href="#doc-convexity-bond">#</a> <code>convexity_bond</code></h3>
<p><code>convexity_bond FACE, COUPON, N, PP_Y, YIELD</code> — bond convexity measure.</p>
</article>
</section>
<section class="tutorial-section" id="ch-image-quality-metrics">
<h2>Image Quality Metrics</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-ssim">
<h3><a class="doc-anchor" href="#doc-ssim">#</a> <code>ssim</code></h3>
<p><code>ssim A, B [, L]</code> — Structural Similarity Index (single window).</p>
</article>
<article class="doc-entry" id="doc-psnr">
<h3><a class="doc-anchor" href="#doc-psnr">#</a> <code>psnr</code></h3>
<p><code>psnr A, B [, MAX_VAL]</code> — peak SNR in dB.</p>
</article>
<article class="doc-entry" id="doc-mssim">
<h3><a class="doc-anchor" href="#doc-mssim">#</a> <code>mssim</code></h3>
<p><code>mssim A, B [, WIN, L]</code> — mean SSIM across non-overlapping windows.</p>
</article>
</section>
<section class="tutorial-section" id="ch-acoustics">
<h2>Acoustics</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-db-spl-from-pa">
<h3><a class="doc-anchor" href="#doc-db-spl-from-pa">#</a> <code>db_spl_from_pa</code></h3>
<p><code>db_spl_from_pa P_PA</code> — sound pressure level dB SPL.</p>
</article>
<article class="doc-entry" id="doc-a-weighting-factor">
<h3><a class="doc-anchor" href="#doc-a-weighting-factor">#</a> <code>a_weighting_factor</code></h3>
<p><code>a_weighting_factor F_HZ</code> — IEC 61672 A-weighting amplitude.</p>
</article>
<article class="doc-entry" id="doc-octave-band-center">
<h3><a class="doc-anchor" href="#doc-octave-band-center">#</a> <code>octave_band_center</code></h3>
<p><code>octave_band_center BAND</code> — 1 kHz · 2^band centre frequency.</p>
</article>
<article class="doc-entry" id="doc-semitone-ratio">
<h3><a class="doc-anchor" href="#doc-semitone-ratio">#</a> <code>semitone_ratio</code></h3>
<p><code>semitone_ratio</code> — 12-TET ratio 2^(1/12).</p>
</article>
</section>
<section class="tutorial-section" id="ch-population-genetics">
<h2>Population Genetics</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-hardy-weinberg">
<h3><a class="doc-anchor" href="#doc-hardy-weinberg">#</a> <code>hardy_weinberg</code></h3>
<p><code>hardy_weinberg P</code> — (p², 2pq, q²) genotype frequencies.</p>
</article>
<article class="doc-entry" id="doc-expected-heterozygosity">
<h3><a class="doc-anchor" href="#doc-expected-heterozygosity">#</a> <code>expected_heterozygosity</code></h3>
<p><code>expected_heterozygosity P_VEC</code> — 1 − Σ p_i².</p>
</article>
<article class="doc-entry" id="doc-fst-simple">
<h3><a class="doc-anchor" href="#doc-fst-simple">#</a> <code>fst_simple</code></h3>
<p><code>fst_simple P1, P2, N1, N2</code> — Wright's F_ST between two populations.</p>
</article>
<article class="doc-entry" id="doc-allele-frequencies">
<h3><a class="doc-anchor" href="#doc-allele-frequencies">#</a> <code>allele_frequencies</code></h3>
<p><code>allele_frequencies GENOTYPES</code> — p, q from 0/1/2 genotype counts.</p>
</article>
</section>
<section class="tutorial-section" id="ch-epidemiology">
<h2>Epidemiology</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-sir-step">
<h3><a class="doc-anchor" href="#doc-sir-step">#</a> <code>sir_step</code></h3>
<p><code>sir_step S, I, R, BETA, GAMMA, DT</code> — Euler step of the SIR model.</p>
</article>
<article class="doc-entry" id="doc-sir-r0">
<h3><a class="doc-anchor" href="#doc-sir-r0">#</a> <code>sir_r0</code></h3>
<p><code>sir_r0 BETA, GAMMA</code> — basic reproduction number β/γ.</p>
</article>
<article class="doc-entry" id="doc-doubling-time">
<h3><a class="doc-anchor" href="#doc-doubling-time">#</a> <code>doubling_time</code></h3>
<p><code>doubling_time R</code> — t₂ = ln 2 / r.</p>
</article>
</section>
<section class="tutorial-section" id="ch-inequality-measures">
<h2>Inequality Measures</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-theil-index">
<h3><a class="doc-anchor" href="#doc-theil-index">#</a> <code>theil_index</code></h3>
<p><code>theil_index XS</code> — Theil T inequality index.</p>
</article>
<article class="doc-entry" id="doc-herfindahl-hirschman">
<h3><a class="doc-anchor" href="#doc-herfindahl-hirschman">#</a> <code>herfindahl_hirschman</code></h3>
<p><code>herfindahl_hirschman SHARES</code> — Σ s_i².</p>
</article>
<article class="doc-entry" id="doc-atkinson-index">
<h3><a class="doc-anchor" href="#doc-atkinson-index">#</a> <code>atkinson_index</code></h3>
<p><code>atkinson_index XS [, EPS]</code> — Atkinson inequality with parameter ε.</p>
</article>
<article class="doc-entry" id="doc-lorenz-curve-points">
<h3><a class="doc-anchor" href="#doc-lorenz-curve-points">#</a> <code>lorenz_curve_points</code></h3>
<p><code>lorenz_curve_points XS</code> — matrix of [cumulative-pop, cumulative-income].</p>
</article>
</section>
<section class="tutorial-section" id="ch-apl-j-array-primitives">
<h2>APL / J Array Primitives</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-iota-range">
<h3><a class="doc-anchor" href="#doc-iota-range">#</a> <code>iota_range</code></h3>
<p><code>iota_range N</code> — <code>0..N</code> (APL convention).</p>
</article>
<article class="doc-entry" id="doc-reshape-array">
<h3><a class="doc-anchor" href="#doc-reshape-array">#</a> <code>reshape_array</code></h3>
<p><code>reshape_array ROWS, COLS, FLAT</code> — APL reshape (cycles input).</p>
</article>
<article class="doc-entry" id="doc-grade-up">
<h3><a class="doc-anchor" href="#doc-grade-up">#</a> <code>grade_up</code></h3>
<p><code>grade_up XS</code> — index permutation that sorts ascending.</p>
</article>
<article class="doc-entry" id="doc-grade-down">
<h3><a class="doc-anchor" href="#doc-grade-down">#</a> <code>grade_down</code></h3>
<p><code>grade_down XS</code> — index permutation that sorts descending.</p>
</article>
</section>
<section class="tutorial-section" id="ch-plasma-physics">
<h2>Plasma Physics</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-plasma-frequency">
<h3><a class="doc-anchor" href="#doc-plasma-frequency">#</a> <code>plasma_frequency</code></h3>
<p><code>plasma_frequency N_E</code> — electron plasma angular frequency (rad/s).</p>
</article>
<article class="doc-entry" id="doc-debye-length">
<h3><a class="doc-anchor" href="#doc-debye-length">#</a> <code>debye_length</code></h3>
<p><code>debye_length T_K, N_E</code> — Debye screening length.</p>
</article>
<article class="doc-entry" id="doc-cyclotron-frequency">
<h3><a class="doc-anchor" href="#doc-cyclotron-frequency">#</a> <code>cyclotron_frequency</code></h3>
<p><code>cyclotron_frequency B [, Q, M]</code> — qB/m (electron defaults).</p>
</article>
<article class="doc-entry" id="doc-larmor-radius">
<h3><a class="doc-anchor" href="#doc-larmor-radius">#</a> <code>larmor_radius</code></h3>
<p><code>larmor_radius V_PERP, B [, Q, M]</code> — gyroradius (electron defaults).</p>
</article>
</section>
<section class="tutorial-section" id="ch-string-similarity">
<h2>String Similarity</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-jaro-winkler-similarity">
<h3><a class="doc-anchor" href="#doc-jaro-winkler-similarity">#</a> <code>jaro_winkler_similarity</code></h3>
<p><code>jaro_winkler_similarity A, B</code> — JW string similarity.</p>
</article>
<article class="doc-entry" id="doc-metaphone-simple">
<h3><a class="doc-anchor" href="#doc-metaphone-simple">#</a> <code>metaphone_simple</code></h3>
<p><code>metaphone_simple S</code> — abridged Metaphone consonant skeleton.</p>
</article>
</section>
<section class="tutorial-section" id="ch-rating-systems">
<h2>Rating Systems</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-elo-rating-update">
<h3><a class="doc-anchor" href="#doc-elo-rating-update">#</a> <code>elo_rating_update</code></h3>
<p><code>elo_rating_update R_A, R_B, SCORE_A [, K]</code> → [R_A', R_B'].</p>
</article>
<article class="doc-entry" id="doc-glicko-rating-update">
<h3><a class="doc-anchor" href="#doc-glicko-rating-update">#</a> <code>glicko_rating_update</code></h3>
<p><code>glicko_rating_update R, RD, OPP_R, OPP_RD, SCORE</code> → [R', RD'].</p>
</article>
<article class="doc-entry" id="doc-dice-sum-pmf">
<h3><a class="doc-anchor" href="#doc-dice-sum-pmf">#</a> <code>dice_sum_pmf</code></h3>
<p><code>dice_sum_pmf N, S, TARGET</code> — probability of N s-sided dice summing to TARGET.</p>
</article>
</section>
<section class="tutorial-section" id="ch-effect-sizes">
<h2>Effect Sizes</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-cohens-d">
<h3><a class="doc-anchor" href="#doc-cohens-d">#</a> <code>cohens_d</code></h3>
<p><code>cohens_d A, B</code> — pooled-SD standardised mean difference.</p>
</article>
<article class="doc-entry" id="doc-cliff-delta">
<h3><a class="doc-anchor" href="#doc-cliff-delta">#</a> <code>cliff_delta</code></h3>
<p><code>cliff_delta A, B</code> — non-parametric effect size in [-1, 1].</p>
</article>
<article class="doc-entry" id="doc-vargha-delaney-a12">
<h3><a class="doc-anchor" href="#doc-vargha-delaney-a12">#</a> <code>vargha_delaney_a12</code></h3>
<p><code>vargha_delaney_a12 A, B</code> — P(X > Y) + 0.5 P(X = Y).</p>
</article>
</section>
<section class="tutorial-section" id="ch-control-transient-response">
<h2>Control Transient Response</h2>
<p class="chapter-meta">2 topics</p>
<article class="doc-entry" id="doc-step-response-2nd-order">
<h3><a class="doc-anchor" href="#doc-step-response-2nd-order">#</a> <code>step_response_2nd_order</code></h3>
<p><code>step_response_2nd_order ZETA, OMEGA_N, T</code> — y(t).</p>
</article>
<article class="doc-entry" id="doc-overshoot-2nd-order">
<h3><a class="doc-anchor" href="#doc-overshoot-2nd-order">#</a> <code>overshoot_2nd_order</code></h3>
<p><code>overshoot_2nd_order ZETA</code> — peak overshoot %.</p>
</article>
</section>
<section class="tutorial-section" id="ch-matrix-norms">
<h2>Matrix Norms</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-frobenius-norm">
<h3><a class="doc-anchor" href="#doc-frobenius-norm">#</a> <code>frobenius_norm</code></h3>
<p><code>frobenius_norm M</code> — √(Σ m_ij²).</p>
</article>
<article class="doc-entry" id="doc-spectral-norm">
<h3><a class="doc-anchor" href="#doc-spectral-norm">#</a> <code>spectral_norm</code></h3>
<p><code>spectral_norm M</code> — largest singular value.</p>
</article>
<article class="doc-entry" id="doc-trace-matrix">
<h3><a class="doc-anchor" href="#doc-trace-matrix">#</a> <code>trace_matrix</code></h3>
<p><code>trace_matrix M</code> — Σ m_ii.</p>
</article>
</section>
<section class="tutorial-section" id="ch-network-triad-analysis">
<h2>Network Triad Analysis</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-homophily-index">
<h3><a class="doc-anchor" href="#doc-homophily-index">#</a> <code>homophily_index</code></h3>
<p><code>homophily_index ADJ, LABELS</code> — fraction of same-group edges.</p>
</article>
<article class="doc-entry" id="doc-dyad-census">
<h3><a class="doc-anchor" href="#doc-dyad-census">#</a> <code>dyad_census</code></h3>
<p><code>dyad_census ADJ</code> — [mutual, asymmetric, null] dyads.</p>
</article>
<article class="doc-entry" id="doc-triad-census">
<h3><a class="doc-anchor" href="#doc-triad-census">#</a> <code>triad_census</code></h3>
<p><code>triad_census ADJ</code> — [empty, edge, path, triangle] counts.</p>
</article>
</section>
<section class="tutorial-section" id="ch-misc-inverses">
<h2>Misc Inverses</h2>
<p class="chapter-meta">1 topics</p>
<article class="doc-entry" id="doc-sigmoid-inverse">
<h3><a class="doc-anchor" href="#doc-sigmoid-inverse">#</a> <code>sigmoid_inverse</code></h3>
<p><code>sigmoid_inverse X</code> — ln(x / (1-x)).</p>
</article>
</section>
<section class="tutorial-section" id="ch-parallel-i-o">
<h2>Parallel I/O</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-par-lines">
<h3><a class="doc-anchor" href="#doc-par-lines">#</a> <code>par_lines</code></h3>
<p><code>par_lines PATH, { code }</code> — memory-map a file and scan its lines in parallel across all available CPU cores.</p>
<p>The file is <code>mmap</code>'d into memory rather than read sequentially, and line boundaries are detected in parallel chunks. Each line is passed to the callback as <code>_</code>. Because the file is memory-mapped, there is no read-buffer overhead and the OS kernel pages data in on demand, making <code>par_lines</code> extremely efficient for multi-gigabyte log files or CSV data. Line order within the callback is not guaranteed (lines run in parallel), so the callback should be a self-contained side-effecting operation (accumulate into a shared structure via <code>pchannel</code>, write to a file, etc.) or use <code>par_lines</code> with a reducer. For ordered processing, use <code>read_lines</code> with <code>pmap</code> instead.</p>
<pre><code class="lang-perl">par_lines "data.txt", fn { process }
# Count matching lines in a large log:
my $count = 0
par_lines "/var/log/syslog", fn { $count++ if /ERROR/ }
p $count
# Feed lines into a channel for downstream processing:
my ($tx, $rx) = pchannel(1000)
async { par_lines "huge.csv", fn { $tx->send(_) }
undef $tx }
</code></pre>
</article>
<article class="doc-entry" id="doc-par-walk">
<h3><a class="doc-anchor" href="#doc-par-walk">#</a> <code>par_walk</code></h3>
<p><code>par_walk PATH, { code }</code> — recursively walk a directory tree in parallel, invoking the callback for every file path found.</p>
<p>Directory traversal is parallelized using a work-stealing thread pool: multiple directories are read concurrently, and the callback fires as each file is discovered. The path is passed as <code>_</code> (absolute). This is significantly faster than a sequential <code>find</code>-style walk on SSDs and networked filesystems where directory <code>readdir</code> latency dominates. Symlinks are not followed by default to avoid cycles. The walk visits files only — directories themselves are not passed to the callback unless you pass <code>dirs => 1</code>. Combine with <code>pmap</code> for a two-phase pattern: first collect paths with <code>par_walk</code>, then process file contents in parallel.</p>
<pre><code class="lang-perl">par_walk "./src", fn { p _ if /\.rs$/ }
# Collect all JSON files under a directory:
my @json_files
par_walk "/data", fn { push @json_files, _ if /\.json$/ }
p scalar @json_files
# Parallel content search:
par_walk ".", fn {
if (/\.log$/) {
my @hits = grep /FATAL/, rl
p "$_: ", scalar @hits, " fatals" if @hits
}
}
</code></pre>
</article>
<article class="doc-entry" id="doc-par-sed">
<h3><a class="doc-anchor" href="#doc-par-sed">#</a> <code>par_sed</code></h3>
<p><code>par_sed PATTERN, REPLACEMENT, @files</code> — perform an in-place regex substitution across multiple files in parallel.</p>
<p>Each file is processed by a separate worker thread: the file is read into memory, all matches of PATTERN are replaced with REPLACEMENT, and the result is written back atomically (via a temp file + rename, so readers never see a partially-written file). This is the stryke equivalent of <code>sed -i</code> but parallelized across the file list — ideal for codebase-wide refactors, log scrubbing, or bulk config updates. The pattern uses stryke regex syntax (PCRE-style). Returns the total number of substitutions made across all files.</p>
<pre><code class="lang-perl">par_sed qr/oldFunc/, "newFunc", glob("src/*.pl")
# Case-insensitive replace across a project:
par_sed qr/TODO/i, "DONE", par_walk(".", fn { _ if /\.rs$/ })
# Scrub sensitive data from logs:
my $n = par_sed qr/\b\d{3}-\d{2}-\d{4}\b/, "XXX-XX-XXXX", @log_files
p "redacted $n occurrences"
</code></pre>
</article>
<article class="doc-entry" id="doc-par-find-files">
<h3><a class="doc-anchor" href="#doc-par-find-files">#</a> <code>par_find_files</code></h3>
<p>Recursively search a directory tree in parallel for files matching a glob pattern. Unlike <code>glob_par</code> which takes a single pattern string, <code>par_find_files</code> separates the root directory from the pattern, making it convenient when the search root is a variable. Returns a list of absolute paths to matching files.</p>
<pre><code class="lang-perl">my @src = par_find_files("src", "*.rs")
p scalar @src # count of Rust files under src/
my @tests = par_find_files(".", "*_test.pl")
@tests |> e p
my @configs = par_find_files("/etc", "*.conf")
</code></pre>
</article>
<article class="doc-entry" id="doc-par-line-count">
<h3><a class="doc-anchor" href="#doc-par-line-count">#</a> <code>par_line_count</code></h3>
<p>Count lines across multiple files in parallel, returning the total line count. Each file is read and counted by a separate thread, making this dramatically faster than sequential <code>wc -l</code> for large file sets. Useful for codebase metrics, log analysis, or validating data pipeline output.</p>
<pre><code class="lang-perl">my @files = glob("src/**/*.rs")
my $total = par_line_count(@files)
p "$total lines of Rust"
my $logs = par_line_count(glob("/var/log/*.log"))
p "$logs log lines"
</code></pre>
</article>
<article class="doc-entry" id="doc-par-csv-read">
<h3><a class="doc-anchor" href="#doc-par-csv-read">#</a> <code>par_csv_read</code></h3>
<p><code>par_csv_read @files</code> — read multiple CSV files in parallel, returning an array of parsed datasets (one per file).</p>
<p>Each file is read and parsed by a separate worker thread using a fast Rust CSV parser that handles quoting, escaping, and UTF-8 correctly. Headers are auto-detected from the first row of each file, and each row is returned as a hashref keyed by header names. This is dramatically faster than sequential CSV parsing when you have many files — common in data engineering pipelines where data arrives as daily/hourly CSV partitions. For a single large CSV file, prefer <code>par_lines</code> with manual splitting, since <code>par_csv_read</code> parallelizes across files, not within a single file.</p>
<pre><code class="lang-perl">my @datasets = par_csv_read glob("data/*.csv")
for my $ds (@datasets) {
p scalar @$ds, " rows"
}
# Merge all CSVs into one list:
my @all_rows = par_csv_read(@files) |> flat
p $all_rows[0]->{name} # access by header
# Filter and aggregate:
my @sales = par_csv_read(glob("sales_*.csv")) |> flat
|> grep { _->{region} eq "US" }
</code></pre>
</article>
<article class="doc-entry" id="doc-glob-par">
<h3><a class="doc-anchor" href="#doc-glob-par">#</a> <code>glob_par</code></h3>
<p>Parallel recursive file-system glob using rayon across multiple patterns. Backed by the same zshrs glob engine as <code>glob</code>, so every zsh qualifier (<code>(/)</code>, <code>(.)</code>, <code>(L+1024)</code>, <code>(om[1])</code>, …) is supported here too. Each pattern expands single-threaded but the patterns run concurrently — ideal for many independent searches. For full qualifier reference see <code>glob</code>.</p>
<pre><code class="lang-perl">my @logs = glob_par("**/*.log")
p scalar @logs # count of log files
"**/*.rs" |> glob_par |> e p # print all Rust files
my @imgs = glob_par("assets/**/*.{png,jpg,webp}")
my @big_recent = glob_par("**(.L+1m om[1,5])") # 5 newest >1MB files
</code></pre>
</article>
<article class="doc-entry" id="doc-pwatch">
<h3><a class="doc-anchor" href="#doc-pwatch">#</a> <code>pwatch</code></h3>
<p><code>pwatch(PATTERN, fn { ... })</code> — watch a path or glob pattern for filesystem changes and invoke the callback on each event.</p>
<p>The watcher runs on a background thread using OS-native notifications (FSEvents on macOS, inotify on Linux) so it consumes near-zero CPU while idle. The callback receives the event path in <code>_</code>. The watcher continues until the returned handle is dropped or the program exits. Useful for live-reload dev servers, file-triggered pipelines, or audit logs. Combine with <code>debounce</code> or a <code>pchannel</code> if the callback is expensive and rapid bursts of events need to be coalesced.</p>
<p>The initial expansion goes through the full zshrs glob engine, so zsh qualifiers (<code>(.)</code>, <code>(/)</code>, <code>(L+1m)</code>, …) work for picking what to watch. The runtime event matcher uses the qualifier-stripped pattern shape — stat-based qualifiers can't apply to a single fired event, but they did apply to the watch-set selection upfront.</p>
<pre><code class="lang-perl">my $w = pwatch "./src/**/*.rs", fn {
p "changed: $_"
rebuild()
}
my $logs = pwatch "logs/*(.)", fn { p "log updated: $_" }
my $cfg = pwatch "./config", fn { reload_config() }
sleep # block forever
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-file-i-o">
<h2>File I/O</h2>
<p class="chapter-meta">35 topics</p>
<article class="doc-entry" id="doc-open">
<h3><a class="doc-anchor" href="#doc-open">#</a> <code>open</code></h3>
<p>Open a filehandle for reading, writing, appending, or piping. The three-argument form <code>open my $fh, MODE, EXPR</code> is strongly preferred for safety — it prevents shell injection and makes the mode explicit. Modes include <code><</code> (read), <code>></code> (write/truncate), <code>>></code> (append), <code>+<</code> (read-write), <code>|-</code> (pipe to command), and <code>-|</code> (pipe from command). In stryke, always use lexical filehandles (<code>my $fh</code>) rather than bareword globals. PerlIO layers can be specified in the mode: <code><:utf8</code>, <code><:raw</code>, <code><:encoding(UTF-16)</code>. Always check the return value — <code>open ... or die "...: $!"</code> is idiomatic. The <code>$!</code> variable contains the OS error message on failure. Forgetting to check <code>open</code> is one of the most common bugs in Perl code.</p>
<pre><code class="lang-perl">open my $fh, '<', 'data.txt' or die "open: $!"
my @lines = <$fh>
close $fh
open my $out, '>>', 'log.txt' or die "append: $!"
print $out tm "event happened\n"
close $out
open my $pipe, '-|', 'ls', '-la' or die "pipe: $!"
while (<$pipe>) { p tm _ }
</code></pre>
</article>
<article class="doc-entry" id="doc-close">
<h3><a class="doc-anchor" href="#doc-close">#</a> <code>close</code></h3>
<p>Close a filehandle, flushing any buffered output and releasing the underlying OS file descriptor. Returns true on success, false on failure — and failure is more common than you might think. For write handles, <code>close</code> is where buffered data actually hits disk, so a full disk or network error may only surface at <code>close</code> time. Always check the return value when writing: <code>close $fh or die "close: $!"</code>. For pipe handles opened with <code>|-</code> or <code>-|</code>, <code>close</code> waits for the child process to exit and sets <code>$?</code> to the child's exit status. In stryke, lexical filehandles are automatically closed when they go out of scope, but explicit <code>close</code> is clearer and lets you handle errors.</p>
<pre><code class="lang-perl">open my $fh, '>', 'out.txt' or die $!
print $fh "done\n"
close $fh or die "write failed: $!"
open my $p, '|-', 'gzip', '-c' or die $!
print $p $data
close $p
p "gzip exited: $?" if $?
</code></pre>
</article>
<article class="doc-entry" id="doc-read">
<h3><a class="doc-anchor" href="#doc-read">#</a> <code>read</code></h3>
<p>Read a specified number of bytes from a filehandle into a scalar buffer. The signature is <code>read FH, SCALAR, LENGTH [, OFFSET]</code>. Returns the number of bytes actually read (which may be less than requested at EOF or on partial reads), 0 at EOF, or <code>undef</code> on error. The optional OFFSET argument lets you append to an existing buffer at a given position, which is useful for accumulating data in a loop. For text files, the bytes are decoded according to the handle's PerlIO layer — use <code><:raw</code> for binary data to avoid encoding transforms. In stryke, <code>read</code> works identically to Perl 5. For line-oriented input, prefer <code><$fh></code> or <code>readline</code> instead.</p>
<pre><code class="lang-perl">open my $fh, '<:raw', $path or die $!
my $buf = ''
while (read $fh, my $chunk, 4096) {
$buf .= $chunk
}
p "total: " . length($buf) . " bytes"
close $fh
</code></pre>
</article>
<article class="doc-entry" id="doc-readline">
<h3><a class="doc-anchor" href="#doc-readline">#</a> <code>readline</code></h3>
<p>Read one line (or all remaining lines in list context) from a filehandle. The angle-bracket operator <code><$fh></code> is syntactic sugar for <code>readline($fh)</code>. In scalar context, returns the next line including the trailing newline (or <code>undef</code> at EOF). In list context, returns all remaining lines as a list. The line ending is determined by <code>$/</code> (input record separator, default <code>\n</code>). Set <code>$/ = undef</code> to slurp the entire file in one read. In stryke, <code>readline</code> integrates with the pipe operator — you can pipe filehandle lines through <code>maps</code>, <code>greps</code>, and other streaming combinators. Always <code>chomp</code> after reading if you don't want trailing newlines.</p>
<pre><code class="lang-perl">while (my $line = <$fh>) {
chomp $line
p $line
}
# Slurp entire file
local $/
my $content = <$fh>
p length $content
</code></pre>
</article>
<article class="doc-entry" id="doc-eof">
<h3><a class="doc-anchor" href="#doc-eof">#</a> <code>eof</code></h3>
<p>Test whether a filehandle has reached end-of-file. Returns 1 if the next read on the handle would return EOF, 0 otherwise. Called without arguments, <code>eof()</code> (with parens) checks the last file in the <code><></code> / <code>ARGV</code> stream. Called with no parens as <code>eof</code>, it tests whether the current ARGV file is exhausted but more files may follow. In stryke, <code>eof</code> is typically used in <code>until</code> loops or as a guard before <code>read</code> calls. Note that <code>eof</code> may trigger a blocking read on interactive handles (like STDIN from a terminal) to determine if data is available, so avoid calling it speculatively on interactive input. For most line-processing, <code>while (<$fh>)</code> is simpler and implicitly handles EOF.</p>
<pre><code class="lang-perl">until (eof $fh) {
my $line = <$fh>
p tm $line
}
# Process multiple files via ARGV
while (<>) {
p "new file: $ARGV" if eof()
}
</code></pre>
</article>
<article class="doc-entry" id="doc-seek">
<h3><a class="doc-anchor" href="#doc-seek">#</a> <code>seek</code></h3>
<p>Reposition a filehandle to an arbitrary byte offset. The signature is <code>seek FH, POSITION, WHENCE</code> where WHENCE is 0 (absolute from start), 1 (relative to current position), or 2 (relative to end of file). Use the <code>Fcntl</code> constants <code>SEEK_SET</code>, <code>SEEK_CUR</code>, <code>SEEK_END</code> for clarity. Returns 1 on success, 0 on failure. <code>seek</code> is essential for random-access file I/O — re-reading headers, skipping to known offsets in binary formats, or rewinding a file for a second pass. In stryke, <code>seek</code> flushes the PerlIO buffer before repositioning. Do not mix <code>seek</code>/<code>tell</code> with <code>sysread</code>/<code>syswrite</code> — they use separate buffering layers.</p>
<pre><code class="lang-perl">seek $fh, 0, 0 # rewind to start
my $header = <$fh>
seek $fh, -100, 2 # last 100 bytes
read $fh, my $tail, 100
p $tail
</code></pre>
</article>
<article class="doc-entry" id="doc-tell">
<h3><a class="doc-anchor" href="#doc-tell">#</a> <code>tell</code></h3>
<p>Return the current byte offset of a filehandle's read/write position. Returns a non-negative integer on success, or -1 if the handle is invalid or not seekable (e.g., pipes, sockets). Useful for bookmarking a position before a speculative read so you can <code>seek</code> back if the data doesn't match expectations. In stryke, <code>tell</code> reflects the PerlIO buffered position, not the raw OS file descriptor position — so it correctly accounts for encoding layers and buffered reads. Pair with <code>seek</code> for random-access patterns.</p>
<pre><code class="lang-perl">my $pos = tell $fh
p "at byte $pos"
# Bookmark and restore
my $mark = tell $fh
my $line = <$fh>
unless ($line =~ /^HEADER/) {
seek $fh, $mark, 0 # rewind to before the read
}
</code></pre>
</article>
<article class="doc-entry" id="doc-print">
<h3><a class="doc-anchor" href="#doc-print">#</a> <code>print</code></h3>
<p>Write operands to the selected output handle (default <code>STDOUT</code>) without appending a newline. The output field separator <code>$,</code> is inserted between arguments, and <code>$\</code> is appended at the end — both default to empty string. You can direct output to a specific handle by passing it as the first argument with no comma: <code>print STDERR "msg"</code>. In stryke, <code>print</code> behaves identically to Perl 5 and is useful when you need precise control over output formatting, such as building progress bars, writing binary data, or emitting partial lines. For most line-oriented output, prefer <code>p</code> (say) instead since it handles the newline automatically.</p>
<pre><code class="lang-perl">print "no newline"
print STDERR "error msg\n"
print $fh "data to filehandle\n"
for my $pct (0:100) {
printf "\rprogress: %3d%%", $pct
}
print "\n"
</code></pre>
</article>
<article class="doc-entry" id="doc-say">
<h3><a class="doc-anchor" href="#doc-say">#</a> <code>say</code></h3>
<p>Print operands followed by an automatic newline to <code>STDOUT</code>. In stryke, <code>say</code> is always available without <code>-E</code> or <code>use feature 'say'</code> — it is a first-class builtin. The shorthand <code>p</code> is an alias for <code>say</code> and is preferred in most stryke code. When given a list, <code>say</code> joins elements with <code>$,</code> (output field separator, empty by default) and appends <code>$\</code> plus a newline. For streaming output over pipelines, combine with <code>e</code> (each) to print one element per line. Gotcha: <code>say</code> always adds a newline — if you need raw output without one, use <code>print</code> instead.</p>
<pre><code class="lang-perl">p "hello world"
my @names = ("alice", "bob", "eve")
@names |> e p
1:5 |> maps { _ * 2 } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-printf">
<h3><a class="doc-anchor" href="#doc-printf">#</a> <code>printf</code></h3>
<p>Formatted print to a filehandle (default <code>STDOUT</code>), using C-style format specifiers. The first argument is the format string with <code>%s</code> (string), <code>%d</code> (integer), <code>%f</code> (float), <code>%x</code> (hex), <code>%o</code> (octal), <code>%e</code> (scientific), <code>%g</code> (general float), and <code>%%</code> (literal percent). Width and precision modifiers work as in C: <code>%-10s</code> left-aligns in a 10-char field, <code>%05d</code> zero-pads to 5 digits, <code>%.2f</code> gives 2 decimal places. In stryke, <code>printf</code> supports all standard Perl 5 format specifiers including <code>%v</code> (version strings) and <code>%n</code> is disabled for safety. Direct output to a handle by placing it before the format: <code>printf STDERR "...", @args</code>. Unlike <code>sprintf</code>, <code>printf</code> outputs directly and returns a boolean indicating success.</p>
<pre><code class="lang-perl">printf "%-10s %5d\n", $name, $score
printf STDERR "error %d: %s\n", $code, $msg
printf "%08.2f\n", 3.14159 # 00003.14
printf "%s has %d item%s\n", $user, $n, $n == 1 ? "" : "s"
</code></pre>
</article>
<article class="doc-entry" id="doc-sprintf">
<h3><a class="doc-anchor" href="#doc-sprintf">#</a> <code>sprintf</code></h3>
<p>Return a formatted string without printing it, using the same C-style format specifiers as <code>printf</code>. This is the go-to function for building formatted strings for later use — constructing log messages, building padded table columns, converting numbers to hex or binary representations, or assembling strings that will be passed to other functions. In stryke, <code>sprintf</code> is often combined with the pipe operator: <code>$val |> t { sprintf "0x%04x", _ } |> p</code>. The return value is always a string. All format specifiers from <code>printf</code> apply here.</p>
<pre><code class="lang-perl">my $hex = sprintf "0x%04x", 255
my $padded = sprintf "%08d", $id
my $msg = sprintf "%-20s: %s", $key, $value
my @rows = map { sprintf "%3d. %s", _, $names[_] } 0..$ #names
@rows |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-slurp">
<h3><a class="doc-anchor" href="#doc-slurp">#</a> <code>slurp</code></h3>
<p>Read an entire file into memory as a single UTF-8 string, or — when the path is a glob pattern — concatenate the contents of every matching regular file. Aliases: <code>sl</code>, <code>cat</code>, <code>c</code>. Dies if the file is missing or unreadable. For binary data use <code>read_bytes</code>/<code>slurp_raw</code>.</p>
<p>When the path contains glob metacharacters (<code>*</code> <code>?</code> <code>[</code> <code>**</code>) or a trailing zsh qualifier suffix <code>(...)</code>, it is expanded by the zshrs glob engine and the results are concatenated. <strong><code>slurp</code> hard-fails if the qualifier yields any non-regular file</strong> — <code>slurp "**(/)"</code> errors <code>slurp: not a regular file: ./sub</code> because slurping a directory is meaningless. To list directory paths, use <code>glob "**(/)"</code>. See <code>glob</code> for the full qualifier reference.</p>
<pre><code class="lang-perl">my $text = slurp("config.yaml")
my $all = c("**(.)") # every regular file recursively, concatenated
my $logs = c("logs/*.log") # all logs in one go
my $json = sl("data.json")
my $data = decode_json($json)
"README.md" |> sl |> length |> p # character count
</code></pre>
</article>
<article class="doc-entry" id="doc-slurp-raw">
<h3><a class="doc-anchor" href="#doc-slurp-raw">#</a> <code>slurp_raw</code></h3>
<p>Read an entire file into memory as raw bytes without any encoding interpretation. Unlike <code>slurp</code>, which returns a decoded UTF-8 string, <code>read_bytes</code> preserves the exact byte content — useful for binary files like images, compressed archives, or protocol buffers. The alias <code>slurp_raw</code> emphasizes the raw nature.</p>
<pre><code class="lang-perl">my $png = read_bytes("logo.png")
p length($png) # byte count
my $gz = slurp_raw("data.gz")
my $text = gunzip($gz)
p $text
</code></pre>
</article>
<article class="doc-entry" id="doc-input">
<h3><a class="doc-anchor" href="#doc-input">#</a> <code>input</code></h3>
<p>Slurp all of stdin (or a filehandle) as one string.</p>
<pre><code class="lang-perl">my $all = input # slurp stdin
my $fh_data = input($fh) # slurp filehandle
</code></pre>
</article>
<article class="doc-entry" id="doc-read-lines">
<h3><a class="doc-anchor" href="#doc-read-lines">#</a> <code>read_lines</code></h3>
<p>Read a file and return its contents as a list of lines with trailing newlines stripped. This is the idiomatic way to slurp a file line-by-line in stryke without manually opening a filehandle. The short alias <code>rl</code> keeps one-liners concise. If the file does not exist, the program dies with an error message.</p>
<pre><code class="lang-perl">my @lines = rl("data.txt")
p scalar @lines # line count
@lines |> grep /ERROR/ |> e p # print error lines
my $first = (rl "config.ini")[0]$1
Note: returns an empty list for an empty file.
</code></pre>
</article>
<article class="doc-entry" id="doc-append-file">
<h3><a class="doc-anchor" href="#doc-append-file">#</a> <code>append_file</code></h3>
<p>Append a string to the end of a file, creating it if it does not exist. This is the safe way to add content without overwriting — useful for log files, CSV accumulation, or incremental output. The short alias <code>af</code> is convenient in pipelines. The file is opened, written, and closed atomically per call.</p>
<pre><code class="lang-perl">af("log.txt", "started at " . datetime_utc() . "\n")
1:5 |> e { af("nums.txt", "$_\n") }
my @data = ("a","b","c")
@data |> e { af "out.txt", "$_\n" }
</code></pre>
</article>
<article class="doc-entry" id="doc-to-file">
<h3><a class="doc-anchor" href="#doc-to-file">#</a> <code>to_file</code></h3>
<p>Write a string to a file, truncating any existing content. Unlike <code>append_file</code>, this replaces the file entirely. Returns the written content so it can be used in a pipeline — write to disk and continue processing in one expression. Creates the file if it does not exist.</p>
<pre><code class="lang-perl">my $csv = "name,age\nAlice,30\nBob,25"
$csv |> to_file("people.csv") |> p
to_file("empty.txt", "") # truncate a file
</code></pre>
<p>Note: the return-value-for-piping behavior distinguishes this from a plain write.</p>
</article>
<article class="doc-entry" id="doc-write">
<h3><a class="doc-anchor" href="#doc-write">#</a> <code>write</code></h3>
<p>Output a formatted record to a filehandle using a <code>format</code> declaration. <code>write</code> looks up the format associated with the current (or specified) filehandle, evaluates the format's picture lines against the current variables, and outputs the result. This is Perl's original report-generation mechanism, predating modules like <code>Text::Table</code> and template engines. In stryke, <code>write</code> and <code>format</code> are supported for backward compatibility but are rarely used in new code — <code>printf</code>/<code>sprintf</code> or template strings are more flexible. The format name defaults to the filehandle name (e.g., format <code>STDOUT</code> is used by <code>write STDOUT</code>).</p>
<pre><code class="lang-perl">format STDOUT =
@<<<<<<<<<< @>>>>>>
$name, $score
.
my ($name, $score) = ("alice", 42)
write # outputs: alice 42
</code></pre>
</article>
<article class="doc-entry" id="doc-write-file">
<h3><a class="doc-anchor" href="#doc-write-file">#</a> <code>write_file</code></h3>
<p>Write a string to a file, creating it if it does not exist or truncating it if it does. This is the complement of <code>slurp</code> — together they form a read/write pair for whole-file operations. The short alias <code>wf</code> is convenient for one-liners. The file is opened, written, and closed in a single call.</p>
<pre><code class="lang-perl">spurt("hello.txt", "Hello, world!\n")
wf("nums.txt", join("\n", 1:10))
"generated content" |> wf("out.txt")
my $data = slurp("in.txt")
wf("copy.txt", $data)
</code></pre>
</article>
<article class="doc-entry" id="doc-write-json">
<h3><a class="doc-anchor" href="#doc-write-json">#</a> <code>write_json</code></h3>
<p>Serialize a stryke data structure (hash ref or array ref) as pretty-printed JSON and write it to a file. Creates or overwrites the target file. The short alias <code>wj</code> pairs with <code>rj</code> for round-trip JSON workflows. Useful for persisting configuration, caching API responses, or generating fixture data.</p>
<pre><code class="lang-perl">my %data = (name => "Alice", scores => [98, 87, 95])
wj("out.json", \%data)
my $back = rj("out.json")
p $back->{name} # Alice
</code></pre>
</article>
<article class="doc-entry" id="doc-read-json">
<h3><a class="doc-anchor" href="#doc-read-json">#</a> <code>read_json</code></h3>
<p>Read a JSON file from disk and parse it into a stryke data structure (hash ref or array ref). The short alias <code>rj</code> keeps JSON-config one-liners terse. Dies if the file does not exist or contains malformed JSON. This is the complement of <code>write_json</code>/<code>wj</code>.</p>
<pre><code class="lang-perl">my $cfg = rj("config.json")
p $cfg->{database}{host}
my @items = @{ rj("list.json") }
@items |> e { p _->{name} }$1
Note: numeric strings remain strings; use `+0` to coerce if needed.
</code></pre>
</article>
<article class="doc-entry" id="doc-tempfile">
<h3><a class="doc-anchor" href="#doc-tempfile">#</a> <code>tempfile</code></h3>
<p>Create a temporary file in the system temp directory and return its absolute path as a string. The file is created with a unique name and exists on disk immediately. Use <code>tf</code> as a short alias for quick scratch files in one-liners. The caller is responsible for cleanup, though OS temp-directory reaping will eventually reclaim it.</p>
<pre><code class="lang-perl">my $tmp = tf()
to_file($tmp, "scratch data\n")
p rl($tmp) # scratch data
my @all = map { tf() } 1:3 # three temp files
</code></pre>
</article>
<article class="doc-entry" id="doc-tempdir">
<h3><a class="doc-anchor" href="#doc-tempdir">#</a> <code>tempdir</code></h3>
<p>Create a temporary directory in the system temp directory and return its absolute path. The directory is created with a unique name and is ready for use immediately. The short alias <code>tdr</code> mirrors <code>tf</code> for files. Useful for isolating multi-file operations like test fixtures, build artifacts, or staged output.</p>
<pre><code class="lang-perl">my $dir = tdr()
to_file("$dir/a.txt", "hello")
to_file("$dir/b.txt", "world")
my @files = glob("$dir/*.txt")
p scalar @files # 2
</code></pre>
</article>
<article class="doc-entry" id="doc-binmode">
<h3><a class="doc-anchor" href="#doc-binmode">#</a> <code>binmode</code></h3>
<p>Set the I/O layer on a filehandle, controlling how bytes are translated during reads and writes. Without a layer argument, <code>binmode $fh</code> switches the handle to raw binary mode (no CRLF translation on Windows, no encoding transforms). With a layer, <code>binmode $fh, ':utf8'</code> enables UTF-8 decoding, <code>binmode $fh, ':raw'</code> strips all layers for pure byte I/O, and <code>binmode $fh, ':encoding(ISO-8859-1)'</code> sets a specific encoding. In stryke, encoding layers can also be specified directly in <code>open</code>: <code>open my $fh, '<:utf8', $path</code>. Call <code>binmode</code> before any I/O on the handle — calling it mid-stream may produce garbled output. For binary file processing (images, archives, network protocols), always use <code>:raw</code>.</p>
<pre><code class="lang-perl">open my $fh, '<', $path or die $!
binmode $fh, ':utf8'
my @lines = <$fh>
open my $bin, '<', $img_path or die $!
binmode $bin, ':raw'
read $bin, my $header, 8
p sprintf "magic: %s", unpack("H*", $header)
</code></pre>
</article>
<article class="doc-entry" id="doc-fileno">
<h3><a class="doc-anchor" href="#doc-fileno">#</a> <code>fileno</code></h3>
<p>Return the underlying OS file descriptor number for a filehandle, or <code>undef</code> if the handle is not connected to a real file descriptor (e.g., tied handles, in-memory handles opened to scalar refs). File descriptor numbers are small non-negative integers managed by the OS kernel: 0 is STDIN, 1 is STDOUT, 2 is STDERR. This function is mainly useful for interfacing with system calls that require raw fd numbers, checking whether two handles share the same underlying fd, or passing descriptors to child processes. In stryke, <code>fileno</code> is rarely needed in everyday code but is essential for low-level I/O multiplexing and process management.</p>
<pre><code class="lang-perl">my $fd = fileno STDOUT
p "stdout fd: $fd" # 1
if (defined fileno $fh) {
p "handle is backed by fd " . fileno($fh)
} else {
p "not a real file descriptor"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-flock">
<h3><a class="doc-anchor" href="#doc-flock">#</a> <code>flock</code></h3>
<p>Advisory file locking for coordinating access between processes. <code>flock $fh, OPERATION</code> where OPERATION is <code>LOCK_SH</code> (shared/read lock), <code>LOCK_EX</code> (exclusive/write lock), or <code>LOCK_UN</code> (unlock). Add <code>LOCK_NB</code> for non-blocking mode: <code>LOCK_EX | LOCK_NB</code> returns false immediately if the lock is held rather than waiting. Import constants from <code>Fcntl</code>. Advisory locks are cooperative — they only work if all processes accessing the file use <code>flock</code>. In stryke, <code>flock</code> is the standard mechanism for safe concurrent file access in multi-process scripts, cron jobs, and daemons. Always unlock explicitly or let the handle close (which releases the lock). Gotcha: <code>flock</code> does not work on NFS on many systems.</p>
<pre><code class="lang-perl">use Fcntl ':flock'
open my $fh, '>>', 'shared.log' or die $!
flock $fh, LOCK_EX or die "lock: $!"
print $fh tm "pid $$ wrote this\n"
flock $fh, LOCK_UN
close $fh
unless (flock $fh, LOCK_EX | LOCK_NB) {
p "file is locked by another process"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-getc">
<h3><a class="doc-anchor" href="#doc-getc">#</a> <code>getc</code></h3>
<p>Read a single character from a filehandle (default <code>STDIN</code>). Returns <code>undef</code> at EOF. The character returned respects the handle's encoding layer — under <code>:utf8</code>, <code>getc</code> returns a full Unicode character which may be multiple bytes on disk. This function is useful for interactive single-key input, parsing binary formats one byte at a time, or implementing character-level tokenizers. In stryke, <code>getc</code> blocks until a character is available on the handle. For terminal input, note that most terminals are line-buffered by default, so <code>getc STDIN</code> won't return until the user presses Enter unless you put the terminal into raw mode.</p>
<pre><code class="lang-perl">my $ch = getc STDIN
p "you pressed: $ch"
open my $fh, '<:utf8', $path or die $!
while (defined(my $c = getc $fh)) {
p "char: $c (ord " . ord($c) . ")"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-select">
<h3><a class="doc-anchor" href="#doc-select">#</a> <code>select</code></h3>
<p>In its one-argument form, <code>select HANDLE</code> sets the default output handle for <code>print</code>, <code>say</code>, and <code>write</code>, returning the previously selected handle. This is useful for temporarily redirecting output — for example, sending diagnostics to STDERR while a report goes to a file. In its four-argument form, <code>select RBITS, WBITS, EBITS, TIMEOUT</code> performs POSIX <code>select(2)</code> I/O multiplexing, waiting for one or more file descriptors to become ready for reading, writing, or to report exceptions. The four-argument form is low-level and rarely used directly in stryke — prefer <code>IO::Select</code> or async I/O patterns for multiplexing. <code>select</code> with <code>$|</code> is also the classic way to enable autoflush on a handle.</p>
<pre><code class="lang-perl">my $old = select STDERR
p "this goes to stderr"
select $old
# Enable autoflush on STDOUT
select STDOUT; $| = 1
print "immediately flushed"
</code></pre>
</article>
<article class="doc-entry" id="doc-truncate">
<h3><a class="doc-anchor" href="#doc-truncate">#</a> <code>truncate</code></h3>
<p>Truncate a file to a specified byte length. Accepts either a filehandle or a filename as the first argument, and the desired length as the second. <code>truncate $fh, 0</code> empties the file entirely — a common pattern when rewriting a file in place. <code>truncate $fh, $len</code> discards everything beyond byte <code>$len</code>. Returns true on success, false on failure (check <code>$!</code> for the error). In stryke, truncate works on any seekable filehandle. When using truncate to rewrite a file, remember to also <code>seek $fh, 0, 0</code> to rewind the write position — truncating does not move the file pointer. Gotcha: truncating a file opened read-only will fail.</p>
<pre><code class="lang-perl">open my $fh, '+<', 'data.txt' or die $!
truncate $fh, 0 # empty the file
seek $fh, 0, 0 # rewind to start
print $fh "fresh content\n"
close $fh
</code></pre>
</article>
<article class="doc-entry" id="doc-sysopen">
<h3><a class="doc-anchor" href="#doc-sysopen">#</a> <code>sysopen</code></h3>
<p>Low-level open using POSIX flags for precise control over how a file is opened. The signature is <code>sysopen FH, FILENAME, FLAGS [, PERMS]</code>. Flags are bitwise-OR combinations from <code>Fcntl</code>: <code>O_RDONLY</code>, <code>O_WRONLY</code>, <code>O_RDWR</code>, <code>O_CREAT</code>, <code>O_EXCL</code>, <code>O_TRUNC</code>, <code>O_APPEND</code>, <code>O_NONBLOCK</code>, and others. The optional PERMS argument (e.g., <code>0644</code>) sets the file mode when <code>O_CREAT</code> creates a new file, subject to the process umask. <code>sysopen</code> is the right tool when you need <code>O_EXCL</code> for atomic file creation (lock files, temp files), <code>O_NONBLOCK</code> for non-blocking I/O, or other flags that <code>open</code> cannot express. In stryke, prefer three-argument <code>open</code> for routine file access and reserve <code>sysopen</code> for cases requiring specific POSIX semantics.</p>
<pre><code class="lang-perl">use Fcntl
# Atomic create — fails if file already exists
sysopen my $lock, '/tmp/my.lock', O_WRONLY|O_CREAT|O_EXCL, 0644
or die "already running: $!"
print $lock $$
sysopen my $log, 'app.log', O_WRONLY|O_APPEND|O_CREAT, 0644
or die "open log: $!"
</code></pre>
</article>
<article class="doc-entry" id="doc-sysread">
<h3><a class="doc-anchor" href="#doc-sysread">#</a> <code>sysread</code></h3>
<p>Low-level unbuffered read directly from a file descriptor, bypassing PerlIO buffering layers. The signature is <code>sysread FH, SCALAR, LENGTH [, OFFSET]</code>. Returns the number of bytes read, 0 at EOF, or <code>undef</code> on error. Unlike <code>read</code>, <code>sysread</code> issues a single <code>read(2)</code> system call and may return fewer bytes than requested (short read). This is the right choice for sockets, pipes, and non-blocking I/O where you need precise control over how many system calls occur and cannot tolerate buffering. In stryke, never mix <code>sysread</code>/<code>syswrite</code> with buffered I/O (<code>print</code>, <code>read</code>, <code><$fh></code>) on the same handle — the buffered and unbuffered positions will diverge and produce corrupted reads.</p>
<pre><code class="lang-perl">open my $fh, '<:raw', $path or die $!
my $buf = ''
while (my $n = sysread $fh, $buf, 4096, length($buf)) {
p "read $n bytes (total: " . length($buf) . ")"
}
close $fh
</code></pre>
</article>
<article class="doc-entry" id="doc-syswrite">
<h3><a class="doc-anchor" href="#doc-syswrite">#</a> <code>syswrite</code></h3>
<p>Low-level unbuffered write directly to a file descriptor, bypassing PerlIO buffering layers. The signature is <code>syswrite FH, SCALAR [, LENGTH [, OFFSET]]</code>. Returns the number of bytes actually written, which may be less than requested on non-blocking handles or when writing to pipes/sockets (short write). Returns <code>undef</code> on error. Like <code>sysread</code>, this issues a single <code>write(2)</code> system call and must not be mixed with buffered I/O on the same handle. In stryke, <code>syswrite</code> is essential for socket programming, IPC, and performance-critical binary output where you need to avoid double-buffering. Always check the return value and handle short writes in a loop for robust code.</p>
<pre><code class="lang-perl">my $data = "hello, world"
my $n = syswrite $fh, $data
p "wrote $n bytes"
# Robust write loop for sockets
my $off = 0
while ($off < length $data) {
my $written = syswrite $fh, $data, length($data) - $off, $off
die "syswrite: $!" unless defined $written
$off += $written
}
</code></pre>
</article>
<article class="doc-entry" id="doc-sysseek">
<h3><a class="doc-anchor" href="#doc-sysseek">#</a> <code>sysseek</code></h3>
<p>Low-level seek on a file descriptor, bypassing PerlIO buffering. The signature is <code>sysseek FH, POSITION, WHENCE</code> with the same WHENCE values as <code>seek</code> (0=start, 1=current, 2=end). Returns the new position as a true value, or <code>undef</code> on failure. Unlike <code>seek</code>, <code>sysseek</code> does not flush PerlIO buffers — it operates directly on the underlying OS file descriptor. Use <code>sysseek</code> when working with <code>sysread</code>/<code>syswrite</code> for consistent positioning. In stryke, <code>sysseek</code> with <code>SEEK_CUR</code> and position 0 is an idiom for querying the current fd position without moving: <code>my $pos = sysseek $fh, 0, 1</code>.</p>
<pre><code class="lang-perl">sysseek $fh, 0, 0 # rewind to start
sysread $fh, my $buf, 512
my $pos = sysseek $fh, 0, 1
p "fd position: $pos"
</code></pre>
</article>
<article class="doc-entry" id="doc-format">
<h3><a class="doc-anchor" href="#doc-format">#</a> <code>format</code></h3>
<p>Declare a picture-format template for generating fixed-width text reports. The syntax is <code>format NAME = ... .</code> where each line alternates between picture lines (containing field placeholders) and argument lines (listing the variables to fill in). Placeholders include <code>@<<<<</code> (left-align), <code>@>>>></code> (right-align), <code>@||||</code> (center), <code>@###.##</code> (numeric with decimal), and <code>@*</code> (multiline block fill). The format ends with a lone <code>.</code> on its own line. In stryke, formats are a legacy feature preserved for compatibility with Perl 5 code — for new reports, prefer <code>printf</code>/<code>sprintf</code> for simple alignment or a templating module for complex layouts. Formats interact with the special variables <code>$~</code> (current format name), <code>$^</code> (header format), and <code>$=</code> (lines per page).</p>
<pre><code class="lang-perl">format REPORT =
@<<<<<<<<<<<<<<<< @>>>>> @ ###.##
$item, $qty, $price
.
my ($item, $qty, $price) = ("Widget", 100, 9.99)
my $old = select REPORT
$~ = 'REPORT'
write REPORT
select $old
</code></pre>
</article>
<article class="doc-entry" id="doc-formline">
<h3><a class="doc-anchor" href="#doc-formline">#</a> <code>formline</code></h3>
<p>Format a line of output according to a picture template, appending the result to the <code>$^A</code> (format accumulator) variable. This is the low-level engine behind Perl's <code>format</code>/<code>write</code> report-generation system. Template characters like <code>@<<<</code> (left-justify), <code>@>>></code> (right-justify), and <code>@###.##</code> (numeric) control field placement.</p>
<pre><code class="lang-perl">$^A = ""
formline("@<<<< @>>>>>\n", "Name", "Score")
formline("@<<<< @>>>>>\n", "Alice", 98)
formline("@<<<< @>>>>>\n", "Bob", 85)
p $^A
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-strings">
<h2>Strings</h2>
<p class="chapter-meta">26 topics</p>
<article class="doc-entry" id="doc-chomp">
<h3><a class="doc-anchor" href="#doc-chomp">#</a> <code>chomp</code></h3>
<p><code>chomp STRING</code> — remove the trailing record separator (usually <code>\n</code>) from a string in place and return the number of characters removed.</p>
<p><code>chomp</code> is the idiomatic way to strip newlines after reading input; unlike <code>chop</code>, it only removes the value of <code>$/</code> (the input record separator), so it is safe to call on strings that do not end with a newline — it simply does nothing. You can also <code>chomp</code> an entire array to strip every element at once. In stryke, <code>chomp</code> operates on UTF-8 strings and respects multi-byte <code>$/</code> values. Prefer <code>chomp</code> over <code>chop</code> in virtually all input-processing code; <code>chop</code> is only for when you truly need to remove an arbitrary trailing character regardless of what it is.</p>
<pre><code class="lang-perl">my $line = <STDIN>
chomp $line
p $line
chomp(my @lines = <$fh>) # strip all at once
p scalar @lines
</code></pre>
</article>
<article class="doc-entry" id="doc-chop">
<h3><a class="doc-anchor" href="#doc-chop">#</a> <code>chop</code></h3>
<p><code>chop STRING</code> — remove and return the last character of a string, modifying the string in place.</p>
<p>Unlike <code>chomp</code>, <code>chop</code> unconditionally removes whatever the final character is — newline, letter, digit, or even a multi-byte UTF-8 codepoint in stryke. The return value is the removed character. This makes <code>chop</code> useful for peeling off known trailing delimiters or building parsers that consume input character-by-character, but dangerous for general newline removal because it will silently eat a real character if the string does not end with <code>\n</code>. When called on an array, <code>chop</code> removes the last character of every element and returns the last one removed.</p>
<pre><code class="lang-perl">my $s = "hello!"
my $last = chop $s # $last = "!", $s = "hello"
p $s
my @words = ("foo\n", "bar\n")
chop @words # strips trailing newline from each
@words |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-length">
<h3><a class="doc-anchor" href="#doc-length">#</a> <code>length</code></h3>
<p><code>length STRING</code> — return the <strong>byte</strong> length of a string. Perl 5 builtin; pairs with <code>index</code> / <code>rindex</code> / <code>substr</code> (all byte-based) so positions and lengths share a coordinate system.</p>
<p><code>length "hello"</code> is 5; <code>length "─"</code> is 3 (the box-drawing char takes 3 bytes in UTF-8). For codepoint count, use <code>len</code> (stryke extension), which mirrors <code>[i]</code> / <code>[a:b]</code> slice semantics.</p>
<pre><code class="lang-perl">p length "hello" # 5
p length "─" # 3 (bytes)
p len "─" # 1 (codepoint)
p length "\x{1F600}" # 4 (bytes — emoji is 4-byte UTF-8)
p len "\x{1F600}" # 1 (codepoint)
</code></pre>
</article>
<article class="doc-entry" id="doc-substr">
<h3><a class="doc-anchor" href="#doc-substr">#</a> <code>substr</code></h3>
<p><code>substr STRING, OFFSET [, LENGTH [, REPLACEMENT]]</code> — extract or replace a substring.</p>
<p><code>substr</code> is stryke's Swiss-army knife for positional string manipulation. With two arguments it extracts from OFFSET to end; with three it extracts LENGTH characters; with four it replaces that range with REPLACEMENT and returns the original extracted portion. Negative OFFSET counts from the end of the string (<code>substr $s, -3</code> gives the last three characters). In stryke, offsets are UTF-8 character positions, making it safe for multi-byte text. <code>substr</code> as an lvalue (<code>substr($s, 0, 1) = "X"</code>) is also supported for in-place mutation. Prefer <code>substr</code> over regex when you know exact positions — it is faster and clearer.</p>
<pre><code class="lang-perl">my $s = "hello world"
p substr $s, 0, 5 # hello
p substr $s, -5 # world
substr $s, 6, 5, "stryke" # $s = "hello stryke"
p $s
</code></pre>
</article>
<article class="doc-entry" id="doc-index">
<h3><a class="doc-anchor" href="#doc-index">#</a> <code>index</code></h3>
<p><code>index STRING, SUBSTRING [, POSITION]</code> — return the zero-based <strong>byte</strong> position of the first occurrence of SUBSTRING within STRING, or -1 if not found. Pairs with <code>substr</code> and <code>length</code> (both byte-based) for Perl 5 compat.</p>
<p>The optional POSITION argument lets you start the search at a given offset, which is essential for scanning forward through a string in a loop (call <code>index</code> repeatedly, advancing POSITION past each hit). For multi-byte strings where you want <strong>codepoint</strong> positions paired with <code>[i]</code> / <code>[a:b]</code> slice operators, use <code>cindex</code> (stryke extension) instead — <code>index</code> is byte-indexed because <code>length</code> and <code>substr</code> are, and changing it would break Perl 5 binary-protocol code.</p>
<pre><code class="lang-perl">my $i = index "hello world", "world" # 6
p $i
my $s = "a.b.c.d"
my $pos = 0
while (($pos = index $s, ".", $pos) != -1) {
p "dot at $pos"
$pos++
}
</code></pre>
</article>
<article class="doc-entry" id="doc-rindex">
<h3><a class="doc-anchor" href="#doc-rindex">#</a> <code>rindex</code></h3>
<p><code>rindex STRING, SUBSTRING [, POSITION]</code> — return the zero-based <strong>byte</strong> position of the last occurrence of SUBSTRING within STRING, searching backward from POSITION (or the end). Mirror of <code>index</code>; pairs with <code>substr</code> and <code>length</code> for Perl 5 compat.</p>
<p><code>rindex</code> searches from right to left, making it ideal for extracting file extensions, final path components, or the last delimiter in a string. The optional POSITION argument caps how far right the search begins — characters after POSITION are ignored. Returns -1 when the substring is not found. For codepoint positions paired with <code>[]</code> slice operators, use <code>crindex</code>.</p>
<pre><code class="lang-perl">my $path = "foo/bar/baz.tar.gz"
my $i = rindex $path, "/" # 7
p substr $path, $i + 1 # baz.tar.gz
my $ext = rindex $path, "." # 15
p substr $path, $ext + 1 # gz
</code></pre>
</article>
<article class="doc-entry" id="doc-split">
<h3><a class="doc-anchor" href="#doc-split">#</a> <code>split</code></h3>
<p><code>split /PATTERN/, STRING [, LIMIT]</code> — divide STRING into a list of substrings by splitting on each occurrence of PATTERN.</p>
<p><code>split</code> is one of the most-used string functions. The PATTERN is a regex, so you can split on character classes, alternations, or lookaheads. A LIMIT caps the number of returned fields; the final field contains the unsplit remainder. The special pattern <code>" "</code> (a single space string, not regex) mimics <code>awk</code>-style splitting: it strips leading whitespace and splits on runs of whitespace. In stryke, <code>split</code> integrates with <code>|></code> pipelines, accepting piped-in strings for ergonomic one-liners. Trailing empty fields are removed by default; pass -1 as LIMIT to preserve them.</p>
<pre><code class="lang-perl">my @parts = split /,/, "a,b,c"
"one:two:three" |> split /:/ |> e p # one two three
my ($user, $domain) = split /@/, $email, 2
p "$user at $domain"
</code></pre>
</article>
<article class="doc-entry" id="doc-join">
<h3><a class="doc-anchor" href="#doc-join">#</a> <code>join</code></h3>
<p><code>join SEPARATOR, LIST</code> — concatenate all elements of LIST into a single string, placing SEPARATOR between each pair of adjacent elements.</p>
<p><code>join</code> is the inverse of <code>split</code>. It stringifies each element before joining, so mixing numbers and strings is fine. An empty separator (<code>join "", @list</code>) concatenates without gaps. In stryke, <code>join</code> works naturally with <code>|></code> pipelines: a range or filtered list can be piped directly into <code>join</code> with a separator argument. This is the standard way to build CSV lines, path strings, or human-readable lists from arrays. <code>join</code> never adds a trailing separator — if you need one, append it yourself.</p>
<pre><code class="lang-perl">my $csv = join ",", @fields
1:5 |> join "-" |> p # 1-2-3-4-5
my @parts = ("usr", "local", "bin")
p join "/", "", @parts # /usr/local/bin
</code></pre>
</article>
<article class="doc-entry" id="doc-uc">
<h3><a class="doc-anchor" href="#doc-uc">#</a> <code>uc</code></h3>
<p><code>uc STRING</code> — return a fully uppercased copy of the string.</p>
<p><code>uc</code> performs Unicode-aware uppercasing in stryke, correctly handling multi-byte characters and locale-sensitive transformations. It returns a new string without modifying the original. Use <code>uc</code> for normalizing strings before comparison, formatting headers, or transforming pipeline output. In stryke <code>|></code> chains, combine with <code>maps</code> or <code>t</code> for streaming uppercase transforms. For uppercasing only the first character (e.g., sentence capitalization), use <code>ucfirst</code> instead.</p>
<pre><code class="lang-perl">p uc "hello" # HELLO
@words |> maps { uc } |> e p
"whisper" |> t uc |> p # WHISPER
</code></pre>
</article>
<article class="doc-entry" id="doc-lc">
<h3><a class="doc-anchor" href="#doc-lc">#</a> <code>lc</code></h3>
<p><code>lc STRING</code> — return a fully lowercased copy of the string.</p>
<p><code>lc</code> performs Unicode-aware lowercasing in stryke, so <code>lc "\x{C4}"</code> (capital A with diaeresis) correctly returns the lowercase form. It does not modify the original string — it returns a new one. This is the standard way to normalize strings for case-insensitive comparison: <code>if (lc $a eq lc $b)</code>. In stryke <code>|></code> pipelines, wrap <code>lc</code> with <code>t</code> to apply it as a streaming transform. For lowercasing only the first character, use <code>lcfirst</code> instead.</p>
<pre><code class="lang-perl">p lc "HELLO" # hello
"SHOUT" |> t lc |> t rev |> p # tuohs
my @norm = map lc, @words
@norm |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-ucfirst">
<h3><a class="doc-anchor" href="#doc-ucfirst">#</a> <code>ucfirst</code></h3>
<p><code>ucfirst STRING</code> — return a copy of the string with only the first character uppercased, leaving the rest unchanged.</p>
<p>This is the standard way to capitalize the first letter of a word for display, title-casing, or converting camelCase to PascalCase. In stryke, <code>ucfirst</code> is Unicode-aware and correctly handles multi-byte leading characters. It returns a new string and does not modify the original. For full uppercasing, use <code>uc</code>. A common idiom is <code>ucfirst lc $word</code> to normalize a word to "Title" form.</p>
<pre><code class="lang-perl">p ucfirst "hello" # Hello
p ucfirst lc "hELLO" # Hello
my @titled = map { ucfirst lc } @raw
@titled |> join " " |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcfirst">
<h3><a class="doc-anchor" href="#doc-lcfirst">#</a> <code>lcfirst</code></h3>
<p><code>lcfirst STRING</code> — return a copy of the string with only the first character lowercased, leaving the rest unchanged.</p>
<p>This is useful for converting PascalCase identifiers to camelCase, or for formatting output where only the initial letter matters. In stryke, <code>lcfirst</code> is Unicode-aware, so it handles accented capitals and multi-byte first characters correctly. Like <code>lc</code>, it returns a new string rather than modifying in place. If you need the entire string lowercased, use <code>lc</code> instead.</p>
<pre><code class="lang-perl">p lcfirst "Hello" # hello
p lcfirst "XMLParser" # xMLParser
my @camel = map lcfirst, @PascalNames
@camel |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-chr">
<h3><a class="doc-anchor" href="#doc-chr">#</a> <code>chr</code></h3>
<p><code>chr NUMBER</code> — return the character represented by the given ASCII or Unicode code point.</p>
<p><code>chr</code> is the inverse of <code>ord</code>: <code>chr(ord($c)) eq $c</code> always holds. It accepts any non-negative integer and returns a single-character string. In stryke, values above 127 produce valid UTF-8 characters, so <code>chr 0x1F600</code> gives you a smiley emoji with no special encoding gymnastics. For string literals, stryke supports all standard escapes: <code>\x{hex}</code>, <code>\u{hex}</code>, <code>\o{oct}</code>, <code>\NNN</code> (octal), <code>\cX</code> (control), <code>\N{U+hex}</code>, <code>\N{UNICODE NAME}</code>, plus case modifiers <code>\U..\E</code>, <code>\L..\E</code>, <code>\u</code>, <code>\l</code>, <code>\Q..\E</code>.</p>
<pre><code class="lang-perl">p chr 65 # A
p chr 0x1F600 # smiley emoji
p "\u{0301}" # combining acute accent
p "\N{SNOWMAN}" # ☃
my @abc = map { chr(_ + 64) } 1:26
@abc |> join "" |> p # ABCDEFGHIJKLMNOPQRSTUVWXYZ
</code></pre>
</article>
<article class="doc-entry" id="doc-ord">
<h3><a class="doc-anchor" href="#doc-ord">#</a> <code>ord</code></h3>
<p><code>ord STRING</code> — return the numeric (Unicode code point) value of the first character of the string.</p>
<p><code>ord</code> is the inverse of <code>chr</code>: <code>ord(chr($n)) == $n</code> always holds. When passed a multi-character string, only the first character is examined — the rest are ignored. In stryke, <code>ord</code> returns the full Unicode code point, not just 0-255, so <code>ord "\u{1F600}"</code> returns 128512. This is useful for character classification, building lookup tables, or implementing custom encodings. For ASCII checks, <code>ord($c) >= 32 && ord($c) <= 126</code> tests printability.</p>
<pre><code class="lang-perl">p ord "A" # 65
p ord "\n" # 10
p ord "\u{1F600}" # 128512
my @codes = map ord, split //, "hello"
@codes |> e p # 104 101 108 108 111
</code></pre>
</article>
<article class="doc-entry" id="doc-hex">
<h3><a class="doc-anchor" href="#doc-hex">#</a> <code>hex</code></h3>
<p><code>hex STRING</code> — interpret a hexadecimal string and return its numeric value.</p>
<p>The leading <code>0x</code> prefix is optional: both <code>hex "ff"</code> and <code>hex "0xff"</code> return 255. The string is case-insensitive, so <code>hex "DeAdBeEf"</code> works fine. If the string contains non-hex characters, stryke warns and converts up to the first invalid character. This is the standard way to parse hex-encoded values from config files, color codes, or protocol dumps. For the reverse operation (number to hex string), use <code>sprintf "%x"</code>. Note that <code>hex</code> always returns a number, never a string — arithmetic is immediate.</p>
<pre><code class="lang-perl">my $n = hex "deadbeef"
printf "0x%x = %d\n", $n, $n
p hex "ff" # 255
"cafe" |> t { hex } |> p # 51966
</code></pre>
</article>
<article class="doc-entry" id="doc-oct">
<h3><a class="doc-anchor" href="#doc-oct">#</a> <code>oct</code></h3>
<p><code>oct STRING</code> — interpret an octal, hexadecimal, or binary string and return its numeric value.</p>
<p><code>oct</code> is the multi-base cousin of <code>hex</code>: it auto-detects the base from the prefix. Strings starting with <code>0b</code> are binary, <code>0x</code> are hex, and bare digits or <code>0</code>-prefixed digits are octal. This makes it the go-to for parsing Unix file permissions (<code>oct "0755"</code> gives 493), binary literals, or any string where the radix is embedded in the value. In stryke, <code>oct</code> handles arbitrarily large integers via the same big-number pathway as other arithmetic. A common gotcha: <code>oct "8"</code> warns because 8 is not a valid octal digit — use <code>hex</code> or a bare numeric literal instead.</p>
<pre><code class="lang-perl">p oct "0755" # 493
p oct "0b1010" # 10
p oct "0xff" # 255
my $perms = oct "644"
p sprintf "%04o", $perms # 0644
</code></pre>
</article>
<article class="doc-entry" id="doc-quotemeta">
<h3><a class="doc-anchor" href="#doc-quotemeta">#</a> <code>quotemeta</code></h3>
<p><code>quotemeta STRING</code> — escape all non-alphanumeric characters with backslashes, returning a string safe for interpolation into a regex.</p>
<p>This is essential when building dynamic regexes from user input: without <code>quotemeta</code>, characters like <code>.</code>, <code>*</code>, <code>(</code>, <code>)</code>, <code>[</code>, and <code>\</code> would be interpreted as regex metacharacters, leading to either broken patterns or security vulnerabilities (ReDoS). The equivalent inline syntax is <code>\Q..\E</code> inside a regex. In stryke, <code>quotemeta</code> handles the full Unicode range, escaping any character that is not <code>[A-Za-z0-9_]</code>. Use it liberally whenever you splice user-provided strings into patterns.</p>
<pre><code class="lang-perl">my $input = "file (1).txt"
my $safe = quotemeta $input
p $safe # file\ \(1\)\.txt
my $found = ("file (1).txt" =~ /^$safe$/)
p $found # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-trim">
<h3><a class="doc-anchor" href="#doc-trim">#</a> <code>trim</code></h3>
<p><code>trim STRING</code> or <code>trim LIST</code> — strip leading and trailing ASCII whitespace.</p>
<p>When given a single string, <code>trim</code> returns the stripped result. When given a list or used in a pipeline, it operates in streaming mode, trimming each element individually as it flows through. Whitespace includes spaces, tabs, carriage returns, and newlines. The <code>tm</code> alias is convenient in pipeline chains where brevity matters.</p>
<pre><code class="lang-perl">" hello " |> tm |> p # "hello"
@raw |> tm |> e p
slurp("data.csv") |> ln |> tm |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-lines">
<h3><a class="doc-anchor" href="#doc-lines">#</a> <code>lines</code></h3>
<p><code>lines STRING</code> / <code>ln STRING</code> — split a string on newline boundaries, returning a streaming iterator of lines.</p>
<p>Each line is yielded without the trailing newline character. When piped from <code>slurp</code>, this gives you a lazy line-by-line view of a file without loading all lines into memory at once. Both <code>\n</code> and <code>\r\n</code> line endings are handled. The <code>ln</code> alias keeps pipelines compact.</p>
<pre><code class="lang-perl">slurp("data.txt") |> lines |> e p
my @rows = lines $multiline_str
$body |> ln |> grep /TODO/ |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-words">
<h3><a class="doc-anchor" href="#doc-words">#</a> <code>words</code></h3>
<p><code>words</code> (alias <code>wd</code>) splits a string on whitespace boundaries and returns the resulting list of words. It handles leading, trailing, and consecutive whitespace gracefully — unlike a naive <code>split / /</code>, it never produces empty strings. This is the idiomatic way to tokenize a line of text in stryke, and the short alias <code>wd</code> keeps pipelines compact. It is equivalent to Perl's <code>split ' '</code> behavior.</p>
<pre><code class="lang-perl">my @w = wd " hello world "
p @w # hello, world
my $line = " foo bar baz "
my $count = scalar wd $line
p $count # 3
rl("data.txt") |> map { scalar wd _ } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-chars">
<h3><a class="doc-anchor" href="#doc-chars">#</a> <code>chars</code></h3>
<p><code>chars STRING</code> / <code>ch STRING</code> — split a string into individual characters, returning a streaming iterator.</p>
<p>Each Unicode grapheme cluster is yielded as a separate string element. This is useful for character-level processing such as frequency counting, transliteration, or building character n-grams. In pipeline mode the characters stream one at a time, so you can chain with <code>take</code>, <code>grep</code>, or <code>with_index</code> without materializing the full character array.</p>
<pre><code class="lang-perl">"hello" |> chars |> e p # h e l l o
my @c = chars "abc"
"emoji: \x{1F600}" |> ch |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-snake-case">
<h3><a class="doc-anchor" href="#doc-snake-case">#</a> <code>snake_case</code></h3>
<p><code>snake_case</code> (alias <code>sc</code>) converts a string from any common casing convention — camelCase, PascalCase, kebab-case, or mixed — into snake_case, where words are lowercase and separated by underscores. This is the standard naming convention for Perl and Rust variables and function names. Consecutive uppercase letters in acronyms are handled intelligently (e.g., <code>parseHTTPResponse</code> becomes <code>parse_http_response</code>).</p>
<pre><code class="lang-perl">p sc "camelCase" # camel_case
p sc "PascalCase" # pascal_case
p sc "kebab-case" # kebab_case
p sc "parseHTTPResponse" # parse_http_response
my @methods = qw(getUserName setEmailAddr)
@methods |> map sc |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-camel-case">
<h3><a class="doc-anchor" href="#doc-camel-case">#</a> <code>camel_case</code></h3>
<p><code>camel_case</code> (alias <code>cc</code>) converts a string from any casing convention into camelCase, where the first word is lowercase and subsequent words are capitalized with no separators. This is the standard naming convention for JavaScript variables and Java methods. The function handles underscores, hyphens, and spaces as word boundaries and strips them during conversion.</p>
<pre><code class="lang-perl">p cc "snake_case" # snakeCase
p cc "kebab-case" # kebabCase
p cc "PascalCase" # pascalCase
p cc "hello world" # helloWorld
my @cols = qw(first_name last_name email_addr)
@cols |> map cc |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-kebab-case">
<h3><a class="doc-anchor" href="#doc-kebab-case">#</a> <code>kebab_case</code></h3>
<p><code>kebab_case</code> (alias <code>kc</code>) converts a string from any casing convention into kebab-case, where words are lowercase and separated by hyphens. This is the standard naming convention for CSS classes, URL slugs, and CLI flag names. Like <code>snake_case</code>, it intelligently handles acronyms and mixed-case input. The function treats underscores, spaces, and case transitions as word boundaries.</p>
<pre><code class="lang-perl">p kc "camelCase" # camel-case
p kc "PascalCase" # pascal-case
p kc "snake_case" # snake-case
p kc "parseHTTPResponse" # parse-http-response
my $slug = kc $title # URL-safe slug
</code></pre>
</article>
<article class="doc-entry" id="doc-study">
<h3><a class="doc-anchor" href="#doc-study">#</a> <code>study</code></h3>
<p><code>study STRING</code> — hint to the regex engine that the given string will be matched against multiple patterns, allowing it to build an internal lookup table for faster matching.</p>
<p>In classic Perl, <code>study</code> builds a linked list of character positions so subsequent regex matches can skip impossible starting points. In practice, modern regex engines (including stryke's Rust-based engine) already perform these optimizations internally, so <code>study</code> is effectively a no-op in stryke — calling it is harmless but provides no measurable speedup. It exists for compatibility with Perl code that uses it. You only need <code>study</code> when porting legacy scripts that call it; do not add it to new stryke code expecting a performance benefit.</p>
<pre><code class="lang-perl">study $text # no-op in stryke, kept for compatibility
my @hits = grep { /$pattern/ } @lines
p scalar @hits
</code></pre>
</article>
<article class="doc-entry" id="doc-pos">
<h3><a class="doc-anchor" href="#doc-pos">#</a> <code>pos</code></h3>
<p><code>pos SCALAR</code> — gets or sets the position where the next <code>m//g</code> (global match) will start searching in the given string. After a successful <code>m//g</code> match, <code>pos</code> returns the offset just past the end of the match. You can assign to <code>pos($s)</code> to manually reposition the search. If the last <code>m//g</code> failed, <code>pos</code> resets to <code>undef</code>. This is essential for writing lexers or tokenizers that consume a string incrementally with <code>\G</code>-anchored patterns. In stryke, <code>pos</code> tracks per-scalar state just like Perl.</p>
<pre><code class="lang-perl">my $s = "abcabc"
while ($s =~ /a/g) { p pos($s) }
# 1 4
pos($s) = 0 # reset to scan again
p pos($s) # 0
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-arrays-hashes">
<h2>Arrays & Hashes</h2>
<p class="chapter-meta">20 topics</p>
<article class="doc-entry" id="doc-push">
<h3><a class="doc-anchor" href="#doc-push">#</a> <code>push</code></h3>
<p><code>push @array, LIST</code> — appends one or more elements to the end of an array and returns the new length. This is the primary way to grow arrays in stryke and works identically to Perl's builtin. You can push scalars, lists, or even the result of a pipeline. In stryke, <code>push</code> is O(1) amortized thanks to the underlying Rust <code>Vec</code>.</p>
<pre><code class="lang-perl">my @q
push @q, 1:3
push @q, "four", "five"
p scalar @q # 5
@q |> e p # 1 2 3 four five
</code></pre>
<p>Returns the new element count, so <code>my $len = push @arr, $val;</code> is valid.</p>
</article>
<article class="doc-entry" id="doc-pop">
<h3><a class="doc-anchor" href="#doc-pop">#</a> <code>pop</code></h3>
<p><code>pop @array</code> — removes and returns the last element of an array, or <code>undef</code> if the array is empty. This is the complement of <code>push</code> and together they give you classic stack (LIFO) semantics. In stryke the operation is O(1) because the underlying Rust <code>Vec::pop</code> simply decrements the length. When called without an argument inside a subroutine, <code>pop</code> operates on <code>@_</code>; at file scope it operates on <code>@ARGV</code>, matching standard Perl behavior.</p>
<pre><code class="lang-perl">my @stk = 1:5
my $top = pop @stk
p $top # 5
p scalar @stk # 4
@stk |> e p # 1 2 3 4
</code></pre>
</article>
<article class="doc-entry" id="doc-shift">
<h3><a class="doc-anchor" href="#doc-shift">#</a> <code>shift</code></h3>
<p><code>shift @array</code> — removes and returns the first element of an array, sliding all remaining elements down by one index. Like <code>pop</code>, it returns <code>undef</code> on an empty array. Without an explicit argument it defaults to <code>@_</code> inside subroutines and <code>@ARGV</code> at file scope. Because every element must be moved, <code>shift</code> is O(n); if you only need LIFO access, prefer <code>push</code>/<code>pop</code>. Use <code>shift</code> when processing argument lists or implementing FIFO queues.</p>
<pre><code class="lang-perl">my @args = @ARGV
my $cmd = shift @args
p $cmd
@args |> e p # remaining arguments
</code></pre>
</article>
<article class="doc-entry" id="doc-unshift">
<h3><a class="doc-anchor" href="#doc-unshift">#</a> <code>unshift</code></h3>
<p><code>unshift @array, LIST</code> — prepends one or more elements to the beginning of an array and returns the new length. It is the counterpart of <code>push</code> for the front of the array. Like <code>shift</code>, this is O(n) because existing elements must be moved to make room. When you need to build an array in reverse order or maintain a priority queue with newest items first, <code>unshift</code> is the idiomatic choice. You can pass multiple values and they will appear in the same order they were given.</p>
<pre><code class="lang-perl">my @log = ("b", "c")
unshift @log, "a"
@log |> e p # a b c
my $len = unshift @log, "x", "y"
p $len # 5
@log |> e p # x y a b c
</code></pre>
</article>
<article class="doc-entry" id="doc-splice">
<h3><a class="doc-anchor" href="#doc-splice">#</a> <code>splice</code></h3>
<p><code>splice @array, OFFSET [, LENGTH [, LIST]]</code> — the Swiss-army knife for array mutation. It can insert, remove, or replace elements at any position in a single call. With just an offset it removes everything from that point to the end. With offset and length it removes that many elements. With a replacement list it inserts those elements in place of the removed ones. The return value is the list of removed elements, which is useful for saving what you cut. In stryke this compiles down to Rust's <code>Vec::splice</code> and <code>Vec::drain</code>.</p>
<pre><code class="lang-perl">my @a = 1:5
my @removed = splice @a, 1, 2, 8, 9
@a |> e p # 1 8 9 4 5
@removed |> e p # 2 3
splice @a, 2 # remove from index 2 onward
@a |> e p # 1 8
</code></pre>
</article>
<article class="doc-entry" id="doc-splice-last">
<h3><a class="doc-anchor" href="#doc-splice-last">#</a> <code>splice_last</code></h3>
<p><code>splice_last @array, OFFSET [, LENGTH [, LIST]]</code> — same shape as <code>splice</code>, but returns the <strong>last</strong> removed element instead of the full removed list (or <code>undef</code> if nothing was removed). The stryke spelling of Perl's <code>scalar splice(@a, off, n)</code> for <code>--no-interop</code> mode where <code>scalar</code> is rejected at parse time. The array is still mutated in place, exactly like <code>splice</code>. Aliases: <code>splice1</code>, <code>spl_last</code>. Desugars to <code>tail(splice(...))</code> so any list-context property of <code>splice</code> is preserved.</p>
<pre><code class="lang-perl">my @a = 10:50:10
my $last = splice_last @a, 1, 2 # removes (20, 30), returns 30
@a |> e p # 10 40 50
my $popped = splice_last @b, 0, 0 # removes nothing, returns undef
</code></pre>
</article>
<article class="doc-entry" id="doc-keys">
<h3><a class="doc-anchor" href="#doc-keys">#</a> <code>keys</code></h3>
<p><code>keys %hash</code> — returns the list of all keys in a hash in no particular order. When called on an array, it returns the list of valid indices (0 to <code>$#array</code>). In scalar context, <code>keys</code> returns the number of keys. Calling <code>keys</code> resets the <code>each</code> iterator on that hash, which is the standard way to restart iteration. In stryke, this calls Rust's <code>HashMap::keys()</code> and collects into a <code>Vec</code>. For sorted output, chain with <code>sort</code> via the pipe operator.</p>
<pre><code class="lang-perl">my %env = (HOME => "/root", USER => "me")
keys(%env) |> sort |> e p # HOME USER
p scalar keys %env # 2
my @a = (10, 20, 30)
keys(@a) |> e p # 0 1 2
</code></pre>
</article>
<article class="doc-entry" id="doc-values">
<h3><a class="doc-anchor" href="#doc-values">#</a> <code>values</code></h3>
<p><code>values %hash</code> — returns the list of all values in a hash in no particular order (matching the order of <code>keys</code> for the same hash state). When called on an array, it returns the array elements themselves. In scalar context, returns the count of values. Like <code>keys</code>, calling <code>values</code> resets the <code>each</code> iterator. In stryke this maps to Rust's <code>HashMap::values()</code>. Combine with <code>sum</code>, <code>sort</code>, or pipeline operators for common aggregation patterns.</p>
<pre><code class="lang-perl">my %scores = (alice => 90, bob => 85)
p sum(values %scores) # 175
values(%scores) |> sort { $_1 <=> $_0 } |> e p # 90 85
</code></pre>
</article>
<article class="doc-entry" id="doc-each">
<h3><a class="doc-anchor" href="#doc-each">#</a> <code>each</code></h3>
<p><code>each %hash</code> — returns the next (key, value) pair from a hash as a two-element list, or an empty list when the iterator is exhausted. Each hash has its own internal iterator, which is reset when you call <code>keys</code> or <code>values</code> on the same hash. This is memory-efficient for large hashes because it does not build the full key list. Gotcha: do not add or delete keys while iterating with <code>each</code>; that can cause skipped or duplicated entries. In stryke, the iteration order is non-deterministic (Rust <code>HashMap</code> order).</p>
<pre><code class="lang-perl">my %h = (a => 1, b => 2, c => 3)
while (my ($k, $v) = each %h) { p "$k=$v" }
# output order varies: a=1 b=2 c=3
</code></pre>
</article>
<article class="doc-entry" id="doc-delete">
<h3><a class="doc-anchor" href="#doc-delete">#</a> <code>delete</code></h3>
<p><code>delete EXPR</code> — removes a key-value pair from a hash or an element from an array and returns the removed value (or <code>undef</code> if it did not exist). For hashes this is the only way to truly remove a key; assigning <code>undef</code> to <code>$h{key}</code> leaves the key in place. For arrays, <code>delete</code> sets the element to <code>undef</code> but does not shift indices (use <code>splice</code> if you need to close the gap). In stryke, hash deletion maps to Rust's <code>HashMap::remove</code>. You can delete multiple keys at once with a hash slice: <code>delete @h{@keys}</code>.</p>
<pre><code class="lang-perl">my %h = (x => 1, y => 2, z => 3)
my $old = delete $h{x}
p $old # 1
p exists $h{x} ? "yes" : "no" # no
delete @h{"y", "z"} # delete multiple keys
</code></pre>
</article>
<article class="doc-entry" id="doc-exists">
<h3><a class="doc-anchor" href="#doc-exists">#</a> <code>exists</code></h3>
<p><code>exists EXPR</code> — tests whether a specific key is present in a hash or an index is present in an array, regardless of whether the associated value is <code>undef</code>. This is different from <code>defined</code>: a key can exist but hold <code>undef</code>. Use <code>exists</code> to check hash membership before accessing a value to avoid autovivification side effects. In stryke, <code>exists</code> on a hash compiles to Rust's <code>HashMap::contains_key</code>, and on an array it checks bounds. You can also use it with nested structures: <code>exists $h{a}{b}</code> only checks the final level.</p>
<pre><code class="lang-perl">my %h = (a => 1, b => undef)
p exists $h{b} ? "yes" : "no" # yes (key present, value undef)
p exists $h{c} ? "yes" : "no" # no
my @a = (10, 20, 30)
p exists $a[5] ? "yes" : "no" # no
</code></pre>
</article>
<article class="doc-entry" id="doc-scalar">
<h3><a class="doc-anchor" href="#doc-scalar">#</a> <code>scalar</code></h3>
<p><code>scalar EXPR</code> — forces the expression into scalar context. The most common use is <code>scalar @array</code> to get the element count instead of the list of elements. In stryke, scalar context on an array returns its length as a Rust <code>usize</code>. You can also use <code>scalar</code> on a hash to get the number of key-value pairs, or on a function call to force it to return a single value. This is essential when you want a count inside string interpolation or as a function argument where list context would be ambiguous.</p>
<pre><code class="lang-perl">my @items = ("a", "b", "c")
p scalar @items # 3
p "count: " . scalar @items # count: 3
my %h = (x => 1, y => 2)
p scalar %h # 2
</code></pre>
</article>
<article class="doc-entry" id="doc-defined">
<h3><a class="doc-anchor" href="#doc-defined">#</a> <code>defined</code></h3>
<p><code>defined EXPR</code> — returns true if the expression has a value that is not <code>undef</code>. This is the canonical way to distinguish between "no value" and "a value that happens to be false" (such as <code>0</code>, <code>""</code>, or <code>"0"</code>). Use <code>defined</code> before dereferencing optional values or checking return codes from functions that return <code>undef</code> on failure. In stryke, <code>defined</code> compiles to a Rust <code>Option::is_some()</code> check internally. Note that <code>defined</code> on an aggregate (hash or array) is deprecated in Perl 5 and is a no-op in stryke.</p>
<pre><code class="lang-perl">my $x = undef
p defined($x) ? "yes" : "no" # no
$x = 0
p defined($x) ? "yes" : "no" # yes
my $val = fn_that_may_fail()
p $val if defined $val
</code></pre>
</article>
<article class="doc-entry" id="doc-undef">
<h3><a class="doc-anchor" href="#doc-undef">#</a> <code>undef</code></h3>
<p><code>undef</code> — the undefined value, representing the absence of a value. As a function, <code>undef $var</code> explicitly undefines a variable, freeing any value it held. <code>undef</code> is falsy in boolean context and triggers "use of uninitialized value" warnings under <code>use warnings</code>. In stryke, <code>undef</code> maps to Rust's <code>None</code> in an <code>Option</code> type internally. Use <code>undef</code> to reset variables, signal missing return values, or clear hash entries without deleting the key.</p>
<pre><code class="lang-perl">my $x = 42
undef $x
p defined($x) ? "def" : "undef" # undef
fn maybe { return undef if !@_
return $_[0] }
p defined(maybe()) ? "got" : "nothing" # nothing
</code></pre>
</article>
<article class="doc-entry" id="doc-ref">
<h3><a class="doc-anchor" href="#doc-ref">#</a> <code>ref</code></h3>
<p><code>ref EXPR</code> — returns a string indicating the reference type of the value, or an empty string if it is not a reference. Common return values are <code>SCALAR</code>, <code>ARRAY</code>, <code>HASH</code>, <code>CODE</code>, <code>REF</code>, and <code>Regexp</code>. For blessed objects it returns the class name. Use <code>ref</code> to dispatch on data type or validate arguments in polymorphic functions. In stryke, <code>ref</code> inspects the Rust enum variant of the underlying value. Note that <code>ref</code> does not recurse; it only tells you the top-level type.</p>
<pre><code class="lang-perl">my $r = [1, 2, 3]
p ref($r) # ARRAY
p ref(\%ENV) # HASH
p ref(\&main) # CODE
p ref(42) # (empty string)
</code></pre>
</article>
<article class="doc-entry" id="doc-bless">
<h3><a class="doc-anchor" href="#doc-bless">#</a> <code>bless</code></h3>
<p>Associate a reference with a package name, turning it into an object of that class. The blessed reference can then have methods called on it via <code>-></code>. The second argument defaults to the current package. This is the foundation of Perl's object system.</p>
<pre><code class="lang-perl">fn new($class, %args) {
bless { %args }, $class
}
my $obj = new("Dog", name => "Rex", breed => "Lab")
p ref($obj) # Dog
p $obj->{name} # Rex
</code></pre>
</article>
<article class="doc-entry" id="doc-tie">
<h3><a class="doc-anchor" href="#doc-tie">#</a> <code>tie</code></h3>
<p>Bind a variable to an implementing class so that all accesses (read, write, delete, etc.) are intercepted by methods on that class. This is Perl's mechanism for transparent object-backed variables — tied hashes can be backed by a database, tied scalars can validate on assignment, etc. Use <code>untie</code> to remove the binding.</p>
<pre><code class="lang-perl">tie my %db, 'DB_File', 'cache.db'
$db{key} = "value" # writes to disk
p $db{key} # reads from disk
untie %db
</code></pre>
</article>
<article class="doc-entry" id="doc-prototype">
<h3><a class="doc-anchor" href="#doc-prototype">#</a> <code>prototype</code></h3>
<p>Return the prototype string of a named function, or <code>undef</code> if the function has no prototype. Prototypes control how arguments are parsed at compile time — they influence context and reference-passing behavior. Useful for introspection and metaprogramming.</p>
<pre><code class="lang-perl">p prototype("CORE::push") # \@@
p prototype("CORE::map") # &@
fn greet($name) { p "hi $name" }
p prototype(\&greet) # undef (signatures, no proto)
</code></pre>
</article>
<article class="doc-entry" id="doc-wantarray">
<h3><a class="doc-anchor" href="#doc-wantarray">#</a> <code>wantarray</code></h3>
<p><code>wantarray()</code> — returns true if the current subroutine was called in list context, false in scalar context, and <code>undef</code> in void context. This lets a function adapt its return value to the caller's expectations. A common pattern is returning a list in list context and a count or reference in scalar context. In stryke, use <code>fn</code> to define subroutines and <code>wantarray()</code> inside them just like in Perl. Note that <code>wantarray</code> only reflects the immediate call site, not nested contexts.</p>
<pre><code class="lang-perl">fn ctx { wantarray() ? "list" : "scalar" }
my @r = ctx()
p $r[0] # list
my $r = ctx()
p $r # scalar
fn flexible { wantarray() ? (1, 2, 3) : 3 }
my @all = flexible()
p scalar @all # 3
my $cnt = flexible()
p $cnt # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-caller">
<h3><a class="doc-anchor" href="#doc-caller">#</a> <code>caller</code></h3>
<p><code>caller [LEVEL]</code> — returns information about the calling subroutine's context. In list context it returns <code>(package, filename, line)</code> for the given call-stack level (default 0, the immediate caller). With higher levels you can walk up the call stack for debugging or generating stack traces. In scalar context, <code>caller</code> returns just the package name. In stryke, <code>caller</code> works with <code>fn</code>-defined subroutines and integrates with the runtime's frame tracking. This is invaluable for building custom error reporters or trace utilities.</p>
<pre><code class="lang-perl">fn here {
my ($pkg, $f, $ln) = caller()
p "$f:$ln"
}
here() # prints current file:line
fn deep {
my ($pkg, $f, $ln) = caller(1)
p "grandparent: $f:$ln"
}
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-control-flow">
<h2>Control Flow</h2>
<p class="chapter-meta">17 topics</p>
<article class="doc-entry" id="doc-if">
<h3><a class="doc-anchor" href="#doc-if">#</a> <code>if</code></h3>
<p>The fundamental conditional construct. Evaluates its condition in boolean context and executes the block if true. stryke supports both the block form <code>if (COND) { BODY }</code> and the postfix form <code>EXPR if COND</code>, which is idiomatic for single-statement guards. The condition can be any expression — numbers (0 is false), strings (empty and <code>"0"</code> are false), undef (false), and references (always true). Postfix <code>if</code> cannot have <code>elsif</code>/<code>else</code> — use the block form for multi-branch logic.</p>
<pre><code class="lang-perl">my $n = 42
if ($n > 0) { p "positive" }
p "big" if $n > 10 # postfix — clean one-liner
my $label = "even" if $n % 2 == 0
p "got: $n" if defined $n # guard against undef
</code></pre>
</article>
<article class="doc-entry" id="doc-elsif">
<h3><a class="doc-anchor" href="#doc-elsif">#</a> <code>elsif</code></h3>
<p>Chain additional conditions after an <code>if</code> block without nesting. Each <code>elsif</code> is tested in order; the first one whose condition is true has its block executed, and the rest are skipped. There is no limit on the number of <code>elsif</code> branches. In stryke, prefer <code>match</code> for complex multi-branch dispatch since it supports pattern matching, destructuring, and guards — but <code>elsif</code> remains the right tool for simple linear condition chains. Note: it is <code>elsif</code>, not <code>elseif</code> or <code>else if</code> — the latter is a syntax error.</p>
<pre><code class="lang-perl">fn classify($n) {
if ($n < 0) { "negative" }
elsif ($n == 0) { "zero" }
elsif ($n < 10) { "small" }
elsif ($n < 100) { "medium" }
else { "large" }
}
1:200 |> map classify |> frequencies |> dd
</code></pre>
</article>
<article class="doc-entry" id="doc-else">
<h3><a class="doc-anchor" href="#doc-else">#</a> <code>else</code></h3>
<p>The final fallback branch of an <code>if</code>/<code>elsif</code> chain, executed when no preceding condition was true. Every <code>if</code> can have at most one <code>else</code>, and it must come last. For ternary-style expressions, use <code>COND ? A : B</code> instead of an <code>if</code>/<code>else</code> block — it composes better in <code>|></code> pipes and assignments.</p>
<pre><code class="lang-perl">if ($n % 2 == 0) { p "even" }
else { p "odd" }
# Ternary is often cleaner in pipes:
1:10 |> map { _ % 2 == 0 ? "even" : "odd" } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-unless">
<h3><a class="doc-anchor" href="#doc-unless">#</a> <code>unless</code></h3>
<p>A negated conditional — executes the block when the condition is *false*. This reads more naturally than <code>if (!COND)</code> for guard clauses and early returns. stryke supports both block and postfix forms. Convention: use <code>unless</code> for simple negative guards; avoid <code>unless</code> with complex compound conditions, as double-negatives hurt readability. There is no <code>unlessif</code> — use <code>if</code>/<code>elsif</code> chains for multi-branch logic.</p>
<pre><code class="lang-perl">unless ($ENV{QUIET}) { p "verbose output" }
p "missing!" unless -e $path # postfix guard
die "no input" unless @ARGV
return unless defined $val # early return pattern
</code></pre>
</article>
<article class="doc-entry" id="doc-for">
<h3><a class="doc-anchor" href="#doc-for">#</a> <code>for</code></h3>
<p>Iterate over a list, binding each element to a loop variable (or <code>_</code> by default). <code>for</code> and <code>foreach</code> are interchangeable keywords. The loop variable is automatically localized and aliases the original element — modifications to <code>_</code> inside the loop mutate the list in-place. In stryke, <code>for</code> loops work with ranges, arrays, hash slices, and iterator results. For parallel iteration, see <code>pfor</code>; for pipeline-style processing, prefer <code>|> e</code> or <code>|> map</code>. C-style <code>for (INIT; COND; STEP)</code> is also supported.</p>
<pre><code class="lang-perl">for my $f (glob "*.txt") { p $f }
for (1:5) { p _ * 2 } # _ is default
my @names = qw(alice bob carol)
for (@names) { _ = uc _ } # mutates in-place
p join ", ", @names # ALICE, BOB, CAROL
</code></pre>
</article>
<article class="doc-entry" id="doc-while">
<h3><a class="doc-anchor" href="#doc-while">#</a> <code>while</code></h3>
<p>Loop that re-evaluates its condition before each iteration and continues as long as it is true. Commonly used for reading input line-by-line, polling, and indefinite iteration. The condition is tested in boolean context. <code>while</code> integrates naturally with the diamond operator <code><></code> for reading filehandles. The loop variable can be declared in the condition with <code>my</code>, scoping it to the loop body. Postfix form is also supported: <code>EXPR while COND;</code>.</p>
<pre><code class="lang-perl">while (my $line = <STDIN>) {
$line |> tm |> p # trim + print each line
}
my $i = 0
while ($i < 5) { p $i++ } # counted loop
while (1) { last if done() } # infinite loop with break
</code></pre>
</article>
<article class="doc-entry" id="doc-until">
<h3><a class="doc-anchor" href="#doc-until">#</a> <code>until</code></h3>
<p>Loop that continues as long as its condition is *false* — the logical inverse of <code>while</code>. Useful when the termination condition is more naturally expressed as a positive assertion ("keep going until X happens"). Supports both block and postfix forms. Prefer <code>while</code> with a negated condition if <code>until</code> makes the logic harder to read.</p>
<pre><code class="lang-perl">my $n = 1
until ($n > 1000) { $n *= 2 }
p $n # 1024
my $tries = 0
until (connected()) {
$tries++
sleep 1
}
p "connected after $tries tries"
</code></pre>
</article>
<article class="doc-entry" id="doc-do">
<h3><a class="doc-anchor" href="#doc-do">#</a> <code>do</code></h3>
<p>Execute a block and return its value, or execute a file. As a block, <code>do { ... }</code> creates an expression scope — the last expression in the block is the return value, making it useful for complex initializations. As a file operation, <code>do "file.pl"</code> executes the file in the current scope and returns its last expression. Unlike <code>require</code>, <code>do</code> does not cache and re-executes on each call. <code>do { ... } while (COND)</code> creates a loop that always runs at least once.</p>
<pre><code class="lang-perl">my $val = do { my $x = 10
$x ** 2 } # 100
p $val
my $cfg = do "config.pl" # load config
# do-while: body runs at least once
my $input
do { $input = readline(STDIN) |> tm } while ($input eq "")
</code></pre>
</article>
<article class="doc-entry" id="doc-last">
<h3><a class="doc-anchor" href="#doc-last">#</a> <code>last</code></h3>
<p>Immediately exit the innermost enclosing loop (equivalent to <code>break</code> in C/Rust). Execution continues after the loop. <code>last LABEL</code> can target a labeled outer loop to break out of nested loops. Works in <code>for</code>, <code>foreach</code>, <code>while</code>, <code>until</code>, and <code>do-while</code>. Does *not* work inside <code>map</code>, <code>grep</code>, or <code>|></code> pipeline stages — use <code>take</code>, <code>first</code>, or <code>take_while</code> for early termination in functional contexts.</p>
<pre><code class="lang-perl">for (1:1_000_000) {
last if _ > 5
p _
} # prints 1 2 3 4 5
OUTER: for my $i (1:10) {
for my $j (1:10) {
last OUTER if $i * $j > 50 # break both loops
}
}
</code></pre>
<p>For pipeline early-exit: <code>1:1000 |> take_while { _ < 50 } |> e p</code>.</p>
</article>
<article class="doc-entry" id="doc-next">
<h3><a class="doc-anchor" href="#doc-next">#</a> <code>next</code></h3>
<p>Skip the rest of the current loop iteration and jump to the next one. The loop condition (for <code>while</code>/<code>until</code>) or the next element (for <code>for</code>/<code>foreach</code>) is evaluated immediately. Like <code>last</code>, <code>next</code> supports labeled loops with <code>next LABEL</code> for skipping in nested loops. This is the primary tool for filtering within imperative loops. In stryke, consider <code>grep</code>/<code>filter</code> or <code>|> reject</code> for functional-style filtering instead.</p>
<pre><code class="lang-perl">for (1:10) {
next if _ % 2 # skip odds
p _
} # 2 4 6 8 10
for my $file (glob "*") {
next unless -f $file # skip non-files
next if $file =~ /^\./ # skip hidden
p $file
}
</code></pre>
</article>
<article class="doc-entry" id="doc-redo">
<h3><a class="doc-anchor" href="#doc-redo">#</a> <code>redo</code></h3>
<p>Restart the current loop iteration from the top of the loop body *without* re-evaluating the loop condition or advancing to the next element. The loop variable retains its current value. This is a niche but powerful tool for retry logic within loops — when an iteration fails, <code>redo</code> lets you try again with the same input. Use sparingly, as it can create infinite loops if the retry condition never resolves. Always pair with a guard or counter. For automated retry with backoff, prefer <code>retry { ... } times => N, backoff => 'exponential'</code>.</p>
<pre><code class="lang-perl">for my $url (@urls) {
my $body = eval { fetch($url) }
if ($@) {
warn "retry $url: $@"
sleep 1
redo # try same URL again
}
p length($body)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-continue">
<h3><a class="doc-anchor" href="#doc-continue">#</a> <code>continue</code></h3>
<p>A block attached to a <code>for</code>/<code>foreach</code>/<code>while</code> loop that executes after each iteration, even when <code>next</code> is called. Analogous to the increment expression in a C-style <code>for</code> loop. The <code>continue</code> block does *not* run when <code>last</code> or <code>redo</code> is used. Useful for unconditional per-iteration bookkeeping like incrementing counters, logging progress, or flushing buffers. Rarely used but fully supported in stryke.</p>
<pre><code class="lang-perl">my $count = 0
for my $item (@work) {
next if $item->{skip}
process($item)
} continue {
$count++
p "processed $count so far" if $count % 100 == 0
}
</code></pre>
</article>
<article class="doc-entry" id="doc-given">
<h3><a class="doc-anchor" href="#doc-given">#</a> <code>given</code></h3>
<p>A switch-like construct that evaluates an expression and dispatches to <code>when</code> blocks via smartmatch semantics. The topic variable <code>_</code> is set to the <code>given</code> expression for the duration of the block. Each <code>when</code> clause is tested in order; the first match executes its block and control passes out of the <code>given</code> (implicit break). A <code>default</code> block handles the no-match case. In stryke, prefer the <code>match</code> keyword for new code — it offers pattern destructuring, typed patterns, array/hash shape matching, and <code>if</code> guards that <code>given</code>/<code>when</code> cannot express.</p>
<pre><code class="lang-perl">given ($cmd) {
when ("start") { p "starting up" }
when ("stop") { p "shutting down" }
when (/^re/) { p "restarting" }
default { p "unknown: $cmd" }
}
</code></pre>
<p>See <code>match</code> for stryke-native pattern matching with destructuring.</p>
</article>
<article class="doc-entry" id="doc-when">
<h3><a class="doc-anchor" href="#doc-when">#</a> <code>when</code></h3>
<p>A case clause inside a <code>given</code> block. The expression is matched against the topic <code>_</code> using smartmatch semantics: strings match exactly, regexes match against <code>_</code>, arrayrefs check membership, coderefs are called with <code>_</code> as argument, and numbers compare numerically. When a <code>when</code> clause matches, its block executes and control exits the enclosing <code>given</code> (implicit break). Multiple <code>when</code> clauses are tried in order until one matches.</p>
<pre><code class="lang-perl">given ($val) {
when (/^\d+$/) { p "number" }
when (["a","b","c"]) { p "early letter" }
when (42) { p "the answer" }
default { p "something else" }
}
</code></pre>
<p>In stryke, the <code>match</code> keyword provides more powerful pattern matching.</p>
</article>
<article class="doc-entry" id="doc-default">
<h3><a class="doc-anchor" href="#doc-default">#</a> <code>default</code></h3>
<p>The fallback clause in a <code>given</code> block, executed when no <code>when</code> clause matched. Every <code>given</code> should have a <code>default</code> to handle unexpected values, similar to <code>else</code> in an <code>if</code> chain or the wildcard <code>_</code> arm in stryke <code>match</code>. If no <code>default</code> is present and nothing matches, execution simply continues after the <code>given</code> block. In stryke <code>match</code>, use <code>_ => ...</code> for the default arm instead.</p>
<pre><code class="lang-perl">given ($exit_code) {
when (0) { p "success" }
when (1) { p "general error" }
when (2) { p "misuse" }
default { p "unknown exit code: $exit_code" }
}
</code></pre>
</article>
<article class="doc-entry" id="doc-return">
<h3><a class="doc-anchor" href="#doc-return">#</a> <code>return</code></h3>
<p>Return a value from a subroutine.</p>
<pre><code class="lang-perl">fn pin_val($v, $lo, $hi) {
return $lo if $v < $lo
return $hi if $v > $hi
$v
}
</code></pre>
</article>
<article class="doc-entry" id="doc-not">
<h3><a class="doc-anchor" href="#doc-not">#</a> <code>not</code></h3>
<p>Low-precedence logical negation — returns true if the expression is false, and false if it is true. Functionally identical to <code>!</code> but binds looser than almost everything, so <code>not $a == $b</code> is <code>not($a == $b)</code> rather than <code>(!$a) == $b</code>. Useful for readable boolean conditions.</p>
<pre><code class="lang-perl">if (not defined $val) {
p "val is undef"
}
my @missing = grep { not -e _ } @files
@missing |> e p
p not 0 # 1
p not 1 # (empty string)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-error-handling">
<h2>Error Handling</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-try">
<h3><a class="doc-anchor" href="#doc-try">#</a> <code>try</code></h3>
<p>Structured exception handling that cleanly separates the happy path from error recovery. The <code>try</code> block runs the code; if it throws (via <code>die</code>), execution jumps to the <code>catch</code> block with the exception bound to the declared variable. An optional <code>finally</code> block runs unconditionally afterward — ideal for cleanup like closing filehandles or releasing locks. Unlike <code>eval</code>, <code>try</code>/<code>catch</code> is a first-class statement with proper scoping and no <code>$@</code> pollution. In stryke, <code>try</code> integrates with all exception types including string messages, hashrefs, and objects.</p>
<pre><code class="lang-perl">try {
my $data = fetch_json($url)
p $data->{name}
} catch ($e) {
warn "request failed: $e"
return fallback()
} finally {
log_info("fetch attempt complete")
}
</code></pre>
<p>Prefer <code>try</code>/<code>catch</code> over <code>eval { }</code> for new code — it reads better and avoids <code>$@</code> clobbering races.</p>
</article>
<article class="doc-entry" id="doc-catch">
<h3><a class="doc-anchor" href="#doc-catch">#</a> <code>catch</code></h3>
<p>The error-handling clause that follows a <code>try</code> block. When the <code>try</code> block throws an exception, execution transfers to <code>catch</code> with the exception value bound to the declared variable (e.g. <code>$e</code>). The catch variable is lexically scoped to the catch block. You can inspect the exception — it may be a string, a hashref with structured error info, or an object with methods. Multiple error types can be differentiated with <code>ref</code> or <code>match</code> inside the catch body. If the catch block itself throws, the exception propagates upward (the <code>finally</code> block still runs first, if present).</p>
<pre><code class="lang-perl">try { die { code => 404, msg => "not found" } }
catch ($e) {
if (ref $e eq 'HASH') {
p "error $e->{code}: $e->{msg}"
} else {
p "caught: $e"
}
}
</code></pre>
</article>
<article class="doc-entry" id="doc-finally">
<h3><a class="doc-anchor" href="#doc-finally">#</a> <code>finally</code></h3>
<p>A cleanup block that runs after <code>try</code>/<code>catch</code> regardless of whether an exception was thrown or not. This guarantees resource cleanup even if the <code>try</code> block throws or the <code>catch</code> block re-throws. The <code>finally</code> block cannot change the exception or the return value — it is strictly for side effects like closing filehandles, releasing locks, or logging. If <code>finally</code> itself throws, that exception replaces the original one (avoid throwing in finally). <code>finally</code> is optional — you can use <code>try</code>/<code>catch</code> without it.</p>
<pre><code class="lang-perl">my $fh
try {
open $fh, '<', $path or die $!
process(<$fh>)
} catch ($e) {
log_error("failed: $e")
} finally {
close $fh if $fh # always cleanup
}
</code></pre>
</article>
<article class="doc-entry" id="doc-eval">
<h3><a class="doc-anchor" href="#doc-eval">#</a> <code>eval</code></h3>
<p>The classic Perl exception-catching mechanism. <code>eval { BLOCK }</code> executes the block in an exception-trapping context: if the block throws (via <code>die</code>), execution continues after the <code>eval</code> with the error stored in <code>$@</code>. <code>eval "STRING"</code> compiles and executes Perl code at runtime — powerful but dangerous (code injection risk). In stryke, prefer <code>try</code>/<code>catch</code> for exception handling as it avoids the <code>$@</code> clobbering pitfalls and reads more clearly. <code>eval</code> remains useful for dynamic code evaluation and backward compatibility with Perl 5 idioms.</p>
<pre><code class="lang-perl">eval { die "oops" }
if ($@) { p "caught: $@" }
# Eval string — dynamic code execution
my $expr = "2 + 2"
my $result = eval $expr
p $result # 4
</code></pre>
<p>Caveat: <code>$@</code> can be clobbered by intervening <code>eval</code>s or destructors — <code>try</code>/<code>catch</code> avoids this.</p>
</article>
<article class="doc-entry" id="doc-die">
<h3><a class="doc-anchor" href="#doc-die">#</a> <code>die</code></h3>
<p>Raise an exception, immediately unwinding the call stack until caught by <code>try</code>/<code>catch</code> or <code>eval</code>. The argument can be a string (most common), a reference (hashref for structured errors), or an object. If uncaught, the program terminates and the message is printed to STDERR. In stryke, <code>die</code> works identically to Perl 5 and integrates with <code>try</code>/<code>catch</code>, <code>eval</code>, and the <code>$@</code> mechanism. Convention: end die messages with <code>\n</code> to suppress the automatic "at FILE line LINE" suffix, or omit it to get location info for debugging.</p>
<pre><code class="lang-perl">fn divide($a, $b) {
die "division by zero\n" unless $b
$a / $b
}
# Structured error
die { code => 400, msg => "bad request", field => "email" }
# With automatic location
die "something broke" # prints: something broke at script.pl line 5.
</code></pre>
</article>
<article class="doc-entry" id="doc-warn">
<h3><a class="doc-anchor" href="#doc-warn">#</a> <code>warn</code></h3>
<p>Print a warning message to STDERR without terminating the program. Behaves like <code>die</code> but only emits the message instead of throwing an exception. If the message does not end with <code>\n</code>, Perl appends the current file and line number. Warnings can be intercepted with <code>$SIG{__WARN__}</code> or suppressed with <code>no warnings</code>. In stryke, <code>warn</code> is useful for non-fatal diagnostics; for structured logging, use <code>log_warn</code> instead.</p>
<pre><code class="lang-perl">warn "file not found: $path" unless -e $path
warn "deprecated: use fetch_json instead\n" # no line number
# Intercept warnings
local $SIG{__WARN__} = fn ($msg) { log_warn($msg) }
warn "redirected to logger"
</code></pre>
</article>
<article class="doc-entry" id="doc-croak">
<h3><a class="doc-anchor" href="#doc-croak">#</a> <code>croak</code></h3>
<p>Die from the caller's perspective — the error message reports the file and line of the *caller*, not the function that called <code>croak</code>. This is the right choice for library/module functions where the error is the caller's fault (bad arguments, misuse). Without <code>croak</code>, the user sees an error pointing at library internals, which is unhelpful. In stryke, <code>croak</code> is available as a builtin without <code>use Carp</code>. For debugging deep call chains, use <code>confess</code> instead to get a full stack trace.</p>
<pre><code class="lang-perl">fn parse($s) {
croak "parse: empty input" unless length $s
croak "parse: not JSON" unless $s =~ /^[{\[]/
json_decode($s)
}
# Error will point at the call site, not inside parse()
my $data = parse("") # dies: "parse: empty input at caller.pl line 5"
</code></pre>
</article>
<article class="doc-entry" id="doc-confess">
<h3><a class="doc-anchor" href="#doc-confess">#</a> <code>confess</code></h3>
<p>Die with a full stack trace from the point of the error all the way up through every caller. This is invaluable for debugging deep call chains where <code>die</code> or <code>croak</code> only show one frame. Each frame includes the package, file, and line number. In stryke, <code>confess</code> is available as a builtin without <code>use Carp</code>. Use <code>confess</code> during development for maximum diagnostic info; switch to <code>croak</code> in production-facing libraries where the trace would confuse end users.</p>
<pre><code class="lang-perl">fn validate($data) {
confess "missing required field 'name'" unless $data->{name}
}
fn process($input) { validate($input) }
fn main { process({}) } # full trace: main -> process -> validate
</code></pre>
<p>The trace output shows: <code>missing required field 'name' at script.pl line 2.\n\tmain::validate called at line 4\n\t...</code>.</p>
</article>
</section>
<section class="tutorial-section" id="ch-aop-advice">
<h2>AOP / Advice</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-before">
<h3><a class="doc-anchor" href="#doc-before">#</a> <code>before</code></h3>
<p><code>before "<glob>" { ... }</code> — register advice that runs *before* every call to a sub whose name matches the glob pattern. Inside the body, <code>$INTERCEPT_NAME</code> holds the called sub's name and <code>@INTERCEPT_ARGS</code> holds the args.</p>
<p>The leading keyword only commits to advice parsing when followed by a string literal, so <code>before(...)</code> as a normal sub call still parses normally. Multiple <code>before</code> advices on the same name all fire in registration order. The advice cannot suppress the call (use <code>around</code> for that) and its return value is discarded.</p>
<pre><code class="lang-perl">before "fetch" { warn "calling fetch with @INTERCEPT_ARGS" }
before "log_*" { $log_count++ } # glob: any sub starting with log_
before "*" { trace($INTERCEPT_NAME) } # every sub call
</code></pre>
<p>Bodies are lowered to bytecode and dispatched through the VM (<code>run_block_region</code>), so <code>our $x</code> and other compile-time name resolutions work the same inside advice as outside it. The body's final statement must be an expression (same constraint as <code>map { }</code> block lowering); a literal <code>for</code>/<code>while</code>/<code>if</code> block or a literal <code>return</code> will be rejected at firing time.</p>
</article>
<article class="doc-entry" id="doc-after">
<h3><a class="doc-anchor" href="#doc-after">#</a> <code>after</code></h3>
<p><code>after "<glob>" { ... }</code> — register advice that runs *after* every call to a sub whose name matches the glob pattern. The body sees the call's return in <code>$INTERCEPT_RESULT</code>, the wall-clock duration in <code>$INTERCEPT_MS</code> (millis, float) and <code>$INTERCEPT_US</code> (micros, integer), the called name in <code>$INTERCEPT_NAME</code>, and the args in <code>@INTERCEPT_ARGS</code>.</p>
<p>Multiple <code>after</code> advices on the same name all fire in registration order. The advice's return value is discarded — the call's return is whatever the original sub (or a matching <code>around</code>) produced.</p>
<pre><code class="lang-perl">after "fetch" { warn "fetch returned $INTERCEPT_RESULT in ${INTERCEPT_MS}ms" }
after "*" { log_call($INTERCEPT_NAME, $INTERCEPT_US) }
</code></pre>
</article>
<article class="doc-entry" id="doc-around">
<h3><a class="doc-anchor" href="#doc-around">#</a> <code>around</code></h3>
<p><code>around "<glob>" { ... }</code> — register advice that *wraps* every call to a sub whose name matches the glob pattern. Use <code>proceed()</code> to invoke the original; the around block's evaluated value is the call's return (AspectJ-style).</p>
<p>The first matching <code>around</code> on a given name wraps; later <code>around</code> matches are skipped (mirrors zshrs <code>run_intercepts</code>). If <code>proceed()</code> is not called, the original sub never runs and the around block's value replaces it. The block can transform (<code>proceed() + 100</code>), forward (just <code>proceed()</code>), or replace (omit <code>proceed()</code> and emit a value).</p>
<pre><code class="lang-perl">around "expensive" {
my $cached = cache_get($INTERCEPT_ARGS[0])
return $cached if defined $cached
my $r = proceed()
cache_put($INTERCEPT_ARGS[0], $r)
$r
}
around "flaky" { my $r = eval { proceed() }; $@ ? retry_default() : $r }
</code></pre>
<p>Recursion guard: calling the advised sub from inside its own advice runs the original directly without re-firing advice — no infinite loop.</p>
</article>
<article class="doc-entry" id="doc-proceed">
<h3><a class="doc-anchor" href="#doc-proceed">#</a> <code>proceed</code></h3>
<p><code>proceed()</code> — invoke the original sub with the saved args from inside an <code>around</code> advice block. Returns the original's value. Calling <code>proceed</code> outside an <code>around</code> block is a runtime error.</p>
<p>The re-entrancy guard ensures <code>proceed</code> runs the original directly without re-firing any matching <code>around</code> advice for the same name, so transformation chains can't infinite-loop.</p>
<pre><code class="lang-perl">around "target" {
my $r = proceed()
$r * 2 # double whatever target returned
}
around "target" { proceed() // "default" } # forward, with fallback
</code></pre>
</article>
<article class="doc-entry" id="doc-intercept-list">
<h3><a class="doc-anchor" href="#doc-intercept-list">#</a> <code>intercept_list</code></h3>
<p><code>intercept_list()</code> — return the registered AOP advice as an array of <code>[id, kind, pattern]</code> triples (each element is an arrayref).</p>
<pre><code class="lang-perl">before "foo" { ... }
after "bar*" { ... }
for my $row (intercept_list()) {
my ($id, $kind, $pat) = @$row
p "id=$id kind=$kind pattern=$pat"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-intercept-remove">
<h3><a class="doc-anchor" href="#doc-intercept-remove">#</a> <code>intercept_remove</code></h3>
<p><code>intercept_remove($id)</code> — remove a single AOP advice by its id (from <code>intercept_list</code>). Returns the count removed (0 or 1).</p>
<pre><code class="lang-perl">before "foo" { ... }
my ($id, $kind, $pat) = @{ (intercept_list())[0] }
intercept_remove($id)
p scalar intercept_list() # 0
</code></pre>
</article>
<article class="doc-entry" id="doc-intercept-clear">
<h3><a class="doc-anchor" href="#doc-intercept-clear">#</a> <code>intercept_clear</code></h3>
<p><code>intercept_clear()</code> — drop all registered AOP advice. Returns the count cleared.</p>
<pre><code class="lang-perl">before "a" { ... }
after "b" { ... }
p intercept_clear() # 2
p scalar intercept_list() # 0
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-declarations">
<h2>Declarations</h2>
<p class="chapter-meta">10 topics</p>
<article class="doc-entry" id="doc-my">
<h3><a class="doc-anchor" href="#doc-my">#</a> <code>my</code></h3>
<p>Declare a lexically scoped variable visible only within the enclosing block or file. <code>my</code> is the workhorse of Perl variable declarations — use it for scalars (<code>$</code>), arrays (<code>@</code>), and hashes (<code>%</code>). Variables declared with <code>my</code> are invisible outside their scope, which prevents accidental cross-scope mutation. In stryke, <code>my</code> variables participate in pipe chains and can be destructured in list context. Uninitialized <code>my</code> variables default to <code>undef</code>.</p>
<pre><code class="lang-perl">my $name = "world"
my @nums = 1:5
my %cfg = (debug => 1, verbose => 0)
p "hello $name"
@nums |> grep _ > 2 |> e p$1
Use `my` everywhere unless you specifically need `our` (package global), `local` (dynamic scope), or `state` (persistent).
</code></pre>
</article>
<article class="doc-entry" id="doc-our">
<h3><a class="doc-anchor" href="#doc-our">#</a> <code>our</code></h3>
<p>Declare a package-global variable accessible as a lexical alias in the current scope. Unlike <code>my</code>, <code>our</code> variables are visible across the entire package and can be accessed from other packages via their fully qualified name (e.g. <code>$Counter::total</code>). Useful for package-level configuration, shared counters, or variables that need to survive across file boundaries.</p>
<p>In stryke, <code>our</code> variables are NOT mutex-protected. <strong>Mutating an <code>our</code> variable from inside <code>fan</code>/<code>pmap</code>/<code>pfor</code> is rejected at runtime</strong> with a directive to use <code>oursync</code> (the package-global counterpart of <code>mysync</code> — same <code>Arc<Mutex></code> backing, keyed by <code>Pkg::x</code>).</p>
<pre><code class="lang-perl">package Counter
our $total = 0 # serial use only
fn bump { $total++ }
package main
Counter::bump() for 1:5
p $Counter::total # 5
# For parallel mutation, use oursync:
package C
oursync $shared = 0
fn bump { $shared++ }
package main
fan 10000 { C::bump() } # always exactly 10000
</code></pre>
<p>Prefer <code>my</code> for local state; <code>our</code> for cross-package read-mostly globals; <code>oursync</code> for cross-package mutation under parallelism.</p>
</article>
<article class="doc-entry" id="doc-local">
<h3><a class="doc-anchor" href="#doc-local">#</a> <code>local</code></h3>
<p>Temporarily override a global variable's value for the duration of the current dynamic scope. When the scope exits, the original value is automatically restored. This is essential for modifying Perl's special variables (like <code>$/</code>, <code>$\</code>, <code>$,</code>) without permanently altering global state. Unlike <code>my</code> which creates a new variable, <code>local</code> saves and restores an existing global. In stryke, <code>local</code> works with all special variables and respects the same restoration semantics during exception unwinding.</p>
<pre><code class="lang-perl">local $/ = undef # slurp mode
open my $fh, '<', 'data.txt' or die $!
my $body = <$fh> # reads entire file
close $fh
# $/ restored to "\n" when scope exits
</code></pre>
<p>Common patterns: <code>local $/ = undef</code> (slurp), <code>local $, = ","</code> (join print args), <code>local %ENV</code> (temporary env).</p>
</article>
<article class="doc-entry" id="doc-state">
<h3><a class="doc-anchor" href="#doc-state">#</a> <code>state</code></h3>
<p>Declare a persistent lexical variable that retains its value across calls to the enclosing subroutine. Unlike <code>my</code>, which reinitializes on each call, <code>state</code> initializes only once — the first time execution reaches the declaration — and preserves the value for all subsequent calls. This is perfect for counters, caches, and memoization without resorting to globals or closures over external variables. In stryke, <code>state</code> variables are per-thread when used inside <code>~> { }</code> or <code>fan</code> blocks; they are not shared across workers.</p>
<pre><code class="lang-perl">fn ctr {
state $n = 0
++$n
}
p ctr() for 1:5 # 1 2 3 4 5
fn cache_lookup($x) {
state %cache
$cache{$x} //= expensive($x)
}
</code></pre>
<p>Requires <code>use feature 'state'</code> in standard Perl, but is always available in stryke.</p>
</article>
<article class="doc-entry" id="doc-package">
<h3><a class="doc-anchor" href="#doc-package">#</a> <code>package</code></h3>
<p>Set the current package namespace for all subsequent declarations. Package names are conventionally <code>CamelCase</code> with <code>::</code> separators (e.g. <code>Math::Utils</code>). All unqualified function and <code>our</code> variable names are installed into the current package. In stryke, packages work identically to standard Perl — they provide namespace isolation but are not classes by themselves (use <code>struct</code> or <code>bless</code> for OOP). Switching packages mid-file is allowed but discouraged; prefer one package per file.</p>
<pre><code class="lang-perl">package Math::Utils
fn calc_fact($n) { $n <= 1 ? 1 : $n * calc_fact($n - 1) }
fn calc_fib($n) { $n < 2 ? $n : calc_fib($n - 1) + calc_fib($n - 2) }
package main
p Math::Utils::calc_fact(10) # 3628800
</code></pre>
</article>
<article class="doc-entry" id="doc-use">
<h3><a class="doc-anchor" href="#doc-use">#</a> <code>use</code></h3>
<p>Load and import a user module at compile time: <code>use Module qw(func);</code>. Stryke list utilities (<code>sum</code>, <code>max</code>, <code>uniq</code>, <code>reduce</code>, …), error helpers (<code>croak</code>, <code>confess</code>, <code>carp</code>), and serialization (<code>json_encode</code>, <code>json_decode</code>, <code>ddump</code>) are all native bare-name builtins — no import needed.</p>
<pre><code class="lang-perl">use My::Project::Helpers qw(normalize_path canonicalize)
my @vals = 1:10
p sum(@vals) # 55
p max(@vals) # 10
p normalize_path("/tmp/../etc")
</code></pre>
</article>
<article class="doc-entry" id="doc-no">
<h3><a class="doc-anchor" href="#doc-no">#</a> <code>no</code></h3>
<p>Unimport a module or pragma: <code>no strict 'refs';</code>.</p>
<pre><code class="lang-perl">no warnings 'experimental'
given ($x) { when (1) { p "one" } }
</code></pre>
</article>
<article class="doc-entry" id="doc-require">
<h3><a class="doc-anchor" href="#doc-require">#</a> <code>require</code></h3>
<p>Load a user module at runtime: <code>require Module;</code>. JSON / YAML / TOML decoding is built in (<code>json_decode</code>, <code>yaml_decode</code>, <code>toml_decode</code>) — no module load needed.</p>
<pre><code class="lang-perl">require My::Plugin::Loader
my $loader = My::Plugin::Loader::init()
p $loader->status
# Built-in: no require needed
my $data = json_decode($text)
p $data->{name}
</code></pre>
</article>
<article class="doc-entry" id="doc-begin">
<h3><a class="doc-anchor" href="#doc-begin">#</a> <code>BEGIN</code></h3>
<p><code>BEGIN { }</code> — runs at compile time, before the rest of the program.</p>
<pre><code class="lang-perl">BEGIN { p "compiling..." }
p "running"
# output: compiling... then running
</code></pre>
</article>
<article class="doc-entry" id="doc-end">
<h3><a class="doc-anchor" href="#doc-end">#</a> <code>END</code></h3>
<p><code>END { }</code> — runs after the program finishes (or on exit).</p>
<pre><code class="lang-perl">END { p "cleanup done" }
p "main work"
# output: main work then cleanup done
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-cluster-distributed">
<h2>Cluster / Distributed</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-cluster">
<h3><a class="doc-anchor" href="#doc-cluster">#</a> <code>cluster</code></h3>
<p><code>cluster(["host1:N", "host2:M", ...])</code> — build an SSH-backed worker pool for distributing stryke workloads across multiple machines.</p>
<p>Each entry in the list is a hostname (or <code>user@host</code>) followed by a colon and the number of worker slots to allocate on that host. Under the hood, stryke opens persistent SSH multiplexed connections to each host, deploys lightweight <code>stryke --remote-worker</code> processes, and manages a work-stealing scheduler across the entire cluster. The cluster object is then passed to distributed primitives like <code>pmap_on</code> and <code>pflat_map_on</code>. Workers must have <code>stryke</code> installed and accessible on <code>$PATH</code>. If a host becomes unreachable mid-computation, its in-flight tasks are automatically re-queued to surviving hosts.</p>
<pre><code class="lang-perl">my $cl = cluster(["server1:8", "server2:4", "gpu-box:16"])
my @results = pmap_on $cl, { heavy_compute } @jobs
# Single-machine cluster for testing:
my $local = cluster(["localhost:4"])
</code></pre>
</article>
<article class="doc-entry" id="doc-pmap-on">
<h3><a class="doc-anchor" href="#doc-pmap-on">#</a> <code>pmap_on</code></h3>
<p><code>pmap_on $cluster, { BLOCK } @list</code> — distributed parallel map that fans work across a <code>cluster</code> of remote machines.</p>
<p>Elements from <code>@list</code> are serialized, shipped to remote <code>stryke --remote-worker</code> processes over SSH, executed in parallel across every worker slot in the cluster, and the results are gathered back in input order. This is the distributed equivalent of <code>pmap</code>: same interface, same order guarantee, but the thread pool spans multiple hosts instead of local cores. Use this when a single machine's CPU count is the bottleneck. The block must be self-contained — it cannot close over local file handles or database connections, since it executes in a separate process on a remote host. Large closures are serialized once and cached on each worker for the lifetime of the cluster.</p>
<pre><code class="lang-perl">my $cl = cluster(["host1:8", "host2:8"])
my @hashes = pmap_on $cl, { sha256(slurp) } @file_paths
my @results = pmap_on $cl, { fetch("https://api.example.com/$_") } 1:10_000
</code></pre>
</article>
<article class="doc-entry" id="doc-pflat-map-on">
<h3><a class="doc-anchor" href="#doc-pflat-map-on">#</a> <code>pflat_map_on</code></h3>
<p>Distributed parallel flat-map over <code>cluster</code>.</p>
</article>
<article class="doc-entry" id="doc-ssh">
<h3><a class="doc-anchor" href="#doc-ssh">#</a> <code>ssh</code></h3>
<p><code>ssh($host, $command)</code> — execute a shell command on a remote host via SSH and return its stdout as a string.</p>
<p>This is a simple synchronous wrapper around an SSH invocation. The command is run in the remote user's default shell, and stdout is captured and returned. If the remote command exits non-zero, stryke dies with the stderr output. For bulk remote work, prefer <code>cluster</code> + <code>pmap_on</code> which manages connection pooling and parallelism automatically. <code>ssh</code> is best for one-off administrative commands, health checks, or bootstrapping a remote environment before building a cluster.</p>
<pre><code class="lang-perl">my $uptime = ssh("server1", "uptime")
p ssh("deploy@prod", "cat /etc/hostname")
my $free = ssh("gpu-box", "nvidia-smi --query-gpu=memory.free --format=csv,noheader")
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-datetime">
<h2>Datetime</h2>
<p class="chapter-meta">15 topics</p>
<article class="doc-entry" id="doc-datetime-utc">
<h3><a class="doc-anchor" href="#doc-datetime-utc">#</a> <code>datetime_utc</code></h3>
<p>Return the current UTC date and time as an ISO 8601 string (e.g. <code>2026-04-15T12:30:00Z</code>). This is the simplest way to get a portable, unambiguous timestamp for logging, file naming, or serialization. The returned string always ends with <code>Z</code> indicating UTC, so there is no timezone ambiguity.</p>
<pre><code class="lang-perl">my $now = datetime_utc()
p $now # 2026-04-15T12:30:00Z
af("audit.log", "$now: started\n")
my %event = (ts => datetime_utc(), action => "deploy")
wj("event.json", \%event)
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-from-epoch">
<h3><a class="doc-anchor" href="#doc-datetime-from-epoch">#</a> <code>datetime_from_epoch</code></h3>
<p>Convert a Unix epoch timestamp (seconds since 1970-01-01 00:00:00 UTC) into an ISO 8601 datetime string. This is useful when you have raw epoch values from <code>time()</code>, file modification times, or external APIs and need a human-readable representation. Fractional seconds are truncated.</p>
<pre><code class="lang-perl">my $ts = 1700000000
p datetime_from_epoch($ts) # 2023-11-14T22:13:20Z
my $born = datetime_from_epoch(0)
p $born # 1970-01-01T00:00:00Z
my @epochs = (1e9, 1.5e9, 2e9)
@epochs |> e { p datetime_from_epoch }
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-strftime">
<h3><a class="doc-anchor" href="#doc-datetime-strftime">#</a> <code>datetime_strftime</code></h3>
<p>Format an epoch timestamp using a <code>strftime</code>-style format string, giving full control over the output representation. The first argument is the format pattern and the second is the epoch value. Supports all standard specifiers: <code>%Y</code> (4-digit year), <code>%m</code> (month), <code>%d</code> (day), <code>%H</code> (hour), <code>%M</code> (minute), <code>%S</code> (second), <code>%A</code> (weekday name), and more.</p>
<pre><code class="lang-perl">my $t = time()
p datetime_strftime("%Y-%m-%d", $t) # 2026-04-15
p datetime_strftime("%H:%M:%S", $t) # 14:23:07
p datetime_strftime("%A, %B %d", $t) # Wednesday, April 15
my $log_ts = datetime_strftime("%Y%m%d_%H%M%S", $t)
to_file("backup_$log_ts.sql", $data)
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-now-tz">
<h3><a class="doc-anchor" href="#doc-datetime-now-tz">#</a> <code>datetime_now_tz</code></h3>
<p>Return the current date and time in a specified IANA timezone as a formatted string. Pass a timezone name like <code>America/New_York</code>, <code>Europe/London</code>, or <code>Asia/Tokyo</code>. This avoids manual UTC-offset arithmetic and handles daylight saving transitions correctly. Dies if the timezone name is not recognized.</p>
<pre><code class="lang-perl">p datetime_now_tz("America/New_York") # 2026-04-15 08:30:00 EDT
p datetime_now_tz("Asia/Tokyo") # 2026-04-15 21:30:00 JST
p datetime_now_tz("UTC") # same as datetime_utc
my @offices = ("US/Pacific", "Europe/Berlin", "Asia/Kolkata")
@offices |> e { p "$_: " . datetime_now_tz }
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-format-tz">
<h3><a class="doc-anchor" href="#doc-datetime-format-tz">#</a> <code>datetime_format_tz</code></h3>
<p>Format an epoch timestamp in a specific IANA timezone, combining the capabilities of <code>datetime_strftime</code> and <code>datetime_now_tz</code>. This lets you render a historical or future timestamp as it would appear on the wall clock in any timezone. Handles DST transitions automatically.</p>
<pre><code class="lang-perl">my $epoch = 1700000000
p datetime_format_tz($epoch, "America/Chicago")
# 2023-11-14 16:13:20 CST
p datetime_format_tz($epoch, "Europe/London")
# 2023-11-14 22:13:20 GMT
p datetime_format_tz(time(), "Australia/Sydney")
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-parse-local">
<h3><a class="doc-anchor" href="#doc-datetime-parse-local">#</a> <code>datetime_parse_local</code></h3>
<p>Parse a local datetime string (without timezone info) into a Unix epoch timestamp, interpreting it in the system's local timezone. Accepts common formats like <code>2026-04-15 14:30:00</code> or <code>2026-04-15T14:30:00</code>. Dies if the string cannot be parsed. This is the inverse of formatting with <code>localtime</code>.</p>
<pre><code class="lang-perl">my $epoch = datetime_parse_local("2026-04-15 14:30:00")
p $epoch # Unix timestamp
p datetime_from_epoch($epoch) # back to ISO 8601
my $midnight = datetime_parse_local("2026-01-01 00:00:00")
p time() - $midnight # seconds since New Year
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-parse-rfc3339">
<h3><a class="doc-anchor" href="#doc-datetime-parse-rfc3339">#</a> <code>datetime_parse_rfc3339</code></h3>
<p>Parse an RFC 3339 / ISO 8601 datetime string (with timezone offset or <code>Z</code> suffix) into a Unix epoch timestamp. This is the standard format used by JSON APIs, RSS feeds, and git timestamps. Accepts strings like <code>2026-04-15T14:30:00Z</code> or <code>2026-04-15T14:30:00+05:30</code>. Dies on malformed input.</p>
<pre><code class="lang-perl">my $epoch = datetime_parse_rfc3339("2026-04-15T12:00:00Z")
p $epoch
my $with_tz = datetime_parse_rfc3339("2026-04-15T08:00:00-04:00")
p $epoch == $with_tz # 1 (same instant)
# parse API response timestamps
my $created = $response->{created_at}
my $age = time() - datetime_parse_rfc3339($created)
p "created ${age}s ago"
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-add-seconds">
<h3><a class="doc-anchor" href="#doc-datetime-add-seconds">#</a> <code>datetime_add_seconds</code></h3>
<p>Add (or subtract) a number of seconds to an ISO 8601 datetime string and return the resulting ISO 8601 string. This performs calendar-aware arithmetic, correctly crossing day, month, and year boundaries. Pass a negative number to subtract time. Useful for computing deadlines, expiration times, or time windows.</p>
<pre><code class="lang-perl">my $now = datetime_utc()
my $later = datetime_add_seconds($now, 3600) # +1 hour
p $later
my $yesterday = datetime_add_seconds($now, -86400) # -1 day
p $yesterday
my $deadline = datetime_add_seconds($now, 7 * 86400) # +1 week
p "due by $deadline"
</code></pre>
</article>
<article class="doc-entry" id="doc-elapsed">
<h3><a class="doc-anchor" href="#doc-elapsed">#</a> <code>elapsed</code></h3>
<p>Return the number of seconds elapsed since the stryke process started, using a monotonic clock that is immune to system clock adjustments. The short alias <code>el</code> keeps benchmarking one-liners terse. Returns a floating-point value with sub-millisecond precision. Useful for timing operations, profiling hot loops, or adding relative timestamps to log output.</p>
<pre><code class="lang-perl">my $t0 = el()
my @sorted = sort @big_array
my $dur = el() - $t0
p "sort took ${dur}s"
# progress logging
1:100 |> e { do_work
log_info("step $_ at " . el() . "s") }
</code></pre>
</article>
<article class="doc-entry" id="doc-time">
<h3><a class="doc-anchor" href="#doc-time">#</a> <code>time</code></h3>
<p>Return the current Unix epoch as an integer — the number of seconds since 1970-01-01 00:00:00 UTC. This is the standard wall-clock timestamp used for file times, database records, and interop with external systems. For monotonic timing of code sections, prefer <code>elapsed</code>/<code>el</code> instead since <code>time</code> can jump if the system clock is adjusted.</p>
<pre><code class="lang-perl">my $start = time()
sleep(2)
p time() - $start # ~2
my $ts = time()
wj("stamp.json", { created => $ts })
p datetime_from_epoch($ts) # human-readable form
</code></pre>
</article>
<article class="doc-entry" id="doc-times">
<h3><a class="doc-anchor" href="#doc-times">#</a> <code>times</code></h3>
<p>Return the accumulated CPU times for the process as a four-element list: <code>($user, $system, $child_user, $child_system)</code>. User time is CPU spent executing your code; system time is CPU spent in kernel calls on your behalf. Child times cover subprocesses. Values are in seconds (floating point). Useful for profiling whether a script is CPU-bound or I/O-bound.</p>
<pre><code class="lang-perl">my ($u, $s, $cu, $cs) = times()
p "user=${u}s sys=${s}s"
# after heavy computation
my ($u2, $s2) = times()
p "used " . ($u2 - $u) . "s of CPU"
p "total CPU: " . ($u2 + $s2) . "s"
</code></pre>
</article>
<article class="doc-entry" id="doc-localtime">
<h3><a class="doc-anchor" href="#doc-localtime">#</a> <code>localtime</code></h3>
<p>Convert a Unix epoch timestamp to a nine-element list of broken-down local time components: <code>($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst)</code>. Follows the Perl convention where <code>$mon</code> is 0-based (January=0) and <code>$year</code> is years since 1900. When called without arguments, uses the current time. Use <code>gmtime</code> for the UTC equivalent.</p>
<pre><code class="lang-perl">my @t = localtime(time())
p "$t[2]:$t[1]:$t[0]" # HH:MM:SS
my $year = $t[5] + 1900
my $mon = $t[4] + 1
p "$year-$mon-$t[3]" # YYYY-M-D
my @days = qw(Sun Mon Tue Wed Thu Fri Sat)
p $days[$t[6]] # day of week
</code></pre>
</article>
<article class="doc-entry" id="doc-gmtime">
<h3><a class="doc-anchor" href="#doc-gmtime">#</a> <code>gmtime</code></h3>
<p>Convert a Unix epoch timestamp to a nine-element list of broken-down UTC time components, identical in structure to <code>localtime</code> but always in the UTC timezone. The fields are <code>($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst)</code> where <code>$isdst</code> is always 0. When called without arguments, uses the current time.</p>
<pre><code class="lang-perl">my @utc = gmtime(time())
my $year = $utc[5] + 1900
my $mon = $utc[4] + 1
p sprintf("%04d-%02d-%02dT%02d:%02d:%02dZ",
$year, $mon, @utc[3,2,1,0])
# compare local vs UTC
my @loc = localtime(time())
p "UTC hour=$utc[2] local hour=$loc[2]"
</code></pre>
</article>
<article class="doc-entry" id="doc-sleep">
<h3><a class="doc-anchor" href="#doc-sleep">#</a> <code>sleep</code></h3>
<p>Pause execution for the specified number of seconds. Accepts both integer and fractional values for sub-second sleeps (e.g. <code>sleep 0.1</code> for 100ms). The process yields the CPU during the sleep, so it is safe to use in polling loops without burning cycles. Returns the unslept time (always 0 unless interrupted by a signal).</p>
<pre><code class="lang-perl">p "waiting..."
sleep(2)
p "done"
# polling loop
while (!-e "done.flag") {
sleep(0.5)
}
# rate limiting
my @urls = @targets
@urls |> e { fetch
sleep(0.1) }
</code></pre>
</article>
<article class="doc-entry" id="doc-alarm">
<h3><a class="doc-anchor" href="#doc-alarm">#</a> <code>alarm</code></h3>
<p>Schedule a <code>SIGALRM</code> signal to be delivered to the process after the specified number of seconds. Calling <code>alarm(0)</code> cancels any pending alarm. Only one alarm can be active at a time — setting a new alarm replaces the previous one. Returns the number of seconds remaining on the previous alarm (or 0 if none was set). Combine with <code>eval</code> and <code>$SIG{ALRM}</code> to implement timeouts around potentially hanging operations.</p>
<pre><code class="lang-perl">eval {
local $SIG{ALRM} = fn { die "timeout\n" }
alarm(5) # 5 second deadline
my $data = slow_network_call()
alarm(0) # cancel on success
}
if ($@ =~ /timeout/) {
log_error("operation timed out")
}
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-math">
<h2>Math</h2>
<p class="chapter-meta">13 topics</p>
<article class="doc-entry" id="doc-abs">
<h3><a class="doc-anchor" href="#doc-abs">#</a> <code>abs</code></h3>
<p>Return the absolute value of a number, stripping any negative sign. Returns the argument unchanged if it is already non-negative. Works on both integers and floating-point numbers.</p>
<pre><code class="lang-perl">p abs(-42) # 42
p abs(3.14) # 3.14
my $diff = abs($a - $b)
p "distance: $diff"
1:5 |> map { _ - 3 } |> map abs |> e p # 2 1 0 1 2
</code></pre>
</article>
<article class="doc-entry" id="doc-int">
<h3><a class="doc-anchor" href="#doc-int">#</a> <code>int</code></h3>
<p>Truncate a floating-point number toward zero, discarding the fractional part. This is not rounding — <code>int(1.9)</code> is <code>1</code> and <code>int(-1.9)</code> is <code>-1</code>. Use <code>sprintf("%.0f", $n)</code> or <code>POSIX::round</code> for proper rounding. Commonly paired with <code>rand</code> to generate random integers.</p>
<pre><code class="lang-perl">p int(3.7) # 3
p int(-3.7) # -3
p int(rand(6)) + 1 # dice roll 1:6
1:10 |> map { _ / 3 } |> map int |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-sqrt">
<h3><a class="doc-anchor" href="#doc-sqrt">#</a> <code>sqrt</code></h3>
<p>Return the square root of a non-negative number. Dies if the argument is negative — use <code>abs</code> first or check the sign. For the inverse operation, use <code>squared</code>/<code>sq</code> or the <code>**</code> operator.</p>
<pre><code class="lang-perl">p sqrt(144) # 12
p sqrt(2) # 1.41421356...
my $hyp = sqrt($a**2 + $b**2) # Pythagorean theorem
1:5 |> map sqrt |> e { p sprintf("%.3f", _) }
</code></pre>
</article>
<article class="doc-entry" id="doc-squared">
<h3><a class="doc-anchor" href="#doc-squared">#</a> <code>squared</code></h3>
<p>Return the square of a number (<code>N * N</code>). This is a stryke convenience function — clearer than writing <code>$n ** 2</code> or <code>$n * $n</code> in pipelines. The aliases <code>sq</code> and <code>square</code> are interchangeable.</p>
<pre><code class="lang-perl">p squared(5) # 25
p sq(12) # 144
1:5 |> map sq |> e p # 1 4 9 16 25
my $hyp = sqrt(sq($a) + sq($b)) # Pythagorean theorem
</code></pre>
</article>
<article class="doc-entry" id="doc-cubed">
<h3><a class="doc-anchor" href="#doc-cubed">#</a> <code>cubed</code></h3>
<p>Return the cube of a number (<code>N * N * N</code>). This is a stryke convenience function for the common <code>$n ** 3</code> operation, useful in math-heavy pipelines. The aliases <code>cb</code> and <code>cube</code> are interchangeable.</p>
<pre><code class="lang-perl">p cubed(3) # 27
p cb(10) # 1000
1:4 |> map cb |> e p # 1 8 27 64
my $vol = cb($side) # volume of a cube
</code></pre>
</article>
<article class="doc-entry" id="doc-expt">
<h3><a class="doc-anchor" href="#doc-expt">#</a> <code>expt</code></h3>
<p>Raise a base to an arbitrary exponent and return the result. This is the function form of the <code>**</code> operator. Accepts integer and floating-point exponents, including negative values for reciprocals and fractional values for roots.</p>
<pre><code class="lang-perl">p expt(2, 10) # 1024
p expt(27, 1/3) # 3.0 (cube root)
p expt(10, -2) # 0.01
1:8 |> map { expt(2, _) } |> e p # 2 4 8 16 32 64 128 256
</code></pre>
</article>
<article class="doc-entry" id="doc-exp">
<h3><a class="doc-anchor" href="#doc-exp">#</a> <code>exp</code></h3>
<p>Return Euler's number *e* raised to the given power. <code>exp(0)</code> is <code>1</code>, <code>exp(1)</code> is approximately <code>2.71828</code>. This is the inverse of <code>log</code>. Useful for exponential growth/decay calculations, probability distributions, and converting between logarithmic and linear scales.</p>
<pre><code class="lang-perl">p exp(1) # 2.71828182845905
p exp(0) # 1
my $growth = $initial * exp($rate * $time)
1:5 |> map exp |> e { p sprintf("%.4f", _) }
</code></pre>
</article>
<article class="doc-entry" id="doc-log">
<h3><a class="doc-anchor" href="#doc-log">#</a> <code>log</code></h3>
<p>Return the natural (base-*e*) logarithm of a positive number. Dies if the argument is zero or negative. For base-10 logarithms, divide by <code>log(10)</code>. For base-2, divide by <code>log(2)</code>. This is the inverse of <code>exp</code>.</p>
<pre><code class="lang-perl">p log(exp(1)) # 1.0
p log(100) / log(10) # 2.0 (log base 10)
my $bits = log($n) / log(2) # log base 2
1:5 |> map log |> e { p sprintf("%.3f", _) }
</code></pre>
</article>
<article class="doc-entry" id="doc-sin">
<h3><a class="doc-anchor" href="#doc-sin">#</a> <code>sin</code></h3>
<p>Return the sine of an angle given in radians. The result ranges from <code>-1</code> to <code>1</code>. For degrees, convert first: <code>sin($deg * 3.14159265 / 180)</code>. Use <code>atan2</code> to go in the reverse direction.</p>
<pre><code class="lang-perl">p sin(0) # 0
p sin(3.14159265 / 2) # 1.0
my @wave = map { sin(_ * 0.1) } 0:62
@wave |> e { p sprintf("%6.3f", _) }
</code></pre>
</article>
<article class="doc-entry" id="doc-cos">
<h3><a class="doc-anchor" href="#doc-cos">#</a> <code>cos</code></h3>
<p>Return the cosine of an angle given in radians. The result ranges from <code>-1</code> to <code>1</code>. <code>cos(0)</code> is <code>1</code>. Like <code>sin</code>, convert degrees to radians before calling.</p>
<pre><code class="lang-perl">p cos(0) # 1
p cos(3.14159265) # -1.0
my $x = $radius * cos($theta)
my $y = $radius * sin($theta)
p "($x, $y)"
</code></pre>
</article>
<article class="doc-entry" id="doc-atan2">
<h3><a class="doc-anchor" href="#doc-atan2">#</a> <code>atan2</code></h3>
<p>Return the arctangent of <code>Y/X</code> in radians, using the signs of both arguments to determine the correct quadrant. The result ranges from <code>-pi</code> to <code>pi</code>. This is the standard way to compute angles from Cartesian coordinates and is more robust than <code>atan(Y/X)</code> because it handles <code>X=0</code> correctly.</p>
<pre><code class="lang-perl">my $pi = atan2(0, -1) # 3.14159265...
p atan2(1, 1) # 0.785... (pi/4)
my $angle = atan2($dy, $dx)
p sprintf("%.1f degrees", $angle * 180 / $pi)
</code></pre>
</article>
<article class="doc-entry" id="doc-rand">
<h3><a class="doc-anchor" href="#doc-rand">#</a> <code>rand</code></h3>
<p>Return a pseudo-random floating-point number in the range <code>[0, N)</code>. If N is omitted it defaults to <code>1</code>. The result is never exactly equal to N. For integer results, combine with <code>int</code>. Seed the generator with <code>srand</code> for reproducible sequences.</p>
<pre><code class="lang-perl">p rand() # e.g. 0.7342...
p int(rand(100)) # random int 0:99
my @deck = 1:52
my @shuffled = sort { rand() <=> rand() } @deck # poor shuffle
my $coin = rand() < 0.5 ? "heads" : "tails"
p $coin
</code></pre>
</article>
<article class="doc-entry" id="doc-srand">
<h3><a class="doc-anchor" href="#doc-srand">#</a> <code>srand</code></h3>
<p>Seed the pseudo-random number generator used by <code>rand</code>. Calling <code>srand</code> with a specific value produces a reproducible sequence, which is useful for testing. Without arguments, Perl seeds from a platform-specific entropy source. You rarely need to call this explicitly — Perl auto-seeds on first use of <code>rand</code>.</p>
<pre><code class="lang-perl">srand(42) # reproducible sequence
p int(rand(100)) # always the same value
srand(42)
p int(rand(100)) # same value again
srand() # re-seed from entropy
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-file-system">
<h2>File System</h2>
<p class="chapter-meta">34 topics</p>
<article class="doc-entry" id="doc-basename">
<h3><a class="doc-anchor" href="#doc-basename">#</a> <code>basename</code></h3>
<p>Extract the filename component from a path, stripping all leading directory segments. The short alias <code>bn</code> keeps one-liner pipelines terse. If an optional suffix argument is provided, that suffix is also stripped from the result, which is handy for removing extensions.</p>
<pre><code class="lang-perl">p basename("/usr/local/bin/stryke") # stryke
p bn("/tmp/data.csv", ".csv") # data
"/etc/nginx/nginx.conf" |> bn |> p # nginx.conf
</code></pre>
</article>
<article class="doc-entry" id="doc-dirname">
<h3><a class="doc-anchor" href="#doc-dirname">#</a> <code>dirname</code></h3>
<p>Return the directory portion of a path, stripping the final filename component. The short alias <code>dn</code> mirrors <code>bn</code>. This is a pure string operation — it does not touch the filesystem, so it works on paths that do not exist yet. Useful for deriving output directories from input file paths.</p>
<pre><code class="lang-perl">p dirname("/usr/local/bin/stryke") # /usr/local/bin
p dn("/tmp/data.csv") # /tmp
my $dir = dn($0) # directory of current script
</code></pre>
</article>
<article class="doc-entry" id="doc-fileparse">
<h3><a class="doc-anchor" href="#doc-fileparse">#</a> <code>fileparse</code></h3>
<p>Split a path into its three logical components: the filename, the directory prefix, and a suffix that matches one of the supplied patterns. This mirrors Perl's <code>File::Basename::fileparse</code> and is the most flexible path decomposition available. When no suffix patterns are given the suffix is empty.</p>
<pre><code class="lang-perl">my ($name, $dir, $sfx) = fileparse("/home/user/report.txt", qr/\.txt/)
p "$dir | $name | $sfx" # /home/user/ | report | .txt
my ($n, $d) = fileparse("./lib/Foo/Bar.pm")
p "$d$n" # ./lib/Foo/Bar.pm
</code></pre>
</article>
<article class="doc-entry" id="doc-realpath">
<h3><a class="doc-anchor" href="#doc-realpath">#</a> <code>realpath</code></h3>
<p>Resolve a path to its absolute canonical form by following all symbolic links and eliminating <code>.</code> and <code>..</code> segments. Unlike <code>canonpath</code>, this hits the filesystem and will die if any component does not exist. The short alias <code>rp</code> is convenient in pipelines. Use this when you need a guaranteed unique path for deduplication or comparison.</p>
<pre><code class="lang-perl">p realpath(".") # /home/user/project
p rp("../sibling") # /home/user/sibling
my $canon = rp($0) # absolute path of current script
"." |> rp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-canonpath">
<h3><a class="doc-anchor" href="#doc-canonpath">#</a> <code>canonpath</code></h3>
<p>Clean up a file path by collapsing redundant separators, resolving <code>.</code> and <code>..</code> segments, and normalizing trailing slashes — all without touching the filesystem. Unlike <code>realpath</code>, this is a purely lexical operation so it works on paths that do not exist. Use it to normalize user-supplied paths before comparison or storage.</p>
<pre><code class="lang-perl">p canonpath("/usr/./local/../local/bin/") # /usr/local/bin
p canonpath("a/b/../c") # a/c
my $clean = canonpath($ENV{HOME} . "/./docs/../docs")
p $clean
</code></pre>
</article>
<article class="doc-entry" id="doc-getcwd">
<h3><a class="doc-anchor" href="#doc-getcwd">#</a> <code>getcwd</code></h3>
<p>Return the current working directory as an absolute path string. This calls the underlying OS <code>getcwd</code> function, so it always reflects the real directory even if the process changed directories via <code>chdir</code>. The alias <code>pwd</code> matches the familiar shell command. Often used to save and restore directory context around <code>chdir</code> calls.</p>
<pre><code class="lang-perl">my $orig = pwd()
chdir("/tmp")
p pwd() # /tmp
chdir($orig)
p getcwd() # back to original
</code></pre>
</article>
<article class="doc-entry" id="doc-which">
<h3><a class="doc-anchor" href="#doc-which">#</a> <code>which</code></h3>
<p>Search the <code>PATH</code> environment variable for the first executable matching the given command name and return its absolute path, or <code>undef</code> if not found. This is the programmatic equivalent of the shell <code>which</code> command. Useful for checking tool availability before calling <code>system</code> or <code>exec</code>.</p>
<pre><code class="lang-perl">my $gcc = which("gcc") // die "gcc not found"
p $gcc # /usr/bin/gcc
if (which("rg")) {
system("rg pattern file")
} else {
system("grep pattern file")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-glob">
<h3><a class="doc-anchor" href="#doc-glob">#</a> <code>glob</code></h3>
<p>Expand a zsh-style glob pattern against the filesystem and return a list of matching paths. World-first: stryke supports <strong>every</strong> zsh glob qualifier from <code>man zshexpn</code> _Filename Generation > Glob Qualifiers_ (no other scripting language does this). Backed by <code>zsh::glob</code> from zshrs — single source of truth, zero stryke-side reimplementation. Patterns: <code>*</code>, <code>?</code>, <code>[abc]</code>, <code>{a,b}</code>, <code>**</code> recursive, plus the <code>(...)</code> qualifier suffix.</p>
<h4>Qualifier reference (full set)</h4>
<p><strong>File type:</strong> <code>(/)</code> dir · <code>(.)</code> regular file · <code>(@)</code> symlink · <code>(=)</code> socket · <code>(p)</code> FIFO · <code>(%b)</code> block dev · <code>(%c)</code> char dev · <code>(%)</code> any device · <code>(*)</code> executable file.</p>
<p><strong>Permission:</strong> <code>(r)</code> <code>(w)</code> <code>(x)</code> EUID r/w/x · <code>(R)</code> <code>(W)</code> <code>(X)</code> world · <code>(A)</code> <code>(I)</code> <code>(E)</code> group · <code>(s)</code> setuid · <code>(S)</code> setgid · <code>(t)</code> sticky · <code>(f<bits>)</code> exact mode-bit match (e.g. <code>(f644)</code>).</p>
<p><strong>Ownership / device:</strong> <code>(U)</code> owned by EUID · <code>(G)</code> owned by EGID · <code>(u<N>)</code> uid N · <code>(g<N>)</code> gid N · <code>(d<N>)</code> match by device number.</p>
<p><strong>Numeric</strong> (each accepts <code>+N</code> greater, <code>-N</code> less, <code>N</code> equal): <code>(L[unit]±N)</code> size — <code>p</code>/<code>k</code>/<code>m</code>/<code>g</code>/<code>t</code> units, default bytes · <code>(l±N)</code> link count · <code>(a[unit]±N)</code> atime · <code>(m[unit]±N)</code> mtime · <code>(c[unit]±N)</code> ctime — time units <code>s</code>/<code>m</code>/<code>h</code>/<code>d</code>/<code>w</code>/<code>M</code>.</p>
<p><strong>Sort:</strong> <code>(on)</code> <code>(oL)</code> <code>(ol)</code> <code>(oa)</code> <code>(om)</code> <code>(oc)</code> <code>(od)</code> ascending; capital <code>O*</code> descending; <code>(oN)</code> no sort.</p>
<p><strong>Selection:</strong> <code>([N])</code> Nth match · <code>([N,M])</code> slice. Combine with sort: <code>(om[1])</code> newest single match.</p>
<p><strong>Flags:</strong> <code>(N)</code> NULL_GLOB — empty list on no match · <code>(D)</code> include dotfiles · <code>(F)</code> non-empty directory · <code>(M)</code> mark-dirs (append <code>/</code>) · <code>(T)</code> list-types (append type char) · <code>(n)</code> numeric sort.</p>
<p><strong>Eval / functions:</strong> <code>(e'CMD')</code> shell-eval predicate · <code>(+func)</code> function-as-test (predicate sub).</p>
<p><strong>Join words:</strong> <code>(P…)</code> prefix words · <code>(Q…)</code> postfix words around each match.</p>
<p><strong>Colon modifiers:</strong> <code>(:s/PAT/REPL/)</code> sed substitution on each path · <code>(:e)</code> extension · <code>(:r)</code> strip extension · <code>(:t)</code> tail · <code>(:h)</code> head · all of zsh's history-style modifiers.</p>
<p><strong>Combinators:</strong> prefix <code>^</code> negates · prefix <code>-</code> toggles symlink-following · <code>,</code> separates OR alternatives · chained qualifiers AND.</p>
<pre><code class="lang-perl">my @scripts = glob("*.pl")
my @all_rs = glob("src/**/*.rs")
my @dirs = glob("**(/)") # directories only, recursive
my @big = glob("**(L+1024)") # files larger than 1024 bytes
my @recent = glob("**(om[1])") # most recently modified, take 1
my @safe = glob("missing*(N)") # null-glob, never errors
my @mode = glob("**(f644)") # files with exactly mode 644
my @stems = glob("*.txt(:r)") # all .txt files, extension stripped
</code></pre>
</article>
<article class="doc-entry" id="doc-glob-match">
<h3><a class="doc-anchor" href="#doc-glob-match">#</a> <code>glob_match</code></h3>
<p>Test whether a string matches a shell-style glob pattern. Returns true (1) on match, false (empty string) otherwise. Supports <code>*</code>, <code>?</code>, <code>[abc]</code>, and <code>{a,b}</code>. This is a pure string match — it does not read the filesystem, so it works for filtering lists of paths you already have. Note: zsh glob qualifiers like <code>(/)</code> or <code>(.)</code> are stat-based filters that only apply at filesystem-expansion time (<code>glob</code>/<code>glob_par</code>/<code>slurp</code>); <code>glob_match</code> ignores any trailing qualifier.</p>
<pre><code class="lang-perl">p glob_match("*.pl", "script.pl") # 1
p glob_match("*.pl", "script.py") # (empty)
my @perl = grep { glob_match("*.{pl,pm}", _) } @files
@perl |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-copy">
<h3><a class="doc-anchor" href="#doc-copy">#</a> <code>copy</code></h3>
<p>Copy a file from a source path to a destination path. The destination can be a file path or a directory (in which case the source filename is preserved). Dies on failure. This is the programmatic equivalent of <code>cp</code> and avoids shelling out. Metadata such as permissions is preserved where possible.</p>
<pre><code class="lang-perl">copy("src/config.yaml", "/tmp/config.yaml")
copy("report.pdf", "/backup/")
my $tmp = tf()
copy($0, $tmp) # back up the current script
p slurp($tmp)
</code></pre>
</article>
<article class="doc-entry" id="doc-move">
<h3><a class="doc-anchor" href="#doc-move">#</a> <code>move</code></h3>
<p>Move or rename a file from source to destination. If the source and destination are on the same filesystem this is an atomic rename; otherwise it falls back to copy-then-delete. Dies on failure. The short alias <code>mv</code> mirrors the shell command.</p>
<pre><code class="lang-perl">move("draft.txt", "final.txt") # rename in place
mv("output.csv", "/archive/output.csv") # move across dirs
my $tmp = tf()
spurt($tmp, "data")
mv($tmp, "data.txt")
</code></pre>
</article>
<article class="doc-entry" id="doc-rename">
<h3><a class="doc-anchor" href="#doc-rename">#</a> <code>rename</code></h3>
<p>Rename a file or directory from an old name to a new name. This is an atomic operation on the same filesystem. If the destination already exists it is silently replaced. Dies on failure. Unlike <code>move</code>/<code>mv</code>, this does not fall back to copy-then-delete across filesystems.</p>
<pre><code class="lang-perl">rename("draft.md", "final.md")
rename("output", "output_v2") # works on dirs too
my $bak = "config.yaml.bak"
rename("config.yaml", $bak)
spurt("config.yaml", $new_config)
</code></pre>
</article>
<article class="doc-entry" id="doc-unlink">
<h3><a class="doc-anchor" href="#doc-unlink">#</a> <code>unlink</code></h3>
<p>Delete one or more files from the filesystem. Returns the number of files successfully removed. Does not remove directories — use <code>rmdir</code> for those. Dies on permission errors. Accepts a list of paths, making it convenient for batch cleanup.</p>
<pre><code class="lang-perl">unlink("temp.log")
my $n = unlink("a.tmp", "b.tmp", "c.tmp")
p "removed $n files"
my @old = glob("*.bak")
unlink(@old)
</code></pre>
</article>
<article class="doc-entry" id="doc-mkdir">
<h3><a class="doc-anchor" href="#doc-mkdir">#</a> <code>mkdir</code></h3>
<p>Create a directory at the given path. An optional second argument specifies the permission mode as an octal number (default <code>0777</code>, modified by the current <code>umask</code>). Dies if the directory cannot be created. Only creates one level — use <code>make_path</code> or shell out for recursive creation.</p>
<pre><code class="lang-perl">mkdir("output")
mkdir("/tmp/secure", 0700)
my $dir = tdr() . "/sub"
mkdir($dir)
p -d $dir # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-rmdir">
<h3><a class="doc-anchor" href="#doc-rmdir">#</a> <code>rmdir</code></h3>
<p>Remove an empty directory. Dies if the directory does not exist, is not empty, or cannot be removed due to permissions. This only removes a single directory — it will not recursively delete contents. Remove files with <code>unlink</code> first, then call <code>rmdir</code>.</p>
<pre><code class="lang-perl">mkdir("scratch")
rmdir("scratch")
p -d "scratch" # (empty, dir is gone)
unlink("tmp/file.txt")
rmdir("tmp")
</code></pre>
</article>
<article class="doc-entry" id="doc-chmod">
<h3><a class="doc-anchor" href="#doc-chmod">#</a> <code>chmod</code></h3>
<p>Change the permission bits of one or more files. The mode is specified as an octal number. Returns the number of files successfully changed. Does not follow symlinks on some platforms. Use <code>stat</code> to read the current mode before modifying.</p>
<pre><code class="lang-perl">chmod(0755, "script.pl")
chmod(0644, "config.yaml", "data.json")
my $n = chmod(0600, glob("*.key"))
p "secured $n key files"
</code></pre>
</article>
<article class="doc-entry" id="doc-chown">
<h3><a class="doc-anchor" href="#doc-chown">#</a> <code>chown</code></h3>
<p>Change the owner and group of one or more files, specified as numeric UID and GID. Pass <code>-1</code> for either to leave it unchanged. Returns the number of files successfully changed. Typically requires root privileges.</p>
<pre><code class="lang-perl">chown(1000, 1000, "app.log")
chown(-1, 100, "shared.txt") # change group only
my $uid = (getpwnam("deploy"))[2]
chown($uid, -1, "release.tar")
</code></pre>
</article>
<article class="doc-entry" id="doc-chdir">
<h3><a class="doc-anchor" href="#doc-chdir">#</a> <code>chdir</code></h3>
<p>Change the current working directory of the process. Dies if the directory does not exist or is not accessible. This affects all subsequent relative path operations. Pair with <code>getcwd</code>/<code>pwd</code> to save and restore the original directory.</p>
<pre><code class="lang-perl">my $orig = pwd()
chdir("/tmp")
spurt("scratch.txt", "hello")
chdir($orig) # return to original
</code></pre>
</article>
<article class="doc-entry" id="doc-stat">
<h3><a class="doc-anchor" href="#doc-stat">#</a> <code>stat</code></h3>
<p>Return a 13-element list of file status information for a path or filehandle: <code>($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks)</code>. This calls the POSIX <code>stat</code> system call. Use it to check file size, modification time, permissions, and other metadata without reading the file.</p>
<pre><code class="lang-perl">my @st = stat("data.bin")
p "size: $st[7] bytes"
p "modified: " . datetime_from_epoch($st[9])
my ($mode) = (stat($0))[2]
p sprintf("perms: %04o", $mode & 07777)
</code></pre>
</article>
<article class="doc-entry" id="doc-link">
<h3><a class="doc-anchor" href="#doc-link">#</a> <code>link</code></h3>
<p>Create a hard link — a new directory entry pointing to the same underlying inode as the original file. Both names are indistinguishable and share the same data; removing one does not affect the other. Hard links cannot cross filesystem boundaries and typically cannot link directories.</p>
<pre><code class="lang-perl">link("data.csv", "data_backup.csv")
my @st1 = stat("data.csv")
my @st2 = stat("data_backup.csv")
p $st1[1] == $st2[1] # 1 — same inode
</code></pre>
</article>
<article class="doc-entry" id="doc-symlink">
<h3><a class="doc-anchor" href="#doc-symlink">#</a> <code>symlink</code></h3>
<p>Create a symbolic (soft) link that points to a target path. Unlike hard links, symlinks can cross filesystems and can point to directories. The link stores the target as a string, so it can dangle if the target is later removed. Use <code>readlink</code> to inspect where a symlink points.</p>
<pre><code class="lang-perl">symlink("/usr/local/bin/stryke", "pe_link")
p readlink("pe_link") # /usr/local/bin/stryke
p -l "pe_link" # 1 (is a symlink)
symlink("../lib", "lib_link") # relative target
</code></pre>
</article>
<article class="doc-entry" id="doc-readlink">
<h3><a class="doc-anchor" href="#doc-readlink">#</a> <code>readlink</code></h3>
<p>Return the target path that a symbolic link points to, without following the link further. Returns <code>undef</code> if the path is not a symlink. This is useful for inspecting symlink chains, verifying link targets, or resolving one level of indirection at a time.</p>
<pre><code class="lang-perl">symlink("real.conf", "link.conf")
my $target = readlink("link.conf")
p $target # real.conf
if (defined readlink($path)) {
p "$path is a symlink"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-utime">
<h3><a class="doc-anchor" href="#doc-utime">#</a> <code>utime</code></h3>
<p>Set the access time and modification time of one or more files. Times are specified as epoch seconds. Pass <code>undef</code> for either time to set it to the current time. Returns the number of files successfully updated. Useful for cache invalidation, build systems, or preserving timestamps after transformations.</p>
<pre><code class="lang-perl">utime(time(), time(), "output.txt") # touch to now
my $epoch = 1700000000
utime($epoch, $epoch, @files) # backdate files
utime(undef, undef, "marker.flag") # equivalent of touch
</code></pre>
</article>
<article class="doc-entry" id="doc-umask">
<h3><a class="doc-anchor" href="#doc-umask">#</a> <code>umask</code></h3>
<p>Get or set the file creation mask, which controls the default permissions for newly created files and directories. When called with an argument, sets the new mask and returns the previous one. When called without arguments, returns the current mask. The mask is subtracted from the requested permissions in <code>mkdir</code>, <code>open</code>, etc.</p>
<pre><code class="lang-perl">my $old = umask(0077) # restrict: owner-only
mkdir("private") # created with 0700
umask($old) # restore previous mask
p sprintf("%04o", umask()) # print current mask
</code></pre>
</article>
<article class="doc-entry" id="doc-uname">
<h3><a class="doc-anchor" href="#doc-uname">#</a> <code>uname</code></h3>
<p>Return system identification as a five-element list: <code>($sysname, $nodename, $release, $version, $machine)</code>. This calls the POSIX <code>uname</code> system call and is useful for platform-specific logic, logging system info, or generating diagnostic reports without shelling out.</p>
<pre><code class="lang-perl">my ($sys, $node, $rel, $ver, $arch) = uname()
p "$sys $rel ($arch)" # Linux 6.1.0 (x86_64)
if ($sys eq "Darwin") {
p "running on macOS"
}
log_info("host: $node, kernel: $rel")
</code></pre>
</article>
<article class="doc-entry" id="doc-gethostname">
<h3><a class="doc-anchor" href="#doc-gethostname">#</a> <code>gethostname</code></h3>
<p>Return the hostname of the current machine as a string. This calls the POSIX <code>gethostname</code> system call. The short alias <code>hn</code> is useful in log prefixes, temp-file naming, or distributed-system identifiers where you need to tag output by machine.</p>
<pre><code class="lang-perl">p gethostname() # myhost.local
my $log_prefix = hn() . ":" . $$ # myhost.local:12345
log_info("running on " . hn())
</code></pre>
</article>
<article class="doc-entry" id="doc-opendir">
<h3><a class="doc-anchor" href="#doc-opendir">#</a> <code>opendir</code></h3>
<p>Open a directory handle for reading its entries. Returns a directory handle that can be passed to <code>readdir</code>, <code>seekdir</code>, <code>telldir</code>, <code>rewinddir</code>, and <code>closedir</code>. Dies if the directory does not exist or cannot be opened. For most use cases <code>glob</code> or <code>readdir</code> with a path is simpler.</p>
<pre><code class="lang-perl">opendir(my $dh, "/tmp") or die "cannot open: $!"
my @entries = readdir($dh)
closedir($dh)
@entries |> grep { _ !~ /^\./ } |> e p # skip dotfiles
</code></pre>
</article>
<article class="doc-entry" id="doc-readdir">
<h3><a class="doc-anchor" href="#doc-readdir">#</a> <code>readdir</code></h3>
<p>Read entries from a directory handle opened with <code>opendir</code>. In list context, returns all remaining entries. In scalar context, returns the next single entry or <code>undef</code> when exhausted. Entries include <code>.</code> and <code>..</code> so you typically filter them out.</p>
<pre><code class="lang-perl">opendir(my $dh, ".") or die $!
while (my $entry = readdir($dh)) {
next if $entry =~ /^\./
p $entry
}
closedir($dh)
</code></pre>
</article>
<article class="doc-entry" id="doc-closedir">
<h3><a class="doc-anchor" href="#doc-closedir">#</a> <code>closedir</code></h3>
<p>Close a directory handle previously opened with <code>opendir</code>, releasing the underlying OS resource. While directory handles are closed automatically when they go out of scope, explicit <code>closedir</code> is good practice in long-running programs or loops that open many directories.</p>
<pre><code class="lang-perl">opendir(my $dh, "/var/log") or die $!
my @logs = readdir($dh)
closedir($dh)
@logs |> grep { /\.log$/ } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-seekdir">
<h3><a class="doc-anchor" href="#doc-seekdir">#</a> <code>seekdir</code></h3>
<p>Set the current position in a directory handle to a location previously obtained from <code>telldir</code>. This allows you to revisit directory entries without closing and reopening the handle. Rarely needed in practice, but useful for multi-pass directory scanning.</p>
<pre><code class="lang-perl">opendir(my $dh, ".") or die $!
my $pos = telldir($dh)
my @first_pass = readdir($dh)
seekdir($dh, $pos) # rewind to saved position
my @second_pass = readdir($dh)
closedir($dh)
</code></pre>
</article>
<article class="doc-entry" id="doc-telldir">
<h3><a class="doc-anchor" href="#doc-telldir">#</a> <code>telldir</code></h3>
<p>Return the current read position within a directory handle as an opaque integer. The returned value can be passed to <code>seekdir</code> to return to that position later. This is the directory-handle equivalent of <code>tell</code> for file handles.</p>
<pre><code class="lang-perl">opendir(my $dh, "/tmp") or die $!
readdir($dh) # skip .
readdir($dh) # skip ..
my $pos = telldir($dh) # save position after . and ..
my @real = readdir($dh)
seekdir($dh, $pos) # go back
</code></pre>
</article>
<article class="doc-entry" id="doc-rewinddir">
<h3><a class="doc-anchor" href="#doc-rewinddir">#</a> <code>rewinddir</code></h3>
<p>Reset a directory handle back to the beginning so that the next <code>readdir</code> returns the first entry again. This is equivalent to closing and reopening the directory but more efficient. Useful when you need to iterate a directory multiple times.</p>
<pre><code class="lang-perl">opendir(my $dh, "src") or die $!
my $count = scalar readdir($dh)
rewinddir($dh)
my @entries = readdir($dh)
closedir($dh)
p "$count entries"
</code></pre>
</article>
<article class="doc-entry" id="doc-du">
<h3><a class="doc-anchor" href="#doc-du">#</a> <code>du</code></h3>
<p><code>du</code> (alias <code>dir_size</code>) — compute the total size of a directory tree in bytes, recursively walking all files.</p>
<pre><code class="lang-perl">my $bytes = du("/usr/local")
p "$bytes bytes"
</code></pre>
</article>
<article class="doc-entry" id="doc-du-tree">
<h3><a class="doc-anchor" href="#doc-du-tree">#</a> <code>du_tree</code></h3>
<p><code>du_tree</code> (alias <code>dir_sizes</code>) — return directory sizes as an array of hashrefs <code>{path, size}</code>, sorted descending by size. Each entry is an immediate child directory.</p>
<pre><code class="lang-perl">my @dirs = du_tree("/usr/local")
for (@dirs) { p "_->{path}: _->{size}" }
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-process">
<h2>Process</h2>
<p class="chapter-meta">21 topics</p>
<article class="doc-entry" id="doc-system">
<h3><a class="doc-anchor" href="#doc-system">#</a> <code>system</code></h3>
<p>Execute a command in a subshell and wait for it to complete, returning the exit status. A return value of <code>0</code> means success; non-zero indicates failure. The exit status is encoded as <code>$? >> 8</code> for the actual exit code. Use backticks or <code>capture</code> if you need the command's output.</p>
<pre><code class="lang-perl">my $rc = system("make", "test")
p "exit code: " . ($rc >> 8)
system("cp data.csv /backup/") == 0 or die "copy failed"
if (system("which rg >/dev/null 2>&1") == 0) {
p "ripgrep is installed"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-exec">
<h3><a class="doc-anchor" href="#doc-exec">#</a> <code>exec</code></h3>
<p>Replace the current process image entirely with a new command. This never returns on success — the new program takes over. If <code>exec</code> fails (command not found, permission denied) it returns false and execution continues. Use <code>system</code> instead if you want to run a command and keep the current process alive.</p>
<pre><code class="lang-perl">exec("ls", "-la", "/tmp") or die "exec failed: $!"
# code here only runs if exec fails
# common fork+exec pattern
if (fork() == 0) {
exec("worker", "--daemon")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-fork">
<h3><a class="doc-anchor" href="#doc-fork">#</a> <code>fork</code></h3>
<p>Fork the current process, creating a child that is an exact copy of the parent. Returns the child's PID to the parent process and <code>0</code> to the child, allowing each side to branch. Returns <code>undef</code> on failure. Always pair with <code>wait</code>/<code>waitpid</code> to reap the child and avoid zombies.</p>
<pre><code class="lang-perl">my $pid = fork()
if ($pid == 0) {
p "child $$"
exit(0)
}
p "parent $$, child is $pid"
waitpid($pid, 0)
</code></pre>
</article>
<article class="doc-entry" id="doc-wait">
<h3><a class="doc-anchor" href="#doc-wait">#</a> <code>wait</code></h3>
<p>Wait for any child process to terminate and return its PID. The exit status is stored in <code>$?</code>. If there are no child processes, returns <code>-1</code>. This is the simplest reaping function — use <code>waitpid</code> when you need to wait for a specific child or use non-blocking flags.</p>
<pre><code class="lang-perl">for (1:3) {
fork() or do { sleep(1)
exit(0) }
}
while ((my $pid = wait()) != -1) {
p "child $pid exited with " . ($? >> 8)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-waitpid">
<h3><a class="doc-anchor" href="#doc-waitpid">#</a> <code>waitpid</code></h3>
<p>Wait for a specific child process identified by PID to change state. The flags argument controls behavior — use <code>0</code> for blocking wait, or <code>WNOHANG</code> for non-blocking (returns <code>0</code> if child is still running). Returns the PID on success, <code>-1</code> if the child does not exist. Exit status is in <code>$?</code>.</p>
<pre><code class="lang-perl">my $pid = fork() // die "fork: $!"
if ($pid == 0) { sleep(2)
exit(42) }
waitpid($pid, 0)
p "child exited: " . ($? >> 8) # 42
# non-blocking poll
while (waitpid($pid, WNOHANG) == 0) {
p "still running..."
sleep(1)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-kill">
<h3><a class="doc-anchor" href="#doc-kill">#</a> <code>kill</code></h3>
<p>Send a signal to one or more processes by PID. The signal can be specified as a number (<code>9</code>) or a name (<code>"TERM"</code>). Sending signal <code>0</code> tests whether the process exists without actually sending anything. Returns the number of processes successfully signaled.</p>
<pre><code class="lang-perl">kill("TERM", $child_pid)
kill(9, @worker_pids) # SIGKILL
if (kill(0, $pid)) {
p "process $pid is alive"
}
my $n = kill("HUP", @daemons)
p "signaled $n processes"
</code></pre>
</article>
<article class="doc-entry" id="doc-exit">
<h3><a class="doc-anchor" href="#doc-exit">#</a> <code>exit</code></h3>
<p>Terminate the program immediately with the given exit status code. An exit code of <code>0</code> conventionally means success; any non-zero value indicates an error. <code>END</code> blocks and object destructors are still run. Use <code>POSIX::_exit</code> to skip cleanup entirely.</p>
<pre><code class="lang-perl">exit(0) # success
exit(1) if $error # failure
# conditional exit in a pipeline
my $ok = system("make test")
exit($ok >> 8) if $ok
</code></pre>
</article>
<article class="doc-entry" id="doc-getlogin">
<h3><a class="doc-anchor" href="#doc-getlogin">#</a> <code>getlogin</code></h3>
<p>Return the login name of the user who owns the current terminal session. This reads from the system's utmp/utmpx database and may return <code>undef</code> for processes without a controlling terminal (cron jobs, daemons). For a more reliable alternative, use <code>getpwuid($<)</code> which looks up the effective UID.</p>
<pre><code class="lang-perl">my $user = getlogin() // (getpwuid($<))[0]
p "running as $user"
log_info("session started by " . getlogin())
</code></pre>
</article>
<article class="doc-entry" id="doc-getpwnam">
<h3><a class="doc-anchor" href="#doc-getpwnam">#</a> <code>getpwnam</code></h3>
<p>Look up user account information by username string. Returns the same 9-element list as <code>getpwuid</code>: <code>($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell)</code>. Returns empty list if the user does not exist. Useful for resolving a username to a UID before calling <code>chown</code>.</p>
<pre><code class="lang-perl">my @info = getpwnam("deploy")
p "uid=$info[2] home=$info[7]"
my $uid = (getpwnam("www-data"))[2]
chown($uid, -1, "public/index.html")
</code></pre>
</article>
<article class="doc-entry" id="doc-getpwuid">
<h3><a class="doc-anchor" href="#doc-getpwuid">#</a> <code>getpwuid</code></h3>
<p>Look up user account information by numeric UID. Returns <code>($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell)</code> on success, or empty list if the UID does not exist. This is the reliable way to map a UID to a username and home directory.</p>
<pre><code class="lang-perl">my ($name, undef, undef, undef, undef, undef, undef, $home) = getpwuid($<)
p "user: $name, home: $home"
my $root_shell = (getpwuid(0))[8]
p $root_shell # /bin/bash or /bin/zsh
</code></pre>
</article>
<article class="doc-entry" id="doc-getpwent">
<h3><a class="doc-anchor" href="#doc-getpwent">#</a> <code>getpwent</code></h3>
<p>Read the next entry from the system password database, iterating through all user accounts. Returns <code>($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell)</code> for each user, or empty list when exhausted. Call <code>setpwent</code> to rewind and <code>endpwent</code> to close.</p>
<pre><code class="lang-perl">while (my @pw = getpwent()) {
p "$pw[0]: uid=$pw[2] home=$pw[7]"
}
endpwent()
</code></pre>
</article>
<article class="doc-entry" id="doc-getgrgid">
<h3><a class="doc-anchor" href="#doc-getgrgid">#</a> <code>getgrgid</code></h3>
<p>Look up group information by numeric GID. Returns <code>($name, $passwd, $gid, $members)</code> where members is a space-separated string of usernames belonging to the group. Returns empty list if the GID does not exist.</p>
<pre><code class="lang-perl">my ($name, undef, undef, $members) = getgrgid(0)
p "group $name: $members"
my $gname = (getgrgid((stat("file.txt"))[5]))[0]
p "file group: $gname"
</code></pre>
</article>
<article class="doc-entry" id="doc-getgrnam">
<h3><a class="doc-anchor" href="#doc-getgrnam">#</a> <code>getgrnam</code></h3>
<p>Look up group information by group name string. Returns <code>($name, $passwd, $gid, $members)</code>. Useful for resolving a group name to a GID before calling <code>chown</code>, or for checking group membership.</p>
<pre><code class="lang-perl">my ($name, undef, $gid, $members) = getgrnam("staff")
p "gid=$gid members=$members"
chown(-1, $gid, "shared_dir")
if ((getgrnam("admin"))[3] =~ /\b$user\b/) {
p "$user is an admin"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-getgrent">
<h3><a class="doc-anchor" href="#doc-getgrent">#</a> <code>getgrent</code></h3>
<p>Read the next entry from the system group database, iterating through all groups. Returns <code>($name, $passwd, $gid, $members)</code> for each group, or empty list when exhausted. The members field is a space-separated string of usernames. Call <code>endgrent</code> when done.</p>
<pre><code class="lang-perl">while (my @gr = getgrent()) {
p "$gr[0]: gid=$gr[2] members=$gr[3]"
}
endgrent()
</code></pre>
</article>
<article class="doc-entry" id="doc-getppid">
<h3><a class="doc-anchor" href="#doc-getppid">#</a> <code>getppid</code></h3>
<p>Return the process ID of the parent process. This is useful for detecting whether the process has been orphaned (parent PID becomes 1 on Unix when the original parent exits), or for logging the process hierarchy. Always returns a valid PID.</p>
<pre><code class="lang-perl">p "my pid: $$, parent: " . getppid()
if (getppid() == 1) {
log_warn("parent process has exited, we are orphaned")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-getpgrp">
<h3><a class="doc-anchor" href="#doc-getpgrp">#</a> <code>getpgrp</code></h3>
<p>Return the process group ID of the current process (or of the specified PID). Processes in the same group receive signals together — for example, Ctrl-C sends SIGINT to the entire foreground process group. Use <code>setpgrp</code> to move a process into a different group.</p>
<pre><code class="lang-perl">p "process group: " . getpgrp()
my $pg = getpgrp($$)
p $pg == $$ ? "group leader" : "group member"
</code></pre>
</article>
<article class="doc-entry" id="doc-setpgrp">
<h3><a class="doc-anchor" href="#doc-setpgrp">#</a> <code>setpgrp</code></h3>
<p>Set the process group ID of a process. Call <code>setpgrp(0, 0)</code> to make the current process a new group leader, which is useful for daemonization or isolating a subprocess from the terminal's signal group. Takes <code>(PID, PGID)</code> — use <code>0</code> for the current process.</p>
<pre><code class="lang-perl">setpgrp(0, 0) # become process group leader
if (fork() == 0) {
setpgrp(0, 0) # child gets its own group
exec("worker")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-getpriority">
<h3><a class="doc-anchor" href="#doc-getpriority">#</a> <code>getpriority</code></h3>
<p>Get the scheduling priority (nice value) of a process, process group, or user. The <code>which</code> argument selects the target type: <code>PRIO_PROCESS</code>, <code>PRIO_PGRP</code>, or <code>PRIO_USER</code>. Lower values mean higher priority. The default nice value is <code>0</code>; range is typically <code>-20</code> to <code>19</code>.</p>
<pre><code class="lang-perl">my $nice = getpriority(0, $$) # PRIO_PROCESS, current PID
p "nice value: $nice"
my $user_prio = getpriority(2, $<) # PRIO_USER, current user
p "user priority: $user_prio"
</code></pre>
</article>
<article class="doc-entry" id="doc-setpriority">
<h3><a class="doc-anchor" href="#doc-setpriority">#</a> <code>setpriority</code></h3>
<p>Set the scheduling priority (nice value) of a process, process group, or user. Lowering the nice value (higher priority) typically requires root privileges. Raising it (lower priority) is always allowed. Use this to deprioritize background batch work or boost latency-sensitive tasks.</p>
<pre><code class="lang-perl">setpriority(0, $$, 10) # lower priority for batch work
if (fork() == 0) {
setpriority(0, 0, 19) # lowest priority for child
exec("batch-job")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-syscall">
<h3><a class="doc-anchor" href="#doc-syscall">#</a> <code>syscall</code></h3>
<p>Invoke a raw system call by its numeric identifier, passing arguments directly to the kernel. This is an escape hatch for system calls that have no Perl wrapper. The call number is platform-specific and the arguments must be correctly typed (integers or string buffers). Use with caution — incorrect arguments can crash the process.</p>
<pre><code class="lang-perl"># SYS_getpid on Linux x86_64 is 39
my $pid = syscall(39)
p $pid # same as $$
# SYS_sync on Linux is 162
syscall(162) # flush filesystem caches
</code></pre>
</article>
<article class="doc-entry" id="doc-process-list">
<h3><a class="doc-anchor" href="#doc-process-list">#</a> <code>process_list</code></h3>
<p><code>process_list</code> (aliases <code>ps</code>, <code>procs</code>) — list running processes as an array of hashrefs with <code>{pid, name, uid}</code> keys.</p>
<pre><code class="lang-perl">my @procs = ps()
for (@procs) { p "_->{pid} _->{name}" }
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-pack-binary">
<h2>Pack / Binary</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-pack">
<h3><a class="doc-anchor" href="#doc-pack">#</a> <code>pack</code></h3>
<p>Convert a list of values into a binary string according to a template. Each template character specifies how one value is encoded: <code>N</code> for 32-bit big-endian unsigned, <code>n</code> for 16-bit, <code>a</code> for raw bytes, <code>Z</code> for null-terminated string, etc. This is essential for constructing binary protocols, file formats, and <code>sockaddr</code> structures.</p>
<pre><code class="lang-perl">my $bin = pack("NnA4", 0xDEADBEEF, 8080, "test")
p length($bin) # 10 bytes
my $header = pack("A8 N N", "MAGIC01\0", 1, 42)
spurt("data.bin", $header)
</code></pre>
</article>
<article class="doc-entry" id="doc-unpack">
<h3><a class="doc-anchor" href="#doc-unpack">#</a> <code>unpack</code></h3>
<p>Decode a binary string into a list of values according to a template, performing the inverse of <code>pack</code>. The template characters must match how the data was packed. Use this for parsing binary file formats, network protocol headers, or any structured binary data.</p>
<pre><code class="lang-perl">my ($magic, $version, $count) = unpack("A8 N N", $header)
p "v$version, $count records"
my ($port, $addr) = unpack("n a4", $sockaddr)
p inet_ntoa($addr) . ":$port"
</code></pre>
</article>
<article class="doc-entry" id="doc-unpack-first">
<h3><a class="doc-anchor" href="#doc-unpack-first">#</a> <code>unpack_first</code></h3>
<p><code>unpack_first(FMT, STR)</code> — decode the binary string and return the <strong>first</strong> decoded element (or <code>undef</code> if the format yields nothing). The stryke spelling of Perl's <code>scalar unpack(FMT, STR)</code> for <code>--no-interop</code> mode where <code>scalar</code> is rejected at parse time. Aliases: <code>unpack1</code>, <code>up1</code>. Equivalent to <code>head(unpack(FMT, STR))</code> but spelled as a single verb.</p>
<pre><code class="lang-perl">my $first_byte = unpack_first("C", $bytes)
my $port = unpack1("n", $sockaddr)
my $magic_word = up1("N", $header)
</code></pre>
</article>
<article class="doc-entry" id="doc-vec">
<h3><a class="doc-anchor" href="#doc-vec">#</a> <code>vec</code></h3>
<p>Treat a string as a bit vector and get or set individual elements at a specified bit width. The first argument is the string, the second is the element offset, and the third is the bit width (1, 2, 4, 8, 16, or 32). As an lvalue, <code>vec</code> modifies the string in place. Useful for compact boolean arrays and bitmap manipulation.</p>
<pre><code class="lang-perl">my $bits = ""
vec($bits, 0, 1) = 1 # set bit 0
vec($bits, 7, 1) = 1 # set bit 7
p vec($bits, 0, 1) # 1
p vec($bits, 3, 1) # 0
p unpack("B8", $bits) # 10000001
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-logging">
<h2>Logging</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-log-info">
<h3><a class="doc-anchor" href="#doc-log-info">#</a> <code>log_info</code></h3>
<p>Log a message at INFO level to stderr with a timestamp prefix. INFO is the default visible level and is appropriate for normal operational messages — startup notices, progress milestones, summary statistics. Messages are suppressed if the current log level is set higher than INFO.</p>
<pre><code class="lang-perl">log_info("server started on port $port")
my @rows = rl("data.csv")
log_info("loaded " . scalar(@rows) . " rows")
1:5 |> e { log_info("processing item $_") }
</code></pre>
</article>
<article class="doc-entry" id="doc-log-warn">
<h3><a class="doc-anchor" href="#doc-log-warn">#</a> <code>log_warn</code></h3>
<p>Log a message at WARN level to stderr. Warnings indicate unexpected but recoverable situations — missing optional config, deprecated usage, slow operations. WARN messages appear at the default log level and are visually distinct from INFO in structured log output.</p>
<pre><code class="lang-perl">log_warn("config file not found, using defaults")
log_warn("query took ${elapsed}s, exceeds threshold")
unless (-e $path) {
log_warn("$path missing, skipping")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-log-error">
<h3><a class="doc-anchor" href="#doc-log-error">#</a> <code>log_error</code></h3>
<p>Log a message at ERROR level to stderr. Use this for failures that prevent an operation from completing but do not necessarily terminate the program — failed network requests, invalid input, permission errors. ERROR is always visible regardless of log level.</p>
<pre><code class="lang-perl">log_error("failed to connect to $host: $!")
eval { rj("bad.json") }
log_error("parse failed: $@") if $@
log_error("missing required field 'name'")
</code></pre>
</article>
<article class="doc-entry" id="doc-log-debug">
<h3><a class="doc-anchor" href="#doc-log-debug">#</a> <code>log_debug</code></h3>
<p>Log a message at DEBUG level to stderr. Debug messages are hidden by default and only appear when the log level is lowered to DEBUG or TRACE via <code>log_level</code>. Use for detailed internal state that helps during development — variable dumps, branch decisions, intermediate values.</p>
<pre><code class="lang-perl">log_level("debug")
log_debug("cache key: $key")
my $result = compute($x)
log_debug("compute($x) => $result")
@items |> e { log_debug("item: $_") }
</code></pre>
</article>
<article class="doc-entry" id="doc-log-trace">
<h3><a class="doc-anchor" href="#doc-log-trace">#</a> <code>log_trace</code></h3>
<p>Log a message at TRACE level to stderr. This is the most verbose level, producing very fine-grained output — loop iterations, function entry/exit, raw payloads. Only visible when <code>log_level("trace")</code> is set. Use sparingly in production code; primarily for deep debugging sessions.</p>
<pre><code class="lang-perl">log_level("trace")
fn process($x) {
log_trace("entering process($x)")
my $r = $x * 2
log_trace("leaving process => $r")
$r
}
1:3 |> map process |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-json">
<h3><a class="doc-anchor" href="#doc-log-json">#</a> <code>log_json</code></h3>
<p>Emit a structured JSON log line to stderr containing the message plus any additional key-value metadata. This is designed for machine-parseable logging pipelines — centralized log collectors, JSON-based monitoring, or <code>jq</code>-friendly output. Each call emits exactly one JSON object per line.</p>
<pre><code class="lang-perl">log_json("request", method => "GET", path => "/api")
log_json("metric", name => "latency_ms", value => 42)
log_json("error", msg => $@, file => $0)$1
Note: all values are serialized as JSON strings.
</code></pre>
</article>
<article class="doc-entry" id="doc-log-level">
<h3><a class="doc-anchor" href="#doc-log-level">#</a> <code>log_level</code></h3>
<p>Get or set the current minimum log level. When called with no arguments, returns the current level as a string. When called with a level name, sets it for all subsequent log calls. Valid levels from most to least verbose: <code>trace</code>, <code>debug</code>, <code>info</code>, <code>warn</code>, <code>error</code>. The default level is <code>info</code>.</p>
<pre><code class="lang-perl">p log_level() # info
log_level("debug") # enable debug output
log_debug("now visible")
log_level("error") # suppress everything below error
log_info("hidden") # not printed
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-charts-svg">
<h2>Charts (SVG)</h2>
<p class="chapter-meta">19 topics</p>
<article class="doc-entry" id="doc-scatter-svg">
<h3><a class="doc-anchor" href="#doc-scatter-svg">#</a> <code>scatter_svg</code></h3>
<p><code>scatter_svg</code> (alias <code>scatter_plot</code>) — generate an SVG scatter plot. Args: xs, ys [, title]. Dark theme, auto-scaled axes.</p>
<pre><code class="lang-perl">scatter_svg([1,2,3,4], [1,4,9,16], "Squares") |> to_file("scatter.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-line-svg">
<h3><a class="doc-anchor" href="#doc-line-svg">#</a> <code>line_svg</code></h3>
<p><code>line_svg</code> (alias <code>line_plot</code>) — generate an SVG line plot. Args: xs, ys [, title].</p>
<pre><code class="lang-perl">my @x = map { _ * 0.1 } 0:100
my @y = map { sin(_) } @x
line_svg(\@x, \@y, "Sine") |> to_file("sine.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-plot-svg">
<h3><a class="doc-anchor" href="#doc-plot-svg">#</a> <code>plot_svg</code></h3>
<p><code>plot_svg</code> — SVG line plot with auto X axis (0..n-1). Args: ys [, title].</p>
<pre><code class="lang-perl">plot_svg([map { _ ** 2 } 0:50], "Parabola") |> to_file("plot.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-hist-svg">
<h3><a class="doc-anchor" href="#doc-hist-svg">#</a> <code>hist_svg</code></h3>
<p><code>hist_svg</code> (alias <code>histogram_svg</code>) — SVG histogram with auto-binning (sqrt rule). Args: data [, bins, title].</p>
<pre><code class="lang-perl">rnorm(1000) |> hist_svg(30, "Normal") |> to_file("hist.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-boxplot-svg">
<h3><a class="doc-anchor" href="#doc-boxplot-svg">#</a> <code>boxplot_svg</code></h3>
<p><code>boxplot_svg</code> (alias <code>box_plot</code>) — SVG box-and-whisker plot with IQR whiskers and outlier detection. Args: groups [, title]. Groups is array of arrays.</p>
<pre><code class="lang-perl">boxplot_svg([[1,2,3,4,5], [3,4,5,6,20]], "Compare") |> to_file("box.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-bar-svg">
<h3><a class="doc-anchor" href="#doc-bar-svg">#</a> <code>bar_svg</code></h3>
<p><code>bar_svg</code> (alias <code>barchart_svg</code>) — SVG bar chart with labeled bars and value annotations. Args: labels, values [, title].</p>
<pre><code class="lang-perl">bar_svg(["Rust","Go","C++"], [45,30,25], "Languages") |> to_file("bar.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-pie-svg">
<h3><a class="doc-anchor" href="#doc-pie-svg">#</a> <code>pie_svg</code></h3>
<p><code>pie_svg</code> (alias <code>pie_chart</code>) — SVG pie chart with percentage labels. Args: labels, values [, title].</p>
<pre><code class="lang-perl">pie_svg(["A","B","C"], [50,30,20]) |> to_file("pie.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-heatmap-svg">
<h3><a class="doc-anchor" href="#doc-heatmap-svg">#</a> <code>heatmap_svg</code></h3>
<p><code>heatmap_svg</code> (alias <code>heatmap</code>) — SVG heatmap with blue-cyan-yellow-red colormap. Args: matrix [, title].</p>
<pre><code class="lang-perl">heatmap_svg(cor_mat($data), "Correlation") |> to_file("heat.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-donut-svg">
<h3><a class="doc-anchor" href="#doc-donut-svg">#</a> <code>donut_svg</code></h3>
<p><code>donut_svg</code> (alias <code>donut</code>) — SVG donut chart with percentage labels. Accepts labels+values or a hashref.</p>
<pre><code class="lang-perl">donut_svg(["A","B","C"], [50,30,20], "Share") |> to_file("donut.svg")
{Rust => 45, Go => 30} |> donut("Languages") |> to_file("donut.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-area-svg">
<h3><a class="doc-anchor" href="#doc-area-svg">#</a> <code>area_svg</code></h3>
<p><code>area_svg</code> (alias <code>area_chart</code>) — SVG filled area chart. Args: xs, ys [, title].</p>
<pre><code class="lang-perl">my @x = 0:20
my @y = map { sin(_ * 0.3) } @x
area_svg(\@x, \@y, "Wave") |> to_file("area.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-hbar-svg">
<h3><a class="doc-anchor" href="#doc-hbar-svg">#</a> <code>hbar_svg</code></h3>
<p><code>hbar_svg</code> (alias <code>hbar</code>) — SVG horizontal bar chart. Accepts labels+values or a hashref.</p>
<pre><code class="lang-perl">hbar_svg(["Rust","Go","C++"], [45,30,25], "Speed") |> to_file("hbar.svg")
{alpha => 10, beta => 20} |> hbar |> to_file("hbar.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-radar-svg">
<h3><a class="doc-anchor" href="#doc-radar-svg">#</a> <code>radar_svg</code></h3>
<p><code>radar_svg</code> (aliases <code>radar</code>, <code>spider</code>) — SVG radar/spider chart. Args: labels, values [, title].</p>
<pre><code class="lang-perl">radar_svg(["Atk","Def","Spd","HP","MP"], [8,6,9,5,7], "Stats") |> to_file("radar.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-candlestick-svg">
<h3><a class="doc-anchor" href="#doc-candlestick-svg">#</a> <code>candlestick_svg</code></h3>
<p><code>candlestick_svg</code> (aliases <code>candlestick</code>, <code>ohlc</code>) — SVG candlestick OHLC chart. Args: array of [open,high,low,close] [, title].</p>
<pre><code class="lang-perl">candlestick_svg([[100,110,95,105],[105,115,100,112]], "Stock") |> to_file("ohlc.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-violin-svg">
<h3><a class="doc-anchor" href="#doc-violin-svg">#</a> <code>violin_svg</code></h3>
<p><code>violin_svg</code> (alias <code>violin</code>) — SVG violin plot from array of arrays showing distribution shape.</p>
<pre><code class="lang-perl">violin_svg([rnorm(200), rnorm(200, 2)], "Distributions") |> to_file("violin.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-cor-heatmap">
<h3><a class="doc-anchor" href="#doc-cor-heatmap">#</a> <code>cor_heatmap</code></h3>
<p><code>cor_heatmap</code> (alias <code>cor_matrix_svg</code>) — SVG correlation matrix heatmap. Computes pairwise correlations and renders as heatmap.</p>
<pre><code class="lang-perl">cor_heatmap([rnorm(100), rnorm(100), rnorm(100)], "Correlations") |> to_file("cor.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-stacked-bar-svg">
<h3><a class="doc-anchor" href="#doc-stacked-bar-svg">#</a> <code>stacked_bar_svg</code></h3>
<p><code>stacked_bar_svg</code> (alias <code>stacked_bar</code>) — SVG stacked bar chart. Args: labels, series (array of arrays) [, title].</p>
<pre><code class="lang-perl">stacked_bar_svg(["Q1","Q2","Q3"], [[10,20,30],[5,15,25]], "Revenue") |> to_file("stacked.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-wordcloud-svg">
<h3><a class="doc-anchor" href="#doc-wordcloud-svg">#</a> <code>wordcloud_svg</code></h3>
<p><code>wordcloud_svg</code> (aliases <code>wordcloud</code>, <code>wcloud</code>) — SVG word cloud from frequency hashref. Word size scales with frequency.</p>
<pre><code class="lang-perl">{rust => 50, go => 30, python => 40} |> wordcloud("Languages") |> to_file("cloud.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-treemap-svg">
<h3><a class="doc-anchor" href="#doc-treemap-svg">#</a> <code>treemap_svg</code></h3>
<p><code>treemap_svg</code> (alias <code>treemap</code>) — SVG treemap from frequency hashref. Area proportional to values.</p>
<pre><code class="lang-perl">{src => 500, tests => 200, docs => 100} |> treemap("Codebase") |> to_file("tree.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-preview">
<h3><a class="doc-anchor" href="#doc-preview">#</a> <code>preview</code></h3>
<p><code>preview</code> (alias <code>pvw</code>) — wrap SVG/HTML content in a cyberpunk-styled page and open in the default browser.</p>
<pre><code class="lang-perl">scatter_svg([1,2,3], [1,4,9]) |> preview
bar_svg(["A","B"], [10,20]) |> pvw
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-audio">
<h2>Audio</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-audio-convert">
<h3><a class="doc-anchor" href="#doc-audio-convert">#</a> <code>audio_convert</code></h3>
<p><code>audio_convert</code> (alias <code>aconv</code>) — convert audio files between WAV, FLAC, AIFF, and MP3 formats.</p>
<pre><code class="lang-perl">audio_convert("song.flac", "song.mp3")
aconv("input.wav", "output.mp3")
</code></pre>
</article>
<article class="doc-entry" id="doc-audio-info">
<h3><a class="doc-anchor" href="#doc-audio-info">#</a> <code>audio_info</code></h3>
<p><code>audio_info</code> (alias <code>ainfo</code>) — get audio file metadata (duration, sample rate, channels, format) as a hashref.</p>
<pre><code class="lang-perl">my $info = ainfo("song.mp3")
p $info->{duration} # seconds
p $info->{sample_rate} # e.g. 44100
</code></pre>
</article>
<article class="doc-entry" id="doc-id3-read">
<h3><a class="doc-anchor" href="#doc-id3-read">#</a> <code>id3_read</code></h3>
<p><code>id3_read</code> (alias <code>id3</code>) — read ID3 tags from an MP3 file as a hashref (title, artist, album, year, etc.).</p>
<pre><code class="lang-perl">my $tags = id3("song.mp3")
p "$tags->{artist} - $tags->{title}"
</code></pre>
</article>
<article class="doc-entry" id="doc-id3-write">
<h3><a class="doc-anchor" href="#doc-id3-write">#</a> <code>id3_write</code></h3>
<p><code>id3_write</code> (alias <code>id3w</code>) — write ID3 tags to an MP3 file from a hashref.</p>
<pre><code class="lang-perl">id3w("song.mp3", {title => "New Title", artist => "Artist", year => "2026"})
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-network-utilities">
<h2>Network Utilities</h2>
<p class="chapter-meta">18 topics</p>
<article class="doc-entry" id="doc-net-interfaces">
<h3><a class="doc-anchor" href="#doc-net-interfaces">#</a> <code>net_interfaces</code></h3>
<p><code>net_interfaces</code> (aliases <code>net_ifs</code>, <code>ifconfig</code>) — list all network interfaces with name, IPs, MAC, and status.</p>
<pre><code class="lang-perl">my @ifs = net_ifs()
for (@ifs) { p "_->{name}: _->{ipv4}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ipv4">
<h3><a class="doc-anchor" href="#doc-net-ipv4">#</a> <code>net_ipv4</code></h3>
<p><code>net_ipv4</code> (aliases <code>myip</code>, <code>myip4</code>) — return the first non-loopback IPv4 address as a string.</p>
<pre><code class="lang-perl">p myip() # e.g. 192.168.1.42
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ipv6">
<h3><a class="doc-anchor" href="#doc-net-ipv6">#</a> <code>net_ipv6</code></h3>
<p><code>net_ipv6</code> (alias <code>myip6</code>) — return the first non-loopback IPv6 address as a string.</p>
<pre><code class="lang-perl">p myip6() # e.g. fe80::1
</code></pre>
</article>
<article class="doc-entry" id="doc-net-mac">
<h3><a class="doc-anchor" href="#doc-net-mac">#</a> <code>net_mac</code></h3>
<p><code>net_mac</code> (alias <code>mymac</code>) — return the first non-loopback MAC address.</p>
<pre><code class="lang-perl">p mymac() # e.g. aa:bb:cc:dd:ee:ff
</code></pre>
</article>
<article class="doc-entry" id="doc-net-public-ip">
<h3><a class="doc-anchor" href="#doc-net-public-ip">#</a> <code>net_public_ip</code></h3>
<p><code>net_public_ip</code> (aliases <code>pubip</code>, <code>extip</code>) — fetch your public IP address via HTTP.</p>
<pre><code class="lang-perl">p pubip() # e.g. 203.0.113.42
</code></pre>
</article>
<article class="doc-entry" id="doc-net-dns">
<h3><a class="doc-anchor" href="#doc-net-dns">#</a> <code>net_dns</code></h3>
<p><code>net_dns</code> (aliases <code>dns_resolve</code>, <code>resolve</code>) — resolve a hostname to IP addresses.</p>
<pre><code class="lang-perl">my @ips = resolve("github.com")
p @ips
</code></pre>
</article>
<article class="doc-entry" id="doc-net-reverse-dns">
<h3><a class="doc-anchor" href="#doc-net-reverse-dns">#</a> <code>net_reverse_dns</code></h3>
<p><code>net_reverse_dns</code> (alias <code>rdns</code>) — reverse DNS lookup via UDP PTR query.</p>
<pre><code class="lang-perl">p rdns("8.8.8.8") # dns.google
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ping">
<h3><a class="doc-anchor" href="#doc-net-ping">#</a> <code>net_ping</code></h3>
<p><code>net_ping</code> (alias <code>ping</code>) — TCP connect ping to host:port. Returns array of RTT measurements in ms.</p>
<pre><code class="lang-perl">my @rtt = ping("google.com", 443, 5) # 5 pings
p mean(@rtt)
</code></pre>
</article>
<article class="doc-entry" id="doc-net-port-open">
<h3><a class="doc-anchor" href="#doc-net-port-open">#</a> <code>net_port_open</code></h3>
<p><code>net_port_open</code> (alias <code>port_open</code>) — check if a TCP port is open on a host. Returns boolean.</p>
<pre><code class="lang-perl">p port_open("localhost", 8080) # 1 or 0
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ports-scan">
<h3><a class="doc-anchor" href="#doc-net-ports-scan">#</a> <code>net_ports_scan</code></h3>
<p><code>net_ports_scan</code> (aliases <code>port_scan</code>, <code>portscan</code>) — scan a range of TCP ports on a host. Returns list of open ports.</p>
<pre><code class="lang-perl">my @open = port_scan("localhost", 80, 443)
p @open # e.g. 80, 443
</code></pre>
</article>
<article class="doc-entry" id="doc-net-latency">
<h3><a class="doc-anchor" href="#doc-net-latency">#</a> <code>net_latency</code></h3>
<p><code>net_latency</code> (alias <code>tcplat</code>) — measure TCP connect latency to host:port in milliseconds.</p>
<pre><code class="lang-perl">p tcplat("google.com", 443) # e.g. 12.5
</code></pre>
</article>
<article class="doc-entry" id="doc-net-download">
<h3><a class="doc-anchor" href="#doc-net-download">#</a> <code>net_download</code></h3>
<p><code>net_download</code> (aliases <code>download</code>, <code>wget</code>) — download a URL to a local file via ureq.</p>
<pre><code class="lang-perl">wget("https://example.com/data.csv", "data.csv")
</code></pre>
</article>
<article class="doc-entry" id="doc-net-headers">
<h3><a class="doc-anchor" href="#doc-net-headers">#</a> <code>net_headers</code></h3>
<p><code>net_headers</code> (alias <code>http_headers</code>) — fetch HTTP response headers as a hashref.</p>
<pre><code class="lang-perl">my $h = http_headers("https://example.com")
p $h->{"content-type"}
</code></pre>
</article>
<article class="doc-entry" id="doc-net-dns-servers">
<h3><a class="doc-anchor" href="#doc-net-dns-servers">#</a> <code>net_dns_servers</code></h3>
<p><code>net_dns_servers</code> (alias <code>dns_servers</code>) — return the system's configured DNS server addresses.</p>
<pre><code class="lang-perl">my @dns = dns_servers()
p @dns # e.g. 8.8.8.8, 8.8.4.4
</code></pre>
</article>
<article class="doc-entry" id="doc-net-gateway">
<h3><a class="doc-anchor" href="#doc-net-gateway">#</a> <code>net_gateway</code></h3>
<p><code>net_gateway</code> (alias <code>gateway</code>) — return the default gateway IP address.</p>
<pre><code class="lang-perl">p gateway() # e.g. 192.168.1.1
</code></pre>
</article>
<article class="doc-entry" id="doc-net-whois">
<h3><a class="doc-anchor" href="#doc-net-whois">#</a> <code>net_whois</code></h3>
<p><code>net_whois</code> (alias <code>whois</code>) — WHOIS lookup via raw TCP connection on port 43.</p>
<pre><code class="lang-perl">p whois("example.com")
</code></pre>
</article>
<article class="doc-entry" id="doc-net-hostname">
<h3><a class="doc-anchor" href="#doc-net-hostname">#</a> <code>net_hostname</code></h3>
<p><code>net_hostname</code> — return the system hostname.</p>
<pre><code class="lang-perl">p net_hostname() # e.g. my-macbook.local
</code></pre>
</article>
<article class="doc-entry" id="doc-smtp-send">
<h3><a class="doc-anchor" href="#doc-smtp-send">#</a> <code>smtp_send</code></h3>
<p><code>smtp_send</code> (aliases <code>send_email</code>, <code>email</code>) — send an email via SMTP with TLS. Takes a hashref with to, from, subject, body, and SMTP connection fields.</p>
<pre><code class="lang-perl">smtp_send({to => "bob@ex.com", from => "me@ex.com", subject => "Hi",
body => "Hello!", smtp_host => "smtp.ex.com", smtp_port => 587,
smtp_user => "me@ex.com", smtp_pass => $pass})
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-markup-web-scraping">
<h2>Markup / Web Scraping</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-html-parse">
<h3><a class="doc-anchor" href="#doc-html-parse">#</a> <code>html_parse</code></h3>
<p><code>html_parse</code> (alias <code>parse_html</code>) — parse an HTML string into an array of element hashrefs with tag, text, and attrs.</p>
<pre><code class="lang-perl">my @els = html_parse(slurp("page.html"))
for (@els) { p "_->{tag}: _->{text}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-css-select">
<h3><a class="doc-anchor" href="#doc-css-select">#</a> <code>css_select</code></h3>
<p><code>css_select</code> (aliases <code>css</code>, <code>qs</code>, <code>query_selector</code>) — query parsed HTML with a CSS selector. Returns matching elements as hashrefs with tag, text, attrs, and html.</p>
<pre><code class="lang-perl">my @links = css_select(slurp("page.html"), "a.nav")
for (@links) { p "_->{tag} _->{attrs}{href}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-xml-parse">
<h3><a class="doc-anchor" href="#doc-xml-parse">#</a> <code>xml_parse</code></h3>
<p><code>xml_parse</code> (alias <code>parse_xml</code>) — parse an XML string into a nested hashref tree with tag, text, attrs, and children.</p>
<pre><code class="lang-perl">my $root = xml_parse(slurp("data.xml"))
p $root->{tag}
for (@{$root->{children}}) { p _->{text} }
</code></pre>
</article>
<article class="doc-entry" id="doc-xpath">
<h3><a class="doc-anchor" href="#doc-xpath">#</a> <code>xpath</code></h3>
<p><code>xpath</code> (alias <code>xml_select</code>) — query XML with XPath-like expressions (//tag, //tag[@attr='val']). Returns matching nodes as hashrefs.</p>
<pre><code class="lang-perl">my @items = xpath(slurp("feed.xml"), "//item")
for (@items) { p _->{text} }
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-date-utilities">
<h2>Date Utilities</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-dateseq">
<h3><a class="doc-anchor" href="#doc-dateseq">#</a> <code>dateseq</code></h3>
<p><code>dateseq</code> (alias <code>dseq</code>) — generate a sequence of dates. Args: start, end [, step]. Step defaults to 1 day.</p>
<pre><code class="lang-perl">my @days = dseq("2026-01-01", "2026-01-07")
p @days
</code></pre>
</article>
<article class="doc-entry" id="doc-dategrep">
<h3><a class="doc-anchor" href="#doc-dategrep">#</a> <code>dategrep</code></h3>
<p><code>dategrep</code> (alias <code>dgrep</code>) — filter a list of date strings by a pattern or range.</p>
<pre><code class="lang-perl">my @jan = dgrep("2026-01", @dates)
</code></pre>
</article>
<article class="doc-entry" id="doc-dateround">
<h3><a class="doc-anchor" href="#doc-dateround">#</a> <code>dateround</code></h3>
<p><code>dateround</code> (alias <code>dround</code>) — round date strings to a unit (day, hour, month, etc.).</p>
<pre><code class="lang-perl">p dround("2026-04-19T14:35:22", "hour") # 2026-04-19T15:00:00
</code></pre>
</article>
<article class="doc-entry" id="doc-datesort">
<h3><a class="doc-anchor" href="#doc-datesort">#</a> <code>datesort</code></h3>
<p><code>datesort</code> (alias <code>dsort</code>) — sort date strings chronologically.</p>
<pre><code class="lang-perl">my @sorted = dsort("2026-03-01", "2026-01-15", "2026-02-10")
p @sorted
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-git">
<h2>Git</h2>
<p class="chapter-meta">10 topics</p>
<article class="doc-entry" id="doc-git-log">
<h3><a class="doc-anchor" href="#doc-git-log">#</a> <code>git_log</code></h3>
<p><code>git_log</code> (alias <code>glog</code>) — get the last N commits as an array of hashrefs (hash, author, date, message).</p>
<pre><code class="lang-perl">my @commits = glog(10)
for (@commits) { p "_->{hash} _->{message}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-git-status">
<h3><a class="doc-anchor" href="#doc-git-status">#</a> <code>git_status</code></h3>
<p><code>git_status</code> (alias <code>gst</code>) — get working tree status as an array of hashrefs (path, status).</p>
<pre><code class="lang-perl">my @st = gst()
for (@st) { p "_->{status} _->{path}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-git-diff">
<h3><a class="doc-anchor" href="#doc-git-diff">#</a> <code>git_diff</code></h3>
<p><code>git_diff</code> (alias <code>gdiff</code>) — get the current diff as a string.</p>
<pre><code class="lang-perl">p gdiff()
gdiff() |> lines |> grep /^\+/ |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-git-branches">
<h3><a class="doc-anchor" href="#doc-git-branches">#</a> <code>git_branches</code></h3>
<p><code>git_branches</code> (alias <code>gbr</code>) — list all branches as an array of strings.</p>
<pre><code class="lang-perl">my @br = gbr()
p @br
</code></pre>
</article>
<article class="doc-entry" id="doc-git-tags">
<h3><a class="doc-anchor" href="#doc-git-tags">#</a> <code>git_tags</code></h3>
<p><code>git_tags</code> (alias <code>gtags</code>) — list all tags as an array of strings.</p>
<pre><code class="lang-perl">my @tags = gtags()
p @tags
</code></pre>
</article>
<article class="doc-entry" id="doc-git-blame">
<h3><a class="doc-anchor" href="#doc-git-blame">#</a> <code>git_blame</code></h3>
<p><code>git_blame</code> (alias <code>gblame</code>) — blame a file, returning per-line annotation.</p>
<pre><code class="lang-perl">p gblame("src/main.rs")
</code></pre>
</article>
<article class="doc-entry" id="doc-git-authors">
<h3><a class="doc-anchor" href="#doc-git-authors">#</a> <code>git_authors</code></h3>
<p><code>git_authors</code> (alias <code>gauthors</code>) — list unique authors sorted by commit count as hashrefs.</p>
<pre><code class="lang-perl">my @authors = gauthors()
for (@authors) { p "_->{name}: _->{count}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-git-files">
<h3><a class="doc-anchor" href="#doc-git-files">#</a> <code>git_files</code></h3>
<p><code>git_files</code> (alias <code>gfiles</code>) — list all tracked files in the repo.</p>
<pre><code class="lang-perl">my @files = gfiles()
p scalar @files # total tracked files
</code></pre>
</article>
<article class="doc-entry" id="doc-git-show">
<h3><a class="doc-anchor" href="#doc-git-show">#</a> <code>git_show</code></h3>
<p><code>git_show</code> (alias <code>gshow</code>) — show details of a commit (message, diff, author).</p>
<pre><code class="lang-perl">p gshow("HEAD")
p gshow("abc1234")
</code></pre>
</article>
<article class="doc-entry" id="doc-git-root">
<h3><a class="doc-anchor" href="#doc-git-root">#</a> <code>git_root</code></h3>
<p><code>git_root</code> (alias <code>groot</code>) — return the repository root path.</p>
<pre><code class="lang-perl">p groot() # e.g. /home/user/project
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-system">
<h2>System</h2>
<p class="chapter-meta">13 topics</p>
<article class="doc-entry" id="doc-mounts">
<h3><a class="doc-anchor" href="#doc-mounts">#</a> <code>mounts</code></h3>
<p><code>mounts</code> (aliases <code>disk_mounts</code>, <code>filesystems</code>) — list mounted filesystems with usage (total, used, available).</p>
<pre><code class="lang-perl">my @m = mounts()
for (@m) { p "_->{mount}: _->{used}/_->{total}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-thread-count">
<h3><a class="doc-anchor" href="#doc-thread-count">#</a> <code>thread_count</code></h3>
<p><code>thread_count</code> (alias <code>nthreads</code>) — return the rayon thread pool size.</p>
<pre><code class="lang-perl">p nthreads() # e.g. 8
</code></pre>
</article>
<article class="doc-entry" id="doc-pool-info">
<h3><a class="doc-anchor" href="#doc-pool-info">#</a> <code>pool_info</code></h3>
<p><code>pool_info</code> (alias <code>par_info</code>) — return thread pool details as a hashref (threads, queued, active).</p>
<pre><code class="lang-perl">my $info = par_info()
p $info->{threads}
</code></pre>
</article>
<article class="doc-entry" id="doc-par-bench">
<h3><a class="doc-anchor" href="#doc-par-bench">#</a> <code>par_bench</code></h3>
<p><code>par_bench</code> (alias <code>pbench</code>) — run a parallel throughput benchmark and return results.</p>
<pre><code class="lang-perl">my $result = pbench(1000000)
p $result->{ops_per_sec}
</code></pre>
</article>
<article class="doc-entry" id="doc-to-pdf">
<h3><a class="doc-anchor" href="#doc-to-pdf">#</a> <code>to_pdf</code></h3>
<p><code>to_pdf</code> — generate a PDF from text, SVG, or structured data. Returns raw PDF bytes.</p>
<pre><code class="lang-perl">"Hello World" |> to_pdf |> to_file("out.pdf")
scatter_svg([1,2,3], [1,4,9]) |> to_pdf |> to_file("plot.pdf")
</code></pre>
</article>
<article class="doc-entry" id="doc-pdf-text">
<h3><a class="doc-anchor" href="#doc-pdf-text">#</a> <code>pdf_text</code></h3>
<p><code>pdf_text</code> (aliases <code>pdf_read</code>, <code>pdf_extract</code>) — extract all text content from a PDF file and return it as a string.</p>
<pre><code class="lang-perl">my $text = pdf_text("report.pdf")
p $text |> lines |> cnt # number of lines
</code></pre>
</article>
<article class="doc-entry" id="doc-pdf-pages">
<h3><a class="doc-anchor" href="#doc-pdf-pages">#</a> <code>pdf_pages</code></h3>
<p><code>pdf_pages</code> — return the number of pages in a PDF file.</p>
<pre><code class="lang-perl">p pdf_pages("report.pdf") # e.g. 42
</code></pre>
</article>
<article class="doc-entry" id="doc-jq">
<h3><a class="doc-anchor" href="#doc-jq">#</a> <code>jq</code></h3>
<p><code>jq</code> — alias for <code>json_jq</code>. Query JSON data with jq-style expressions.</p>
<pre><code class="lang-perl">my $data = json_decode(slurp("data.json"))
p jq($data, ".items[].name")
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-cpu">
<h3><a class="doc-anchor" href="#doc-stress-cpu">#</a> <code>stress_cpu</code></h3>
<p><code>stress_cpu</code> (alias <code>scpu</code>) — CPU stress test: run SHA256 hashing in a tight loop for the specified duration (default 1 second). Returns number of hashes computed. Use for load testing and thermal validation.</p>
<pre><code class="lang-perl">my $hashes = stress_cpu(10) # 10 seconds of CPU stress
p "Computed $hashes hashes"
# Distributed across cluster
my $c = cluster(["node1:8", "node2:8"])
1:16 |> pmap_on $c { stress_cpu(60) } # 60s stress on all workers
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-mem">
<h3><a class="doc-anchor" href="#doc-stress-mem">#</a> <code>stress_mem</code></h3>
<p><code>stress_mem</code> (alias <code>smem</code>) — Memory stress test: allocate and touch the specified number of bytes (default 100MB). Returns bytes allocated. Use for memory pressure testing and OOM validation.</p>
<pre><code class="lang-perl">my $bytes = stress_mem(1e9) # Allocate 1GB
p "Allocated $bytes bytes"
# Memory pressure across cluster
1:16 |> pmap_on $cluster { stress_mem(4e9) } # 4GB per worker
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-io">
<h3><a class="doc-anchor" href="#doc-stress-io">#</a> <code>stress_io</code></h3>
<p><code>stress_io</code> (alias <code>sio</code>) — IO stress test: write and read temp files in the specified directory (default /tmp) for N iterations (default 100). Returns total bytes written. Use for storage IOPS testing.</p>
<pre><code class="lang-perl">my $bytes = stress_io("/tmp", 1000) # 1000 iterations
p "Wrote $bytes bytes"
# IO stress across cluster
1:16 |> pmap_on $cluster { stress_io("/data", 500) }
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-test">
<h3><a class="doc-anchor" href="#doc-stress-test">#</a> <code>stress_test</code></h3>
<p><code>stress_test</code> (alias <code>st</code>) — Combined CPU/memory/IO stress test. If cluster provided, distributes across all workers. Returns hashref with stats: {cpu_hashes, mem_bytes, io_bytes, workers, duration}.</p>
<pre><code class="lang-perl"># Local stress test (10 seconds)
my $r = stress_test(10)
p "CPU: $r->{cpu_hashes}, Workers: $r->{workers}"
# Distributed stress test
my $c = cluster(["node1:8", "node2:8", "node3:8"])
my $r = stress_test($c, 60) # 60s across 24 workers
p "Hashes: $r->{cpu_hashes}, Duration: $r->{duration}s"
</code></pre>
</article>
<article class="doc-entry" id="doc-heat">
<h3><a class="doc-anchor" href="#doc-heat">#</a> <code>heat</code></h3>
<p><code>heat</code> — Maximum thermal stress. Pins ALL cores to 100% TDP. The hottest function in any programming language. Use for infrastructure burn-in, cooling validation, and power testing.</p>
<pre><code class="lang-perl">heat(60) # 60 seconds of maximum heat
heat() # default 60 seconds
# Output:
# 🔥 HEAT: Pinning N cores to 100% TDP for 60s
# 🔥 HEAT: 3,116,320,000 hashes in 60.00s (51.9M/s across N cores)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-testing">
<h2>Testing</h2>
<p class="chapter-meta">15 topics</p>
<article class="doc-entry" id="doc-assert-eq">
<h3><a class="doc-anchor" href="#doc-assert-eq">#</a> <code>assert_eq</code></h3>
<p><code>assert_eq</code> (alias <code>aeq</code>) — assert that two values are equal as strings. Takes A, B, and an optional message. Fails the test with a diff if A ne B.</p>
<pre><code class="lang-perl">assert_eq $got, $expected, "username matches"
aeq length(@arr), 3
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-ne">
<h3><a class="doc-anchor" href="#doc-assert-ne">#</a> <code>assert_ne</code></h3>
<p><code>assert_ne</code> (alias <code>ane</code>) — assert that two values are not equal as strings. Takes A, B, and an optional message. Fails if A eq B.</p>
<pre><code class="lang-perl">assert_ne $token, "", "token must not be empty"
ane $a, $b
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-ok">
<h3><a class="doc-anchor" href="#doc-assert-ok">#</a> <code>assert_ok</code></h3>
<p><code>assert_ok</code> (alias <code>aok</code>) — assert that a value is truthy (defined and non-zero/non-empty). Fails if the value is falsy or undef.</p>
<pre><code class="lang-perl">assert_ok $result, "fetch returned data"
aok $user->{active}
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-err">
<h3><a class="doc-anchor" href="#doc-assert-err">#</a> <code>assert_err</code></h3>
<p><code>assert_err</code> — assert that a value is falsy or undef. The inverse of <code>assert_ok</code>. Useful for verifying error conditions or absent values.</p>
<pre><code class="lang-perl">assert_err $deleted_user, "user should be gone"
assert_err 0
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-true">
<h3><a class="doc-anchor" href="#doc-assert-true">#</a> <code>assert_true</code></h3>
<p><code>assert_true</code> (alias <code>atrue</code>) — alias for <code>assert_ok</code>. Assert that a value is truthy.</p>
<pre><code class="lang-perl">assert_true $connected, "should be connected"
atrue $flag
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-false">
<h3><a class="doc-anchor" href="#doc-assert-false">#</a> <code>assert_false</code></h3>
<p><code>assert_false</code> (alias <code>afalse</code>) — alias for <code>assert_err</code>. Assert that a value is falsy or undef.</p>
<pre><code class="lang-perl">assert_false $error, "no error expected"
afalse $disabled
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-gt">
<h3><a class="doc-anchor" href="#doc-assert-gt">#</a> <code>assert_gt</code></h3>
<p><code>assert_gt</code> — assert that the first numeric value is strictly greater than the second. Fails with the actual values on mismatch.</p>
<pre><code class="lang-perl">assert_gt $elapsed, 0, "elapsed must be positive"
assert_gt scalar(@results), 10
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-lt">
<h3><a class="doc-anchor" href="#doc-assert-lt">#</a> <code>assert_lt</code></h3>
<p><code>assert_lt</code> — assert that the first numeric value is strictly less than the second.</p>
<pre><code class="lang-perl">assert_lt $latency, 100, "latency under 100ms"
assert_lt $errors, $threshold
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-ge">
<h3><a class="doc-anchor" href="#doc-assert-ge">#</a> <code>assert_ge</code></h3>
<p><code>assert_ge</code> — assert that the first numeric value is greater than or equal to the second.</p>
<pre><code class="lang-perl">assert_ge $count, 1, "at least one result"
assert_ge $version, 2
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-le">
<h3><a class="doc-anchor" href="#doc-assert-le">#</a> <code>assert_le</code></h3>
<p><code>assert_le</code> — assert that the first numeric value is less than or equal to the second.</p>
<pre><code class="lang-perl">assert_le $memory, $limit, "within memory budget"
assert_le length($buf), 4096
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-match">
<h3><a class="doc-anchor" href="#doc-assert-match">#</a> <code>assert_match</code></h3>
<p><code>assert_match</code> (alias <code>amatch</code>) — assert that a string matches a regex pattern. Fails with the actual string and pattern on mismatch.</p>
<pre><code class="lang-perl">assert_match $email, qr/\@/, "must contain @"
amatch $line, qr/^OK/
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-contains">
<h3><a class="doc-anchor" href="#doc-assert-contains">#</a> <code>assert_contains</code></h3>
<p><code>assert_contains</code> (alias <code>acontains</code>) — assert that a string contains a given substring. Fails with both values on mismatch.</p>
<pre><code class="lang-perl">assert_contains $html, "<title>", "page has title"
acontains $log, "SUCCESS"
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-near">
<h3><a class="doc-anchor" href="#doc-assert-near">#</a> <code>assert_near</code></h3>
<p><code>assert_near</code> (alias <code>anear</code>) — assert that two floats are approximately equal within an epsilon tolerance (default 1e-9). Essential for floating-point comparisons.</p>
<pre><code class="lang-perl">assert_near 0.1 + 0.2, 0.3, 1e-10, "float add"
anear $pi, 3.14159, 1e-5
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-dies">
<h3><a class="doc-anchor" href="#doc-assert-dies">#</a> <code>assert_dies</code></h3>
<p><code>assert_dies</code> (alias <code>adies</code>) — assert that a block throws an error. Passes if the block dies, fails if it returns normally.</p>
<pre><code class="lang-perl">assert_dies { die "boom" } "should throw"
adies { 1 / 0 }
</code></pre>
</article>
<article class="doc-entry" id="doc-test-run">
<h3><a class="doc-anchor" href="#doc-test-run">#</a> <code>test_run</code></h3>
<p><code>test_run</code> (alias <code>run_tests</code>) — print a test summary with pass/fail counts and exit with code 1 if any test failed. Call at the end of a test file to report results.</p>
<pre><code class="lang-perl"># ... assertions above ...
test_run # prints summary, exits 1 on failure
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-test-runner-worker-pool">
<h2>Test Runner (worker pool)</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-test">
<h3><a class="doc-anchor" href="#doc-test">#</a> <code>test</code></h3>
<p><code>test(FILE_OR_DIR, ...)</code> — run every <code>test_*.stk</code> / <code>t_*.stk</code> under each path through the <strong>worker pool</strong>. Same engine as <code>s t</code> on the CLI: pre-forks N persistent stryke <code>--test-worker</code> processes, dispatches paths via JSON over stdin/stdout, each worker <code>fork()</code>s a grandchild per test for full isolation, no per-test dyld cost. Returns the exit code (0 on all-pass, 1 on any failure). Optional trailing hashref selects mode: <code>{ fork => 1 }</code> for the legacy <code>posix_spawn</code>-per-test path, <code>{ inproc => 1 }</code> for single-process VM-per-test (fastest, hermetic only), <code>{ quiet => 1 }</code>, <code>{ no_interop => 1 }</code>.</p>
<pre><code class="lang-perl">test("t/") # default: worker pool
test(["t/", "examples/"], { quiet => 1 })
test("t/test_foo.stk", { fork => 1 }) # opt back into per-test fork
my $rc = test(@dirs) # array flattens; rc = 0/1
</code></pre>
</article>
<article class="doc-entry" id="doc-test-no-interop">
<h3><a class="doc-anchor" href="#doc-test-no-interop">#</a> <code>test_no_interop</code></h3>
<p><code>test_no_interop(FILE_OR_DIR, ...)</code> (alias <code>test_ni</code>) — same as <code>test</code>, but pins each worker thread's TLS no-interop flag for the duration of the test (<code>set_no_interop_mode_tls</code>). Sibling <code>pmaps</code> workers don't race on a shared atomic. Forwards <code>--no-interop</code> to every spawned grandchild so each test runs under stryke's bot-firewall mode (rejects Perl-isms, forces stryke idioms).</p>
<pre><code class="lang-perl">test_no_interop("t/")
test_ni(["t/a", "t/b"], { quiet => 1 })
</code></pre>
</article>
<article class="doc-entry" id="doc-check">
<h3><a class="doc-anchor" href="#doc-check">#</a> <code>check</code></h3>
<p><code>check(FILE, ...)</code> — in-process equivalent of <code>stryke check FILE...</code>. Parses, compiles, and lints each path without executing it. Returns the exit code (0 on success, 1 on errors). Optional trailing hashref: <code>{ quiet => 1 }</code>, <code>{ json => 1 }</code>, <code>{ no_interop => 1 }</code>.</p>
<p>Faster than <code>system "stryke check $f"</code> because it skips the binary fork and reuses the parent process's parser/compiler. The lint pass is <strong>not</strong> a strict-vars enforcer — undefined-variable errors only fire on files that themselves do <code>use strict;</code>.</p>
<pre><code class="lang-perl">my $rc = check("foo.stk") # 0 = ok, 1 = errors
check(\@files, { quiet => 1 }) # arrayref + opts
for my $f (glob("src/*.stk")) { check($f) or warn "$f failed" }
</code></pre>
</article>
<article class="doc-entry" id="doc-check-no-interop">
<h3><a class="doc-anchor" href="#doc-check-no-interop">#</a> <code>check_no_interop</code></h3>
<p><code>check_no_interop(FILE, ...)</code> (alias <code>check_ni</code>) — same as <code>check</code>, but pins <strong>this thread</strong> to <code>--no-interop</code> for the duration of the check via an RAII guard on the per-thread no-interop flag. Sibling threads are unaffected, so the builtin is safe to call from <code>pmaps</code> workers in parallel — no global-atomic race.</p>
<pre><code class="lang-perl">check_no_interop("foo.stk") # rejects sub/say/$a/$b
pmaps { check_ni(_, { quiet => 1 }) } @files # parallel-safe, no race
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-ai-primitives-docs-ai-primitives-md">
<h2>AI primitives (docs/AI_PRIMITIVES.md)</h2>
<p class="chapter-meta">79 topics</p>
<article class="doc-entry" id="doc-ai">
<h3><a class="doc-anchor" href="#doc-ai">#</a> <code>ai</code></h3>
<p><code>ai $prompt, opts...</code> — single-shot LLM call (or auto-routes to the agent loop when <code>tools => [...]</code>/<code>tool fn</code>s are in scope, vision when <code>image => $url|$path</code>, structured output when <code>schema => +{...}</code>, document input when <code>pdf => $path</code>).</p>
<pre><code class="lang-perl">my $r = ai "summarize this", $document
my $r = ai "weather in SF" # auto-uses any `tool fn` defined in scope
my $r = ai "describe", image => "/photo.jpg"
my $r = ai "extract user", schema => +{ name => "string", age => "int" }
</code></pre>
<p>Providers: anthropic (default), openai. Mock with <code>ai_mock_install</code>. Cost via <code>ai_cost</code>.</p>
</article>
<article class="doc-entry" id="doc-stream-prompt">
<h3><a class="doc-anchor" href="#doc-stream-prompt">#</a> <code>stream_prompt</code></h3>
<p><code>stream_prompt $prompt, on_chunk => sub { ... }</code> — Anthropic SSE streaming. With <code>on_chunk</code>, fires once per text-delta. Without, returns a <code>PerlIterator</code>-backed handle: <code>for my $chunk in stream_prompt("...") { print $chunk }</code>.</p>
<pre><code class="lang-perl">my $state = +{ buf => "" };
stream_prompt("write a haiku",
on_chunk => sub { $state->{buf} .= $_[0]; print $_[0] });
</code></pre>
</article>
<article class="doc-entry" id="doc-chat">
<h3><a class="doc-anchor" href="#doc-chat">#</a> <code>chat</code></h3>
<p><code>chat \@messages, opts...</code> — explicit message-list call. Each entry is <code>+{role => "user"|"assistant"|"system", content => ...}</code>.</p>
<pre><code class="lang-perl">chat([
+{ role => "system", content => "Be concise" },
+{ role => "user", content => "hi" },
])
</code></pre>
<p>For multi-turn with auto-tracking, use <code>ai_session_*</code> instead.</p>
</article>
<article class="doc-entry" id="doc-embed">
<h3><a class="doc-anchor" href="#doc-embed">#</a> <code>embed</code></h3>
<p><code>embed $text</code> or <code>embed \@texts</code> — vector embedding via Voyage AI (default) or OpenAI. Returns arrayref of floats (single text) or arrayref-of-arrayref (batch). Routes via <code>ai_routing_set("embed", ...)</code>.</p>
<pre><code class="lang-perl">my @vec = @{ embed("hello world") }
my @vecs = @{ embed(["a", "b", "c"]) }
</code></pre>
</article>
<article class="doc-entry" id="doc-tokens-of">
<h3><a class="doc-anchor" href="#doc-tokens-of">#</a> <code>tokens_of</code></h3>
<p><code>tokens_of</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = tokens_of $x
# or in a pipeline:
@list |> map tokens_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-estimate">
<h3><a class="doc-anchor" href="#doc-ai-estimate">#</a> <code>ai_estimate</code></h3>
<p><code>ai_estimate</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_estimate $x
# or in a pipeline:
@list |> map ai_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-cost">
<h3><a class="doc-anchor" href="#doc-ai-cost">#</a> <code>ai_cost</code></h3>
<p><code>ai_cost()</code> — running spend / token / cache stats hashref: <code>+{usd, input_tokens, output_tokens, embed_tokens, cache_creation_tokens, cache_read_tokens, cache_hits, cache_misses}</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-history">
<h3><a class="doc-anchor" href="#doc-ai-history">#</a> <code>ai_history</code></h3>
<p><code>ai_history</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_history $x
# or in a pipeline:
@list |> map ai_history |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-history-clear">
<h3><a class="doc-anchor" href="#doc-ai-history-clear">#</a> <code>ai_history_clear</code></h3>
<p><code>ai_history_clear</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_history_clear $x
# or in a pipeline:
@list |> map ai_history_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-cache-clear">
<h3><a class="doc-anchor" href="#doc-ai-cache-clear">#</a> <code>ai_cache_clear</code></h3>
<p><code>ai_cache_clear</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_cache_clear $x
# or in a pipeline:
@list |> map ai_cache_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-cache-size">
<h3><a class="doc-anchor" href="#doc-ai-cache-size">#</a> <code>ai_cache_size</code></h3>
<p><code>ai_cache_size</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_cache_size $x
# or in a pipeline:
@list |> map ai_cache_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-mock-install">
<h3><a class="doc-anchor" href="#doc-ai-mock-install">#</a> <code>ai_mock_install</code></h3>
<p><code>ai_mock_install</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_mock_install $x
# or in a pipeline:
@list |> map ai_mock_install |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-mock-clear">
<h3><a class="doc-anchor" href="#doc-ai-mock-clear">#</a> <code>ai_mock_clear</code></h3>
<p><code>ai_mock_clear</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_mock_clear $x
# or in a pipeline:
@list |> map ai_mock_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-config-get">
<h3><a class="doc-anchor" href="#doc-ai-config-get">#</a> <code>ai_config_get</code></h3>
<p><code>ai_config_get</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_config_get $x
# or in a pipeline:
@list |> map ai_config_get |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-config-set">
<h3><a class="doc-anchor" href="#doc-ai-config-set">#</a> <code>ai_config_set</code></h3>
<p><code>ai_config_set</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_config_set $x
# or in a pipeline:
@list |> map ai_config_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-routing-get">
<h3><a class="doc-anchor" href="#doc-ai-routing-get">#</a> <code>ai_routing_get</code></h3>
<p><code>ai_routing_get</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_routing_get $x
# or in a pipeline:
@list |> map ai_routing_get |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-routing-set">
<h3><a class="doc-anchor" href="#doc-ai-routing-set">#</a> <code>ai_routing_set</code></h3>
<p><code>ai_routing_set</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_routing_set $x
# or in a pipeline:
@list |> map ai_routing_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-register-tool">
<h3><a class="doc-anchor" href="#doc-ai-register-tool">#</a> <code>ai_register_tool</code></h3>
<p><code>ai_register_tool($name, $description, +{params}, sub { ... })</code> — register a tool that the bare <code>ai($prompt)</code> call auto-attaches to its agent loop. Idempotent re-register on same name.</p>
<pre><code class="lang-perl">ai_register_tool("weather", "Get weather",
+{ city => "string" },
sub { fetch "https://api.weather.com/" . uri_encode($_[0]->{city}) });
ai_clear_tools();
</code></pre>
<p>For parser-level sugar, use <code>tool fn</code> instead.</p>
</article>
<article class="doc-entry" id="doc-ai-unregister-tool">
<h3><a class="doc-anchor" href="#doc-ai-unregister-tool">#</a> <code>ai_unregister_tool</code></h3>
<p><code>ai_unregister_tool</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_unregister_tool $x
# or in a pipeline:
@list |> map ai_unregister_tool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-clear-tools">
<h3><a class="doc-anchor" href="#doc-ai-clear-tools">#</a> <code>ai_clear_tools</code></h3>
<p><code>ai_clear_tools</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_clear_tools $x
# or in a pipeline:
@list |> map ai_clear_tools |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-tools-list">
<h3><a class="doc-anchor" href="#doc-ai-tools-list">#</a> <code>ai_tools_list</code></h3>
<p><code>ai_tools_list</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_tools_list $x
# or in a pipeline:
@list |> map ai_tools_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-filter">
<h3><a class="doc-anchor" href="#doc-ai-filter">#</a> <code>ai_filter</code></h3>
<p><code>ai_filter \@items, "criterion"</code> — keep items the model judges as matching the criterion. Single batched LLM call; cheap by construction.</p>
</article>
<article class="doc-entry" id="doc-ai-map">
<h3><a class="doc-anchor" href="#doc-ai-map">#</a> <code>ai_map</code></h3>
<p><code>ai_map \@items, "instruction"</code> — apply instruction to each item, single batched LLM call. Returns arrayref of strings.</p>
</article>
<article class="doc-entry" id="doc-ai-classify">
<h3><a class="doc-anchor" href="#doc-ai-classify">#</a> <code>ai_classify</code></h3>
<p><code>ai_classify \@items, "hint", into => ["a", "b", "c"]</code> — assign one of the labels to each item.</p>
</article>
<article class="doc-entry" id="doc-ai-match">
<h3><a class="doc-anchor" href="#doc-ai-match">#</a> <code>ai_match</code></h3>
<p><code>ai_match</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_match $x
# or in a pipeline:
@list |> map ai_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-sort">
<h3><a class="doc-anchor" href="#doc-ai-sort">#</a> <code>ai_sort</code></h3>
<p><code>ai_sort</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_sort $x
# or in a pipeline:
@list |> map ai_sort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-dedupe">
<h3><a class="doc-anchor" href="#doc-ai-dedupe">#</a> <code>ai_dedupe</code></h3>
<p><code>ai_dedupe</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_dedupe $x
# or in a pipeline:
@list |> map ai_dedupe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-extract">
<h3><a class="doc-anchor" href="#doc-ai-extract">#</a> <code>ai_extract</code></h3>
<p><code>ai_extract "prompt", schema => +{ name => "string", age => "int" }</code> — structured JSON output; returns a typed hashref.</p>
</article>
<article class="doc-entry" id="doc-ai-summarize">
<h3><a class="doc-anchor" href="#doc-ai-summarize">#</a> <code>ai_summarize</code></h3>
<p><code>ai_summarize $text, words => 50</code> — convenience wrapper that asks the model for a concise summary at target length.</p>
</article>
<article class="doc-entry" id="doc-ai-translate">
<h3><a class="doc-anchor" href="#doc-ai-translate">#</a> <code>ai_translate</code></h3>
<p><code>ai_translate $text, to => "Spanish"</code> — convenience wrapper for translation.</p>
</article>
<article class="doc-entry" id="doc-ai-template">
<h3><a class="doc-anchor" href="#doc-ai-template">#</a> <code>ai_template</code></h3>
<p><code>ai_template "hi {name}", name => "world"</code> — pure string substitution. <code>{{</code> escapes to a literal <code>{</code>. Missing keys pass through unchanged.</p>
</article>
<article class="doc-entry" id="doc-ai-transcribe">
<h3><a class="doc-anchor" href="#doc-ai-transcribe">#</a> <code>ai_transcribe</code></h3>
<p><code>ai_transcribe "audio.mp3", model => "whisper-1", language => "en"</code> — OpenAI Whisper transcription. Multipart upload to <code>/v1/audio/transcriptions</code>. Returns the transcript string. Defaults to <code>whisper-1</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-speak">
<h3><a class="doc-anchor" href="#doc-ai-speak">#</a> <code>ai_speak</code></h3>
<p><code>ai_speak $text, voice => "alloy", model => "tts-1", format => "mp3", output => "out.mp3"</code> — OpenAI TTS. Returns raw audio bytes; pass <code>output =></code> to also write to disk. Voices: alloy, echo, fable, onyx, nova, shimmer.</p>
</article>
<article class="doc-entry" id="doc-ai-image">
<h3><a class="doc-anchor" href="#doc-ai-image">#</a> <code>ai_image</code></h3>
<p><code>ai_image $prompt, model => "dall-e-3", size => "1024x1024", quality => "hd", output => "out.png", n => 1</code> — image generation (OpenAI Images). Returns raw PNG bytes for n=1, or arrayref of bytes for n>1. Models: <code>dall-e-3</code>, <code>gpt-image-1</code>. <code>output</code> writes to disk (with <code>_1</code>/<code>_2</code>/... suffix for n>1).</p>
</article>
<article class="doc-entry" id="doc-ai-image-edit">
<h3><a class="doc-anchor" href="#doc-ai-image-edit">#</a> <code>ai_image_edit</code></h3>
<p><code>ai_image_edit $prompt, image => "in.png", mask => "mask.png", output => "out.png"</code> — image-to-image edit via OpenAI <code>/v1/images/edits</code>. Optional mask is a PNG with transparent regions marking where to edit. Returns PNG bytes (or arrayref for <code>n>1</code>).</p>
</article>
<article class="doc-entry" id="doc-ai-image-variation">
<h3><a class="doc-anchor" href="#doc-ai-image-variation">#</a> <code>ai_image_variation</code></h3>
<p><code>ai_image_variation image => "in.png", n => 4, size => "1024x1024"</code> — generate variations of an existing image (OpenAI <code>/v1/images/variations</code>, DALL-E 2). Returns PNG bytes for <code>n=1</code> or arrayref for <code>n>1</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-models">
<h3><a class="doc-anchor" href="#doc-ai-models">#</a> <code>ai_models</code></h3>
<p><code>ai_models($provider)</code> → arrayref of model IDs from the live catalog. Providers: <code>openai</code>, <code>anthropic</code>, <code>ollama</code>, <code>gemini</code>. Useful for tooling that surfaces the available models without hardcoding lists.</p>
</article>
<article class="doc-entry" id="doc-ai-citations">
<h3><a class="doc-anchor" href="#doc-ai-citations">#</a> <code>ai_citations</code></h3>
<p><code>ai_citations()</code> — arrayref of citations from the most recent Anthropic call (when <code>citations => 1</code> was passed). Each entry is a hashref with <code>text</code> (cited string), <code>title</code>, <code>start</code>/<code>end</code> char offsets or <code>start_page</code>/<code>end_page</code> page numbers, and <code>document_index</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-dashboard">
<h3><a class="doc-anchor" href="#doc-ai-dashboard">#</a> <code>ai_dashboard</code></h3>
<p><code>ai_dashboard()</code> → ANSI-colored multi-line summary (cost, tokens in/out, embed tokens, prompt-cache write/read, result-cache hit ratio). Drop at the end of a script or during a session: <code>print ai_dashboard()</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-pricing">
<h3><a class="doc-anchor" href="#doc-ai-pricing">#</a> <code>ai_pricing</code></h3>
<p><code>ai_pricing("claude-opus-4-7")</code> → hashref <code>+{ model, input, output, input_per_1m, output_per_1m }</code> with the per-1K-token pricing the runtime uses for cost tracking. Useful for pre-flight cost estimates.</p>
</article>
<article class="doc-entry" id="doc-ai-describe">
<h3><a class="doc-anchor" href="#doc-ai-describe">#</a> <code>ai_describe</code></h3>
<p><code>ai_describe("image.png", style => "concise")</code> — vision wrapper that asks the model to describe an image. Styles: <code>concise</code> (one sentence), <code>detailed</code> (paragraph), <code>alt</code> (HTML alt-text ≤125 chars), or any custom suffix.</p>
</article>
<article class="doc-entry" id="doc-ai-grounded">
<h3><a class="doc-anchor" href="#doc-ai-grounded">#</a> <code>ai_grounded</code></h3>
<p><code>ai_grounded($prompt, documents => [@paths_or_strings], titles => [@titles])</code> — Anthropic-only multi-document grounding. Each entry can be a PDF path, a text-file path, or an inline string. Citations are auto-enabled; retrieve via <code>ai_citations()</code> after the call.</p>
</article>
<article class="doc-entry" id="doc-ai-moderate">
<h3><a class="doc-anchor" href="#doc-ai-moderate">#</a> <code>ai_moderate</code></h3>
<p><code>ai_moderate($text, model => "omni-moderation-latest")</code> → <code>+{ flagged, categories, scores }</code>. OpenAI content-safety classifier. Free endpoint — no token cost. Use it before sending user-generated content to a generative model.</p>
</article>
<article class="doc-entry" id="doc-ai-chunk">
<h3><a class="doc-anchor" href="#doc-ai-chunk">#</a> <code>ai_chunk</code></h3>
<p><code>ai_chunk($text, max_tokens => 500, overlap => 50, by => "tokens"|"chars"|"sentences")</code> → arrayref of strings. Pure local logic — no API call. Sentence mode splits on <code>.!?</code> and greedily packs.</p>
</article>
<article class="doc-entry" id="doc-ai-warm">
<h3><a class="doc-anchor" href="#doc-ai-warm">#</a> <code>ai_warm</code></h3>
<p><code>ai_warm(model => ..., provider => ...)</code> → <code>+{ ok, latency_ms, error, model, provider }</code>. Sends a 1-token ping so auth/network failures surface at script start instead of mid-flow.</p>
</article>
<article class="doc-entry" id="doc-ai-compare">
<h3><a class="doc-anchor" href="#doc-ai-compare">#</a> <code>ai_compare</code></h3>
<p><code>ai_compare($a, $b, criteria => "factual accuracy", scale => 5)</code> → <code>+{ winner, reason, scores => +{a, b}, raw }</code>. Single-call structured comparison. <code>winner</code> is <code>"a"</code>, <code>"b"</code>, or <code>"tie"</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-session-export">
<h3><a class="doc-anchor" href="#doc-ai-session-export">#</a> <code>ai_session_export</code></h3>
<p><code>ai_session_export($handle)</code> → JSON string capturing system, model, provider, and full message log. Pair with <code>ai_session_import($json)</code> to restore.</p>
</article>
<article class="doc-entry" id="doc-ai-session-import">
<h3><a class="doc-anchor" href="#doc-ai-session-import">#</a> <code>ai_session_import</code></h3>
<p><code>ai_session_import($json)</code> → fresh session handle hashref. Inverse of <code>ai_session_export</code>. Allocates a new id and populates the session from the JSON body.</p>
</article>
<article class="doc-entry" id="doc-ai-file-upload">
<h3><a class="doc-anchor" href="#doc-ai-file-upload">#</a> <code>ai_file_upload</code></h3>
<p><code>ai_file_upload("path", purpose => "user_data")</code> → metadata hashref with <code>id</code>, <code>bytes</code>, <code>filename</code>, <code>purpose</code>, <code>created_at</code>. OpenAI Files API — file_id can be referenced by Whisper/Vision/Batch/Assistants.</p>
</article>
<article class="doc-entry" id="doc-ai-file-list">
<h3><a class="doc-anchor" href="#doc-ai-file-list">#</a> <code>ai_file_list</code></h3>
<p><code>ai_file_list(purpose => "...")</code> → arrayref of file metadata hashrefs from <code>/v1/files</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-file-get">
<h3><a class="doc-anchor" href="#doc-ai-file-get">#</a> <code>ai_file_get</code></h3>
<p><code>ai_file_get($file_id)</code> → metadata hashref for a single file.</p>
</article>
<article class="doc-entry" id="doc-ai-file-delete">
<h3><a class="doc-anchor" href="#doc-ai-file-delete">#</a> <code>ai_file_delete</code></h3>
<p><code>ai_file_delete($file_id)</code> → 1 if deleted, 0 otherwise. Removes the file from OpenAI's storage.</p>
</article>
<article class="doc-entry" id="doc-ai-file-anthropic-upload">
<h3><a class="doc-anchor" href="#doc-ai-file-anthropic-upload">#</a> <code>ai_file_anthropic_upload</code></h3>
<p><code>ai_file_anthropic_upload("path/to/file.pdf")</code> → metadata hashref with <code>id</code>, <code>filename</code>, <code>mime_type</code>, <code>size_bytes</code>, <code>created_at</code>. Anthropic's beta <code>/v1/files</code> endpoint — file_id can be referenced from batch jobs and document blocks.</p>
</article>
<article class="doc-entry" id="doc-ai-file-anthropic-list">
<h3><a class="doc-anchor" href="#doc-ai-file-anthropic-list">#</a> <code>ai_file_anthropic_list</code></h3>
<p><code>ai_file_anthropic_list()</code> → arrayref of file-metadata hashrefs from Anthropic's <code>/v1/files</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-file-anthropic-delete">
<h3><a class="doc-anchor" href="#doc-ai-file-anthropic-delete">#</a> <code>ai_file_anthropic_delete</code></h3>
<p><code>ai_file_anthropic_delete($file_id)</code> → 1 on success, 0 otherwise. Removes the file from Anthropic's storage.</p>
</article>
<article class="doc-entry" id="doc-ai-session-new">
<h3><a class="doc-anchor" href="#doc-ai-session-new">#</a> <code>ai_session_new</code></h3>
<p><code>ai_session_new(system => "...", model => "...")</code> — start a multi-turn chat session. Use <code>ai_session_send($s, "msg")</code> to advance, <code>ai_session_history($s)</code> to inspect, <code>ai_session_close($s)</code> to drop.</p>
</article>
<article class="doc-entry" id="doc-ai-session-send">
<h3><a class="doc-anchor" href="#doc-ai-session-send">#</a> <code>ai_session_send</code></h3>
<p><code>ai_session_send</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_session_send $x
# or in a pipeline:
@list |> map ai_session_send |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-session-history">
<h3><a class="doc-anchor" href="#doc-ai-session-history">#</a> <code>ai_session_history</code></h3>
<p><code>ai_session_history</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_session_history $x
# or in a pipeline:
@list |> map ai_session_history |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-session-close">
<h3><a class="doc-anchor" href="#doc-ai-session-close">#</a> <code>ai_session_close</code></h3>
<p><code>ai_session_close</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_session_close $x
# or in a pipeline:
@list |> map ai_session_close |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-session-reset">
<h3><a class="doc-anchor" href="#doc-ai-session-reset">#</a> <code>ai_session_reset</code></h3>
<p><code>ai_session_reset</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_session_reset $x
# or in a pipeline:
@list |> map ai_session_reset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-memory-save">
<h3><a class="doc-anchor" href="#doc-ai-memory-save">#</a> <code>ai_memory_save</code></h3>
<p><code>ai_memory_save("id", "content", $metadata?, $path?)</code> — embed + persist a doc in the sqlite-backed memory store.</p>
</article>
<article class="doc-entry" id="doc-ai-memory-recall">
<h3><a class="doc-anchor" href="#doc-ai-memory-recall">#</a> <code>ai_memory_recall</code></h3>
<p><code>ai_memory_recall("query", top_k => 5)</code> — re-embed query, return top-k matches by cosine similarity. Each entry: <code>+{id, content, score, metadata}</code>.</p>
</article>
<article class="doc-entry" id="doc-ai-memory-forget">
<h3><a class="doc-anchor" href="#doc-ai-memory-forget">#</a> <code>ai_memory_forget</code></h3>
<p><code>ai_memory_forget</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_memory_forget $x
# or in a pipeline:
@list |> map ai_memory_forget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-memory-count">
<h3><a class="doc-anchor" href="#doc-ai-memory-count">#</a> <code>ai_memory_count</code></h3>
<p><code>ai_memory_count</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_memory_count $x
# or in a pipeline:
@list |> map ai_memory_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-memory-clear">
<h3><a class="doc-anchor" href="#doc-ai-memory-clear">#</a> <code>ai_memory_clear</code></h3>
<p><code>ai_memory_clear</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_memory_clear $x
# or in a pipeline:
@list |> map ai_memory_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-vision">
<h3><a class="doc-anchor" href="#doc-ai-vision">#</a> <code>ai_vision</code></h3>
<p><code>ai_vision</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_vision $x
# or in a pipeline:
@list |> map ai_vision |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-pdf">
<h3><a class="doc-anchor" href="#doc-ai-pdf">#</a> <code>ai_pdf</code></h3>
<p><code>ai_pdf</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_pdf $x
# or in a pipeline:
@list |> map ai_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-budget">
<h3><a class="doc-anchor" href="#doc-ai-budget">#</a> <code>ai_budget</code></h3>
<p><code>ai_budget($usd_cap, sub { ... })</code> — runs the block; raises a runtime error if AI spend during the block exceeds <code>$usd_cap</code>. Restores prior global cap on exit.</p>
</article>
<article class="doc-entry" id="doc-ai-last-thinking">
<h3><a class="doc-anchor" href="#doc-ai-last-thinking">#</a> <code>ai_last_thinking</code></h3>
<p><code>ai_last_thinking</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_last_thinking $x
# or in a pipeline:
@list |> map ai_last_thinking |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-batch">
<h3><a class="doc-anchor" href="#doc-ai-batch">#</a> <code>ai_batch</code></h3>
<p><code>ai_batch</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_batch $x
# or in a pipeline:
@list |> map ai_batch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-pmap">
<h3><a class="doc-anchor" href="#doc-ai-pmap">#</a> <code>ai_pmap</code></h3>
<p><code>ai_pmap</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_pmap $x
# or in a pipeline:
@list |> map ai_pmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-cosine">
<h3><a class="doc-anchor" href="#doc-vec-cosine">#</a> <code>vec_cosine</code></h3>
<p><code>vec_cosine \@a, \@b</code> — cosine similarity in <code>[-1, 1]</code>. Both args are arrayrefs of floats (typical embedding shape).</p>
</article>
<article class="doc-entry" id="doc-vec-search">
<h3><a class="doc-anchor" href="#doc-vec-search">#</a> <code>vec_search</code></h3>
<p><code>vec_search \@query, \@candidates, top_k => N</code> — return top-k matches as <code>+{idx, score}</code>.</p>
</article>
<article class="doc-entry" id="doc-vec-topk">
<h3><a class="doc-anchor" href="#doc-vec-topk">#</a> <code>vec_topk</code></h3>
<p><code>vec_topk</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = vec_topk $x
# or in a pipeline:
@list |> map vec_topk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-search-tool">
<h3><a class="doc-anchor" href="#doc-web-search-tool">#</a> <code>web_search_tool</code></h3>
<p><code>web_search_tool()</code> — built-in tool spec for <code>tools => [...]</code>. Brave Search via <code>$BRAVE_SEARCH_API_KEY</code>, falls back to DuckDuckGo HTML scrape.</p>
</article>
<article class="doc-entry" id="doc-fetch-url-tool">
<h3><a class="doc-anchor" href="#doc-fetch-url-tool">#</a> <code>fetch_url_tool</code></h3>
<p><code>fetch_url_tool()</code> — built-in tool spec that fetches a URL and returns text.</p>
</article>
<article class="doc-entry" id="doc-read-file-tool">
<h3><a class="doc-anchor" href="#doc-read-file-tool">#</a> <code>read_file_tool</code></h3>
<p><code>read_file_tool()</code> — built-in tool spec that reads a file from disk.</p>
</article>
<article class="doc-entry" id="doc-run-code-tool">
<h3><a class="doc-anchor" href="#doc-run-code-tool">#</a> <code>run_code_tool</code></h3>
<p><code>run_code_tool()</code> — built-in tool spec that runs Python code in a subprocess (10s timeout, returns stdout+stderr).</p>
</article>
<article class="doc-entry" id="doc-tool">
<h3><a class="doc-anchor" href="#doc-tool">#</a> <code>tool</code></h3>
<p><code>tool fn NAME($p1: type, $p2: type) -> Type "docstring" { body }</code> — declare an agent-callable tool. Param types become the JSON Schema. Auto-registers via <code>ai_register_tool</code> so bare <code>ai($prompt)</code> calls see it.</p>
<pre><code class="lang-perl">tool fn weather($city: string) "Get current weather" {
fetch "https://api.weather.com/" . uri_encode($city)
}
tool fn calc($a: int, $b: int) -> int "Add two ints" { $a + $b }
my $r = ai("what's the weather in SF and 7+5?");
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-mcp-model-context-protocol">
<h2>MCP (Model Context Protocol)</h2>
<p class="chapter-meta">13 topics</p>
<article class="doc-entry" id="doc-mcp-connect">
<h3><a class="doc-anchor" href="#doc-mcp-connect">#</a> <code>mcp_connect</code></h3>
<p><code>mcp_connect "stdio:CMD ARGS"</code> or <code>mcp_connect "https://server/mcp"</code> — connect to an MCP server. Speaks JSON-RPC over stdio (subprocess) or streamable HTTP. Returns a handle.</p>
</article>
<article class="doc-entry" id="doc-mcp-tools">
<h3><a class="doc-anchor" href="#doc-mcp-tools">#</a> <code>mcp_tools</code></h3>
<p><code>mcp_tools $h</code> — list the server's tools. Cached after first call.</p>
</article>
<article class="doc-entry" id="doc-mcp-resources">
<h3><a class="doc-anchor" href="#doc-mcp-resources">#</a> <code>mcp_resources</code></h3>
<p><code>mcp_resources</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = mcp_resources $x
# or in a pipeline:
@list |> map mcp_resources |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcp-prompts">
<h3><a class="doc-anchor" href="#doc-mcp-prompts">#</a> <code>mcp_prompts</code></h3>
<p><code>mcp_prompts</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = mcp_prompts $x
# or in a pipeline:
@list |> map mcp_prompts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcp-call">
<h3><a class="doc-anchor" href="#doc-mcp-call">#</a> <code>mcp_call</code></h3>
<p><code>mcp_call $h, "tool_name", +{...args}</code> — invoke a tool on the connected server.</p>
</article>
<article class="doc-entry" id="doc-mcp-resource">
<h3><a class="doc-anchor" href="#doc-mcp-resource">#</a> <code>mcp_resource</code></h3>
<p><code>mcp_resource</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = mcp_resource $x
# or in a pipeline:
@list |> map mcp_resource |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcp-prompt">
<h3><a class="doc-anchor" href="#doc-mcp-prompt">#</a> <code>mcp_prompt</code></h3>
<p><code>mcp_prompt</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = mcp_prompt $x
# or in a pipeline:
@list |> map mcp_prompt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcp-close">
<h3><a class="doc-anchor" href="#doc-mcp-close">#</a> <code>mcp_close</code></h3>
<p><code>mcp_close</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = mcp_close $x
# or in a pipeline:
@list |> map mcp_close |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcp-attach-to-ai">
<h3><a class="doc-anchor" href="#doc-mcp-attach-to-ai">#</a> <code>mcp_attach_to_ai</code></h3>
<p><code>mcp_attach_to_ai $h</code> — register a connected MCP server so subsequent bare <code>ai($prompt)</code> calls auto-include its tools.</p>
</article>
<article class="doc-entry" id="doc-mcp-detach-from-ai">
<h3><a class="doc-anchor" href="#doc-mcp-detach-from-ai">#</a> <code>mcp_detach_from_ai</code></h3>
<p><code>mcp_detach_from_ai</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = mcp_detach_from_ai $x
# or in a pipeline:
@list |> map mcp_detach_from_ai |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcp-attached">
<h3><a class="doc-anchor" href="#doc-mcp-attached">#</a> <code>mcp_attached</code></h3>
<p><code>mcp_attached</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = mcp_attached $x
# or in a pipeline:
@list |> map mcp_attached |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcp-server-start">
<h3><a class="doc-anchor" href="#doc-mcp-server-start">#</a> <code>mcp_server_start</code></h3>
<p><code>mcp_server_start "name", +{ tools => [...] }</code> — run a stdio JSON-RPC MCP server in-process. Pair with <code>s_web build</code> to ship a self-contained MCP server binary.</p>
<p>For parser-level sugar, use <code>mcp_server "name" { tool foo($a) "..." {...} }</code>.</p>
</article>
<article class="doc-entry" id="doc-mcp-server">
<h3><a class="doc-anchor" href="#doc-mcp-server">#</a> <code>mcp_server</code></h3>
<p><code>mcp_server "name" { tool NAME(args) "doc" { body } ... }</code> — declarative MCP server block. Compiles to <code>mcp_server_start("name", +{ tools => [...] })</code> with private helper fns for each tool body.</p>
<pre><code class="lang-perl">mcp_server "filesystem" {
tool read_file($path: string) "Read file contents" { slurp $path }
tool list_dir($path: string) "List dir entries" { join("\n", readdir $path) }
}
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-web-framework-stryke-web-readme-md">
<h2>Web framework (stryke_web/README.md)</h2>
<p class="chapter-meta">112 topics</p>
<article class="doc-entry" id="doc-web-route">
<h3><a class="doc-anchor" href="#doc-web-route">#</a> <code>web_route</code></h3>
<p><code>web_route "VERB /path", "controller#action"</code> — register a route in the global router.</p>
<pre><code class="lang-perl">web_route "GET /posts", "posts#index"
web_route "POST /posts", "posts#create"
</code></pre>
</article>
<article class="doc-entry" id="doc-web-resources">
<h3><a class="doc-anchor" href="#doc-web-resources">#</a> <code>web_resources</code></h3>
<p><code>web_resources "posts"</code> — register the 7-route REST scaffold (index/show/new/create/edit/update/destroy) for a resource.</p>
</article>
<article class="doc-entry" id="doc-web-root">
<h3><a class="doc-anchor" href="#doc-web-root">#</a> <code>web_root</code></h3>
<p><code>web_root "posts#index"</code> — shortcut for <code>web_route "GET /"</code>.</p>
</article>
<article class="doc-entry" id="doc-web-application-config">
<h3><a class="doc-anchor" href="#doc-web-application-config">#</a> <code>web_application_config</code></h3>
<p><code>web_application_config</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_application_config $x
# or in a pipeline:
@list |> map web_application_config |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-render">
<h3><a class="doc-anchor" href="#doc-web-render">#</a> <code>web_render</code></h3>
<p><code>web_render html => "..."</code> / <code>text => ...</code> / <code>json => ...</code> / <code>template => "posts/index", locals => +{...}</code> — emit a response. Templates resolve <code>app/views/...html.erb</code>, run through the ERB engine, wrap in the application layout.</p>
</article>
<article class="doc-entry" id="doc-web-render-partial">
<h3><a class="doc-anchor" href="#doc-web-render-partial">#</a> <code>web_render_partial</code></h3>
<p><code>web_render_partial</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_render_partial $x
# or in a pipeline:
@list |> map web_render_partial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-redirect">
<h3><a class="doc-anchor" href="#doc-web-redirect">#</a> <code>web_redirect</code></h3>
<p><code>web_redirect "/path", 302</code> — issue a 3xx redirect with <code>Location</code> header.</p>
</article>
<article class="doc-entry" id="doc-web-json">
<h3><a class="doc-anchor" href="#doc-web-json">#</a> <code>web_json</code></h3>
<p><code>web_json</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_json $x
# or in a pipeline:
@list |> map web_json |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-text">
<h3><a class="doc-anchor" href="#doc-web-text">#</a> <code>web_text</code></h3>
<p><code>web_text</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_text $x
# or in a pipeline:
@list |> map web_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-params">
<h3><a class="doc-anchor" href="#doc-web-params">#</a> <code>web_params</code></h3>
<p><code>web_params()</code> — hashref of query + form-urlencoded body + JSON body + path captures.</p>
</article>
<article class="doc-entry" id="doc-web-request">
<h3><a class="doc-anchor" href="#doc-web-request">#</a> <code>web_request</code></h3>
<p><code>web_request</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_request $x
# or in a pipeline:
@list |> map web_request |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-routes-table">
<h3><a class="doc-anchor" href="#doc-web-routes-table">#</a> <code>web_routes_table</code></h3>
<p><code>web_routes_table</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_routes_table $x
# or in a pipeline:
@list |> map web_routes_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-boot-application">
<h3><a class="doc-anchor" href="#doc-web-boot-application">#</a> <code>web_boot_application</code></h3>
<p><code>web_boot_application</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_boot_application $x
# or in a pipeline:
@list |> map web_boot_application |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-db-connect">
<h3><a class="doc-anchor" href="#doc-web-db-connect">#</a> <code>web_db_connect</code></h3>
<p><code>web_db_connect "sqlite://path"</code> — open and cache the global SQLite connection. Required before any <code>web_model_*</code> call.</p>
</article>
<article class="doc-entry" id="doc-web-db-execute">
<h3><a class="doc-anchor" href="#doc-web-db-execute">#</a> <code>web_db_execute</code></h3>
<p><code>web_db_execute</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_db_execute $x
# or in a pipeline:
@list |> map web_db_execute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-db-query">
<h3><a class="doc-anchor" href="#doc-web-db-query">#</a> <code>web_db_query</code></h3>
<p><code>web_db_query</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_db_query $x
# or in a pipeline:
@list |> map web_db_query |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-jobs-init">
<h3><a class="doc-anchor" href="#doc-web-jobs-init">#</a> <code>web_jobs_init</code></h3>
<p><code>web_jobs_init()</code> — create the SQLite <code>jobs</code> table if it doesn't exist. Idempotent.</p>
</article>
<article class="doc-entry" id="doc-web-job-enqueue">
<h3><a class="doc-anchor" href="#doc-web-job-enqueue">#</a> <code>web_job_enqueue</code></h3>
<p><code>web_job_enqueue("name", +{...args}, queue => "...", priority => N, max_attempts => N)</code> → job id (i64). Status starts as <code>pending</code>.</p>
</article>
<article class="doc-entry" id="doc-web-job-dequeue">
<h3><a class="doc-anchor" href="#doc-web-job-dequeue">#</a> <code>web_job_dequeue</code></h3>
<p><code>web_job_dequeue(queue => "...")</code> → <code>+{id, name, args_json, args, attempts, max_attempts}</code> or undef. Atomically marks the picked job as <code>running</code> and increments <code>attempts</code>.</p>
</article>
<article class="doc-entry" id="doc-web-job-complete">
<h3><a class="doc-anchor" href="#doc-web-job-complete">#</a> <code>web_job_complete</code></h3>
<p><code>web_job_complete($id)</code> — mark a running job as <code>done</code>.</p>
</article>
<article class="doc-entry" id="doc-web-job-fail">
<h3><a class="doc-anchor" href="#doc-web-job-fail">#</a> <code>web_job_fail</code></h3>
<p><code>web_job_fail($id, error => "msg")</code> — if <code>attempts < max_attempts</code>, returns to <code>pending</code> for retry; otherwise marked <code>failed</code>. Returns the new status.</p>
</article>
<article class="doc-entry" id="doc-web-jobs-list">
<h3><a class="doc-anchor" href="#doc-web-jobs-list">#</a> <code>web_jobs_list</code></h3>
<p><code>web_jobs_list(queue => "...", status => "...", limit => 50)</code> → arrayref of job hashrefs.</p>
</article>
<article class="doc-entry" id="doc-web-jobs-stats">
<h3><a class="doc-anchor" href="#doc-web-jobs-stats">#</a> <code>web_jobs_stats</code></h3>
<p><code>web_jobs_stats()</code> → <code>+{pending, running, done, failed}</code>.</p>
</article>
<article class="doc-entry" id="doc-web-job-purge">
<h3><a class="doc-anchor" href="#doc-web-job-purge">#</a> <code>web_job_purge</code></h3>
<p><code>web_job_purge(status => "done")</code> → number of rows deleted.</p>
</article>
<article class="doc-entry" id="doc-web-db-begin">
<h3><a class="doc-anchor" href="#doc-web-db-begin">#</a> <code>web_db_begin</code></h3>
<p><code>web_db_begin</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_db_begin $x
# or in a pipeline:
@list |> map web_db_begin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-db-commit">
<h3><a class="doc-anchor" href="#doc-web-db-commit">#</a> <code>web_db_commit</code></h3>
<p><code>web_db_commit</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_db_commit $x
# or in a pipeline:
@list |> map web_db_commit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-db-rollback">
<h3><a class="doc-anchor" href="#doc-web-db-rollback">#</a> <code>web_db_rollback</code></h3>
<p><code>web_db_rollback</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_db_rollback $x
# or in a pipeline:
@list |> map web_db_rollback |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-all">
<h3><a class="doc-anchor" href="#doc-web-model-all">#</a> <code>web_model_all</code></h3>
<p><code>web_model_all "posts"</code> — <code>SELECT * FROM posts ORDER BY id</code>. Returns arrayref of hashrefs.</p>
</article>
<article class="doc-entry" id="doc-web-model-find">
<h3><a class="doc-anchor" href="#doc-web-model-find">#</a> <code>web_model_find</code></h3>
<p><code>web_model_find "posts", $id</code> — find by id; returns hashref or undef.</p>
</article>
<article class="doc-entry" id="doc-web-model-where">
<h3><a class="doc-anchor" href="#doc-web-model-where">#</a> <code>web_model_where</code></h3>
<p><code>web_model_where</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_where $x
# or in a pipeline:
@list |> map web_model_where |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-create">
<h3><a class="doc-anchor" href="#doc-web-model-create">#</a> <code>web_model_create</code></h3>
<p><code>web_model_create "posts", +{title => "...", body => "..."}</code> — INSERT + return new row with id and auto-set <code>created_at</code>/<code>updated_at</code>.</p>
</article>
<article class="doc-entry" id="doc-web-model-update">
<h3><a class="doc-anchor" href="#doc-web-model-update">#</a> <code>web_model_update</code></h3>
<p><code>web_model_update</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_update $x
# or in a pipeline:
@list |> map web_model_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-destroy">
<h3><a class="doc-anchor" href="#doc-web-model-destroy">#</a> <code>web_model_destroy</code></h3>
<p><code>web_model_destroy</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_destroy $x
# or in a pipeline:
@list |> map web_model_destroy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-soft-destroy">
<h3><a class="doc-anchor" href="#doc-web-model-soft-destroy">#</a> <code>web_model_soft_destroy</code></h3>
<p><code>web_model_soft_destroy</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_soft_destroy $x
# or in a pipeline:
@list |> map web_model_soft_destroy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-paginate">
<h3><a class="doc-anchor" href="#doc-web-model-paginate">#</a> <code>web_model_paginate</code></h3>
<p><code>web_model_paginate</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_paginate $x
# or in a pipeline:
@list |> map web_model_paginate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-search">
<h3><a class="doc-anchor" href="#doc-web-model-search">#</a> <code>web_model_search</code></h3>
<p><code>web_model_search</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_search $x
# or in a pipeline:
@list |> map web_model_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-count">
<h3><a class="doc-anchor" href="#doc-web-model-count">#</a> <code>web_model_count</code></h3>
<p><code>web_model_count</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_count $x
# or in a pipeline:
@list |> map web_model_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-first">
<h3><a class="doc-anchor" href="#doc-web-model-first">#</a> <code>web_model_first</code></h3>
<p><code>web_model_first</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_first $x
# or in a pipeline:
@list |> map web_model_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-last">
<h3><a class="doc-anchor" href="#doc-web-model-last">#</a> <code>web_model_last</code></h3>
<p><code>web_model_last</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_last $x
# or in a pipeline:
@list |> map web_model_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-increment">
<h3><a class="doc-anchor" href="#doc-web-model-increment">#</a> <code>web_model_increment</code></h3>
<p><code>web_model_increment</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_increment $x
# or in a pipeline:
@list |> map web_model_increment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-model-with">
<h3><a class="doc-anchor" href="#doc-web-model-with">#</a> <code>web_model_with</code></h3>
<p><code>web_model_with</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_model_with $x
# or in a pipeline:
@list |> map web_model_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-create-table">
<h3><a class="doc-anchor" href="#doc-web-create-table">#</a> <code>web_create_table</code></h3>
<p><code>web_create_table</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_create_table $x
# or in a pipeline:
@list |> map web_create_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-drop-table">
<h3><a class="doc-anchor" href="#doc-web-drop-table">#</a> <code>web_drop_table</code></h3>
<p><code>web_drop_table</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_drop_table $x
# or in a pipeline:
@list |> map web_drop_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-add-column">
<h3><a class="doc-anchor" href="#doc-web-add-column">#</a> <code>web_add_column</code></h3>
<p><code>web_add_column</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_add_column $x
# or in a pipeline:
@list |> map web_add_column |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-remove-column">
<h3><a class="doc-anchor" href="#doc-web-remove-column">#</a> <code>web_remove_column</code></h3>
<p><code>web_remove_column</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_remove_column $x
# or in a pipeline:
@list |> map web_remove_column |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-migrate">
<h3><a class="doc-anchor" href="#doc-web-migrate">#</a> <code>web_migrate</code></h3>
<p><code>web_migrate()</code> — apply every <code>up</code> block from <code>db/migrate/*.stk</code> whose version isn't yet in <code>schema_migrations</code>.</p>
</article>
<article class="doc-entry" id="doc-web-rollback">
<h3><a class="doc-anchor" href="#doc-web-rollback">#</a> <code>web_rollback</code></h3>
<p><code>web_rollback</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_rollback $x
# or in a pipeline:
@list |> map web_rollback |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-validate">
<h3><a class="doc-anchor" href="#doc-web-validate">#</a> <code>web_validate</code></h3>
<p><code>web_validate $attrs, +{title => "presence,length:1..100", email => "format:^.+@.+$"}</code> — returns <code>+{ok => 1}</code> or <code>+{ok => 0, errors => +{...}}</code>. Validators: <code>presence</code>, <code>length:MIN..MAX</code>, <code>format:REGEX</code>, <code>numericality</code>, <code>inclusion:a|b|c</code>, <code>confirmation:other_field</code>.</p>
</article>
<article class="doc-entry" id="doc-web-permit">
<h3><a class="doc-anchor" href="#doc-web-permit">#</a> <code>web_permit</code></h3>
<p><code>web_permit</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_permit $x
# or in a pipeline:
@list |> map web_permit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-password-hash">
<h3><a class="doc-anchor" href="#doc-web-password-hash">#</a> <code>web_password_hash</code></h3>
<p><code>web_password_hash $pw</code> returns a <code>web1$saltHex$digest</code> shaped string. <code>web_password_verify $pw, $stored</code> returns 1/0. SHA-256 + 16-byte salt; constant-time compare.</p>
</article>
<article class="doc-entry" id="doc-web-session">
<h3><a class="doc-anchor" href="#doc-web-session">#</a> <code>web_session</code></h3>
<p><code>web_session</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_session $x
# or in a pipeline:
@list |> map web_session |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-session-set">
<h3><a class="doc-anchor" href="#doc-web-session-set">#</a> <code>web_session_set</code></h3>
<p>Server-side session storage backed by a signed cookie. <code>web_session_set("user_id", 42)</code> / <code>web_session_get("user_id")</code>. Cookie value is base64-JSON; HttpOnly + SameSite=Lax by default.</p>
</article>
<article class="doc-entry" id="doc-web-session-clear">
<h3><a class="doc-anchor" href="#doc-web-session-clear">#</a> <code>web_session_clear</code></h3>
<p><code>web_session_clear</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_session_clear $x
# or in a pipeline:
@list |> map web_session_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-set-cookie">
<h3><a class="doc-anchor" href="#doc-web-set-cookie">#</a> <code>web_set_cookie</code></h3>
<p><code>web_set_cookie</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_set_cookie $x
# or in a pipeline:
@list |> map web_set_cookie |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-cookies">
<h3><a class="doc-anchor" href="#doc-web-cookies">#</a> <code>web_cookies</code></h3>
<p><code>web_cookies</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_cookies $x
# or in a pipeline:
@list |> map web_cookies |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-flash">
<h3><a class="doc-anchor" href="#doc-web-flash">#</a> <code>web_flash</code></h3>
<p><code>web_flash</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_flash $x
# or in a pipeline:
@list |> map web_flash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-flash-set">
<h3><a class="doc-anchor" href="#doc-web-flash-set">#</a> <code>web_flash_set</code></h3>
<p><code>web_flash_set</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_flash_set $x
# or in a pipeline:
@list |> map web_flash_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-flash-get">
<h3><a class="doc-anchor" href="#doc-web-flash-get">#</a> <code>web_flash_get</code></h3>
<p><code>web_flash_get</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_flash_get $x
# or in a pipeline:
@list |> map web_flash_get |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-jwt-encode">
<h3><a class="doc-anchor" href="#doc-web-jwt-encode">#</a> <code>web_jwt_encode</code></h3>
<p><code>web_jwt_encode +{user_id => 1, role => "admin"}</code> — HS256-sign a JWT using <code>secret_key_base</code> from <code>web_application_config</code>.</p>
</article>
<article class="doc-entry" id="doc-web-jwt-decode">
<h3><a class="doc-anchor" href="#doc-web-jwt-decode">#</a> <code>web_jwt_decode</code></h3>
<p><code>web_jwt_decode $token</code> — verify + decode an HS256 JWT. Returns the payload hashref or undef on bad signature.</p>
</article>
<article class="doc-entry" id="doc-web-bearer-token">
<h3><a class="doc-anchor" href="#doc-web-bearer-token">#</a> <code>web_bearer_token</code></h3>
<p><code>web_bearer_token</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_bearer_token $x
# or in a pipeline:
@list |> map web_bearer_token |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-otp-secret">
<h3><a class="doc-anchor" href="#doc-web-otp-secret">#</a> <code>web_otp_secret</code></h3>
<p>TOTP / 2FA — RFC 6238, 30-second window, ±1 step skew tolerance. <code>web_otp_secret()</code> returns a base32 secret to share with the authenticator app; <code>web_otp_generate($secret)</code> returns the current 6-digit code; <code>web_otp_verify($secret, $code)</code> returns 1/0.</p>
</article>
<article class="doc-entry" id="doc-web-token-for">
<h3><a class="doc-anchor" href="#doc-web-token-for">#</a> <code>web_token_for</code></h3>
<p><code>web_token_for</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_token_for $x
# or in a pipeline:
@list |> map web_token_for |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-token-consume">
<h3><a class="doc-anchor" href="#doc-web-token-consume">#</a> <code>web_token_consume</code></h3>
<p><code>web_token_consume</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_token_consume $x
# or in a pipeline:
@list |> map web_token_consume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-can">
<h3><a class="doc-anchor" href="#doc-web-can">#</a> <code>web_can</code></h3>
<p><code>web_can</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_can $x
# or in a pipeline:
@list |> map web_can |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-signed">
<h3><a class="doc-anchor" href="#doc-web-signed">#</a> <code>web_signed</code></h3>
<p><code>web_signed</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_signed $x
# or in a pipeline:
@list |> map web_signed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-unsigned">
<h3><a class="doc-anchor" href="#doc-web-unsigned">#</a> <code>web_unsigned</code></h3>
<p><code>web_unsigned</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_unsigned $x
# or in a pipeline:
@list |> map web_unsigned |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-cache-get">
<h3><a class="doc-anchor" href="#doc-web-cache-get">#</a> <code>web_cache_get</code></h3>
<p><code>web_cache_get</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_cache_get $x
# or in a pipeline:
@list |> map web_cache_get |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-cache-set">
<h3><a class="doc-anchor" href="#doc-web-cache-set">#</a> <code>web_cache_set</code></h3>
<p><code>web_cache_set</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_cache_set $x
# or in a pipeline:
@list |> map web_cache_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-cache-delete">
<h3><a class="doc-anchor" href="#doc-web-cache-delete">#</a> <code>web_cache_delete</code></h3>
<p><code>web_cache_delete</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_cache_delete $x
# or in a pipeline:
@list |> map web_cache_delete |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-cache-clear">
<h3><a class="doc-anchor" href="#doc-web-cache-clear">#</a> <code>web_cache_clear</code></h3>
<p><code>web_cache_clear</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_cache_clear $x
# or in a pipeline:
@list |> map web_cache_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-t">
<h3><a class="doc-anchor" href="#doc-web-t">#</a> <code>web_t</code></h3>
<p><code>web_t</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_t $x
# or in a pipeline:
@list |> map web_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-load-locale">
<h3><a class="doc-anchor" href="#doc-web-load-locale">#</a> <code>web_load_locale</code></h3>
<p><code>web_load_locale</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_load_locale $x
# or in a pipeline:
@list |> map web_load_locale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-log">
<h3><a class="doc-anchor" href="#doc-web-log">#</a> <code>web_log</code></h3>
<p><code>web_log</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_log $x
# or in a pipeline:
@list |> map web_log |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-set-header">
<h3><a class="doc-anchor" href="#doc-web-set-header">#</a> <code>web_set_header</code></h3>
<p><code>web_set_header</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_set_header $x
# or in a pipeline:
@list |> map web_set_header |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-status">
<h3><a class="doc-anchor" href="#doc-web-status">#</a> <code>web_status</code></h3>
<p><code>web_status</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_status $x
# or in a pipeline:
@list |> map web_status |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-uuid">
<h3><a class="doc-anchor" href="#doc-web-uuid">#</a> <code>web_uuid</code></h3>
<p><code>web_uuid</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_uuid $x
# or in a pipeline:
@list |> map web_uuid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-now">
<h3><a class="doc-anchor" href="#doc-web-now">#</a> <code>web_now</code></h3>
<p><code>web_now</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_now $x
# or in a pipeline:
@list |> map web_now |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-security-headers">
<h3><a class="doc-anchor" href="#doc-web-security-headers">#</a> <code>web_security_headers</code></h3>
<p><code>web_security_headers</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_security_headers $x
# or in a pipeline:
@list |> map web_security_headers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-openapi">
<h3><a class="doc-anchor" href="#doc-web-openapi">#</a> <code>web_openapi</code></h3>
<p><code>web_openapi</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_openapi $x
# or in a pipeline:
@list |> map web_openapi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-etag">
<h3><a class="doc-anchor" href="#doc-web-etag">#</a> <code>web_etag</code></h3>
<p><code>web_etag</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_etag $x
# or in a pipeline:
@list |> map web_etag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-csv">
<h3><a class="doc-anchor" href="#doc-web-csv">#</a> <code>web_csv</code></h3>
<p><code>web_csv</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_csv $x
# or in a pipeline:
@list |> map web_csv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-markdown">
<h3><a class="doc-anchor" href="#doc-web-markdown">#</a> <code>web_markdown</code></h3>
<p><code>web_markdown</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_markdown $x
# or in a pipeline:
@list |> map web_markdown |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-md">
<h3><a class="doc-anchor" href="#doc-web-md">#</a> <code>web_md</code></h3>
<p><code>web_md</code> — web framework (docs/web_framework.md) builtin. Alias for <code>web_markdown</code>.</p>
<pre><code class="lang-perl">my $result = web_md $x
# or in a pipeline:
@list |> map web_md |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-content-for">
<h3><a class="doc-anchor" href="#doc-web-content-for">#</a> <code>web_content_for</code></h3>
<p><code>web_content_for</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_content_for $x
# or in a pipeline:
@list |> map web_content_for |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-yield-content">
<h3><a class="doc-anchor" href="#doc-web-yield-content">#</a> <code>web_yield_content</code></h3>
<p><code>web_yield_content</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_yield_content $x
# or in a pipeline:
@list |> map web_yield_content |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-jsonapi-resource">
<h3><a class="doc-anchor" href="#doc-web-jsonapi-resource">#</a> <code>web_jsonapi_resource</code></h3>
<p><code>web_jsonapi_resource</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_jsonapi_resource $x
# or in a pipeline:
@list |> map web_jsonapi_resource |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-jsonapi-collection">
<h3><a class="doc-anchor" href="#doc-web-jsonapi-collection">#</a> <code>web_jsonapi_collection</code></h3>
<p><code>web_jsonapi_collection</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_jsonapi_collection $x
# or in a pipeline:
@list |> map web_jsonapi_collection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-jsonapi-error">
<h3><a class="doc-anchor" href="#doc-web-jsonapi-error">#</a> <code>web_jsonapi_error</code></h3>
<p><code>web_jsonapi_error</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_jsonapi_error $x
# or in a pipeline:
@list |> map web_jsonapi_error |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-rate-limit">
<h3><a class="doc-anchor" href="#doc-web-rate-limit">#</a> <code>web_rate_limit</code></h3>
<p><code>web_rate_limit</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_rate_limit $x
# or in a pipeline:
@list |> map web_rate_limit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-before-action">
<h3><a class="doc-anchor" href="#doc-web-before-action">#</a> <code>web_before_action</code></h3>
<p><code>web_before_action</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_before_action $x
# or in a pipeline:
@list |> map web_before_action |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-after-action">
<h3><a class="doc-anchor" href="#doc-web-after-action">#</a> <code>web_after_action</code></h3>
<p><code>web_after_action</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_after_action $x
# or in a pipeline:
@list |> map web_after_action |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-h">
<h3><a class="doc-anchor" href="#doc-web-h">#</a> <code>web_h</code></h3>
<p><code>web_h</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_h $x
# or in a pipeline:
@list |> map web_h |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-link-to">
<h3><a class="doc-anchor" href="#doc-web-link-to">#</a> <code>web_link_to</code></h3>
<p><code>web_link_to</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_link_to $x
# or in a pipeline:
@list |> map web_link_to |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-button-to">
<h3><a class="doc-anchor" href="#doc-web-button-to">#</a> <code>web_button_to</code></h3>
<p><code>web_button_to</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_button_to $x
# or in a pipeline:
@list |> map web_button_to |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-form-with">
<h3><a class="doc-anchor" href="#doc-web-form-with">#</a> <code>web_form_with</code></h3>
<p><code>web_form_with</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_form_with $x
# or in a pipeline:
@list |> map web_form_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-form-close">
<h3><a class="doc-anchor" href="#doc-web-form-close">#</a> <code>web_form_close</code></h3>
<p><code>web_form_close</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_form_close $x
# or in a pipeline:
@list |> map web_form_close |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-text-field">
<h3><a class="doc-anchor" href="#doc-web-text-field">#</a> <code>web_text_field</code></h3>
<p><code>web_text_field</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_text_field $x
# or in a pipeline:
@list |> map web_text_field |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-text-area">
<h3><a class="doc-anchor" href="#doc-web-text-area">#</a> <code>web_text_area</code></h3>
<p><code>web_text_area</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_text_area $x
# or in a pipeline:
@list |> map web_text_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-check-box">
<h3><a class="doc-anchor" href="#doc-web-check-box">#</a> <code>web_check_box</code></h3>
<p><code>web_check_box</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_check_box $x
# or in a pipeline:
@list |> map web_check_box |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-csrf-meta-tag">
<h3><a class="doc-anchor" href="#doc-web-csrf-meta-tag">#</a> <code>web_csrf_meta_tag</code></h3>
<p><code>web_csrf_meta_tag</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_csrf_meta_tag $x
# or in a pipeline:
@list |> map web_csrf_meta_tag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-stylesheet-link-tag">
<h3><a class="doc-anchor" href="#doc-web-stylesheet-link-tag">#</a> <code>web_stylesheet_link_tag</code></h3>
<p><code>web_stylesheet_link_tag</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_stylesheet_link_tag $x
# or in a pipeline:
@list |> map web_stylesheet_link_tag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-javascript-link-tag">
<h3><a class="doc-anchor" href="#doc-web-javascript-link-tag">#</a> <code>web_javascript_link_tag</code></h3>
<p><code>web_javascript_link_tag</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_javascript_link_tag $x
# or in a pipeline:
@list |> map web_javascript_link_tag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-image-tag">
<h3><a class="doc-anchor" href="#doc-web-image-tag">#</a> <code>web_image_tag</code></h3>
<p><code>web_image_tag</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_image_tag $x
# or in a pipeline:
@list |> map web_image_tag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-truncate">
<h3><a class="doc-anchor" href="#doc-web-truncate">#</a> <code>web_truncate</code></h3>
<p><code>web_truncate</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_truncate $x
# or in a pipeline:
@list |> map web_truncate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-pluralize">
<h3><a class="doc-anchor" href="#doc-web-pluralize">#</a> <code>web_pluralize</code></h3>
<p><code>web_pluralize</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_pluralize $x
# or in a pipeline:
@list |> map web_pluralize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-time-ago-in-words">
<h3><a class="doc-anchor" href="#doc-web-time-ago-in-words">#</a> <code>web_time_ago_in_words</code></h3>
<p><code>web_time_ago_in_words</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_time_ago_in_words $x
# or in a pipeline:
@list |> map web_time_ago_in_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-faker-name">
<h3><a class="doc-anchor" href="#doc-web-faker-name">#</a> <code>web_faker_name</code></h3>
<p><code>web_faker_name</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_faker_name $x
# or in a pipeline:
@list |> map web_faker_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-faker-email">
<h3><a class="doc-anchor" href="#doc-web-faker-email">#</a> <code>web_faker_email</code></h3>
<p><code>web_faker_email</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_faker_email $x
# or in a pipeline:
@list |> map web_faker_email |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-faker-sentence">
<h3><a class="doc-anchor" href="#doc-web-faker-sentence">#</a> <code>web_faker_sentence</code></h3>
<p><code>web_faker_sentence</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_faker_sentence $x
# or in a pipeline:
@list |> map web_faker_sentence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-faker-paragraph">
<h3><a class="doc-anchor" href="#doc-web-faker-paragraph">#</a> <code>web_faker_paragraph</code></h3>
<p><code>web_faker_paragraph</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_faker_paragraph $x
# or in a pipeline:
@list |> map web_faker_paragraph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-web-faker-int">
<h3><a class="doc-anchor" href="#doc-web-faker-int">#</a> <code>web_faker_int</code></h3>
<p><code>web_faker_int</code> — web framework (docs/web_framework.md) builtin.</p>
<pre><code class="lang-perl">my $result = web_faker_int $x
# or in a pipeline:
@list |> map web_faker_int |> p
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-stress-telemetry-docs-stress-testing-md">
<h2>Stress / telemetry (docs/STRESS_TESTING.md)</h2>
<p class="chapter-meta">42 topics</p>
<article class="doc-entry" id="doc-stress-fp">
<h3><a class="doc-anchor" href="#doc-stress-fp">#</a> <code>stress_fp</code></h3>
<p><code>stress_fp $secs</code> — float matrix-multiply pinning every core. Returns total FLOP count.</p>
</article>
<article class="doc-entry" id="doc-stress-int">
<h3><a class="doc-anchor" href="#doc-stress-int">#</a> <code>stress_int</code></h3>
<p><code>stress_int $secs</code> — integer pipeline pinning every core.</p>
</article>
<article class="doc-entry" id="doc-stress-cache">
<h3><a class="doc-anchor" href="#doc-stress-cache">#</a> <code>stress_cache</code></h3>
<p><code>stress_cache $secs, $kb</code> — pound a working set of <code>kb</code> KiB per core in random order. Default 1024 (~ L2/L3 boundary).</p>
</article>
<article class="doc-entry" id="doc-stress-branch">
<h3><a class="doc-anchor" href="#doc-stress-branch">#</a> <code>stress_branch</code></h3>
<p><code>stress_branch</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_branch $x
# or in a pipeline:
@list |> map stress_branch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-sort">
<h3><a class="doc-anchor" href="#doc-stress-sort">#</a> <code>stress_sort</code></h3>
<p><code>stress_sort</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_sort $x
# or in a pipeline:
@list |> map stress_sort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-alloc">
<h3><a class="doc-anchor" href="#doc-stress-alloc">#</a> <code>stress_alloc</code></h3>
<p><code>stress_alloc</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_alloc $x
# or in a pipeline:
@list |> map stress_alloc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-mmap">
<h3><a class="doc-anchor" href="#doc-stress-mmap">#</a> <code>stress_mmap</code></h3>
<p><code>stress_mmap</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_mmap $x
# or in a pipeline:
@list |> map stress_mmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-disk">
<h3><a class="doc-anchor" href="#doc-stress-disk">#</a> <code>stress_disk</code></h3>
<p><code>stress_disk $path, $secs, $mb_per_write</code> — sustained sequential write + fsync + read across all cores.</p>
</article>
<article class="doc-entry" id="doc-stress-iops">
<h3><a class="doc-anchor" href="#doc-stress-iops">#</a> <code>stress_iops</code></h3>
<p><code>stress_iops $path, $secs, $block_kb</code> — small random reads/writes for IOPS testing. Default 4KB blocks.</p>
</article>
<article class="doc-entry" id="doc-stress-net">
<h3><a class="doc-anchor" href="#doc-stress-net">#</a> <code>stress_net</code></h3>
<p><code>stress_net "host:port", $secs, $conns</code> — open <code>conns</code> TCP connections per core, pump bytes.</p>
</article>
<article class="doc-entry" id="doc-stress-http">
<h3><a class="doc-anchor" href="#doc-stress-http">#</a> <code>stress_http</code></h3>
<p><code>stress_http $url, $secs, $conns</code> — HTTP GET storm. Counts 2xx responses.</p>
</article>
<article class="doc-entry" id="doc-stress-dns">
<h3><a class="doc-anchor" href="#doc-stress-dns">#</a> <code>stress_dns</code></h3>
<p><code>stress_dns</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_dns $x
# or in a pipeline:
@list |> map stress_dns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-thread">
<h3><a class="doc-anchor" href="#doc-stress-thread">#</a> <code>stress_thread</code></h3>
<p><code>stress_thread</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_thread $x
# or in a pipeline:
@list |> map stress_thread |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-fork">
<h3><a class="doc-anchor" href="#doc-stress-fork">#</a> <code>stress_fork</code></h3>
<p><code>stress_fork</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_fork $x
# or in a pipeline:
@list |> map stress_fork |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-aes">
<h3><a class="doc-anchor" href="#doc-stress-aes">#</a> <code>stress_aes</code></h3>
<p><code>stress_aes $secs</code> — AES-128 encrypt round-trip across cores.</p>
</article>
<article class="doc-entry" id="doc-stress-compress">
<h3><a class="doc-anchor" href="#doc-stress-compress">#</a> <code>stress_compress</code></h3>
<p><code>stress_compress $secs, $kb</code> — gzip compress+decompress payload of <code>kb</code> KiB per core.</p>
</article>
<article class="doc-entry" id="doc-stress-regex">
<h3><a class="doc-anchor" href="#doc-stress-regex">#</a> <code>stress_regex</code></h3>
<p><code>stress_regex</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_regex $x
# or in a pipeline:
@list |> map stress_regex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-json">
<h3><a class="doc-anchor" href="#doc-stress-json">#</a> <code>stress_json</code></h3>
<p><code>stress_json</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_json $x
# or in a pipeline:
@list |> map stress_json |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-burst">
<h3><a class="doc-anchor" href="#doc-stress-burst">#</a> <code>stress_burst</code></h3>
<p><code>stress_burst</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_burst $x
# or in a pipeline:
@list |> map stress_burst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-ramp">
<h3><a class="doc-anchor" href="#doc-stress-ramp">#</a> <code>stress_ramp</code></h3>
<p><code>stress_ramp</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_ramp $x
# or in a pipeline:
@list |> map stress_ramp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-oscillate">
<h3><a class="doc-anchor" href="#doc-stress-oscillate">#</a> <code>stress_oscillate</code></h3>
<p><code>stress_oscillate</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_oscillate $x
# or in a pipeline:
@list |> map stress_oscillate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-all">
<h3><a class="doc-anchor" href="#doc-stress-all">#</a> <code>stress_all</code></h3>
<p><code>stress_all $secs</code> — run every stress kernel above in parallel for <code>secs</code>. Returns a hashref of per-kernel counts.</p>
</article>
<article class="doc-entry" id="doc-stress-cores">
<h3><a class="doc-anchor" href="#doc-stress-cores">#</a> <code>stress_cores</code></h3>
<p><code>stress_cores</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_cores $x
# or in a pipeline:
@list |> map stress_cores |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-temp">
<h3><a class="doc-anchor" href="#doc-stress-temp">#</a> <code>stress_temp</code></h3>
<p>Telemetry helpers: <code>stress_temp()</code> reads CPU temp from <code>/sys/class/thermal</code> (Linux), <code>stress_freq()</code> averages cpufreq across cores, <code>stress_throttled()</code> returns 1 when freq < 80% of max AND temp > 80°C, <code>stress_load()</code> returns <code>+{m1, m5, m15}</code>, <code>stress_meminfo()</code> returns total/used/free/swap bytes.</p>
</article>
<article class="doc-entry" id="doc-stress-thermal-zones">
<h3><a class="doc-anchor" href="#doc-stress-thermal-zones">#</a> <code>stress_thermal_zones</code></h3>
<p><code>stress_thermal_zones</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_thermal_zones $x
# or in a pipeline:
@list |> map stress_thermal_zones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-arm-kill-switch">
<h3><a class="doc-anchor" href="#doc-stress-arm-kill-switch">#</a> <code>stress_arm_kill_switch</code></h3>
<p><code>stress_arm_kill_switch</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_arm_kill_switch $x
# or in a pipeline:
@list |> map stress_arm_kill_switch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-killed">
<h3><a class="doc-anchor" href="#doc-stress-killed">#</a> <code>stress_killed</code></h3>
<p><code>stress_killed</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_killed $x
# or in a pipeline:
@list |> map stress_killed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-disarm-kill-switch">
<h3><a class="doc-anchor" href="#doc-stress-disarm-kill-switch">#</a> <code>stress_disarm_kill_switch</code></h3>
<p><code>stress_disarm_kill_switch</code> — stress / telemetry extensions builtin.</p>
<pre><code class="lang-perl">my $result = stress_disarm_kill_switch $x
# or in a pipeline:
@list |> map stress_disarm_kill_switch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stress-metrics-record">
<h3><a class="doc-anchor" href="#doc-stress-metrics-record">#</a> <code>stress_metrics_record</code></h3>
<p><code>stress_metrics_record("name", $value, k1 => v1, ...)</code> — append a sample to the metrics history. Labels are stringified.</p>
</article>
<article class="doc-entry" id="doc-stress-metrics-clear">
<h3><a class="doc-anchor" href="#doc-stress-metrics-clear">#</a> <code>stress_metrics_clear</code></h3>
<p><code>stress_metrics_clear()</code> — wipe the metrics history. Pair with <code>stress_metrics_count()</code> before/after to verify.</p>
</article>
<article class="doc-entry" id="doc-stress-metrics-count">
<h3><a class="doc-anchor" href="#doc-stress-metrics-count">#</a> <code>stress_metrics_count</code></h3>
<p><code>stress_metrics_count()</code> → current number of samples in the history.</p>
</article>
<article class="doc-entry" id="doc-stress-metrics-export">
<h3><a class="doc-anchor" href="#doc-stress-metrics-export">#</a> <code>stress_metrics_export</code></h3>
<p><code>stress_metrics_export("path", format => "csv"|"json"|"prom")</code> → number of samples written.</p>
</article>
<article class="doc-entry" id="doc-stress-metrics-prometheus">
<h3><a class="doc-anchor" href="#doc-stress-metrics-prometheus">#</a> <code>stress_metrics_prometheus</code></h3>
<p><code>stress_metrics_prometheus()</code> → string in Prometheus text exposition format. Latest value per (name, labels) wins. Drop into a <code>/metrics</code> HTTP handler.</p>
</article>
<article class="doc-entry" id="doc-stress-metrics-json">
<h3><a class="doc-anchor" href="#doc-stress-metrics-json">#</a> <code>stress_metrics_json</code></h3>
<p><code>stress_metrics_json()</code> → JSON string of the entire metrics history.</p>
</article>
<article class="doc-entry" id="doc-stress-metrics-csv">
<h3><a class="doc-anchor" href="#doc-stress-metrics-csv">#</a> <code>stress_metrics_csv</code></h3>
<p><code>stress_metrics_csv()</code> → CSV string with <code>ts_ms,name,value,labels</code> columns.</p>
</article>
<article class="doc-entry" id="doc-stress-metrics-watch">
<h3><a class="doc-anchor" href="#doc-stress-metrics-watch">#</a> <code>stress_metrics_watch</code></h3>
<p><code>stress_metrics_watch(field => "stress_temp", interval_ms => 1000, max_ticks => 60)</code> → arrayref of values sampled at the requested cadence. Polls the metrics history for new entries matching <code>field</code>.</p>
</article>
<article class="doc-entry" id="doc-audit-log">
<h3><a class="doc-anchor" href="#doc-audit-log">#</a> <code>audit_log</code></h3>
<p><code>audit_log("event_name", k1 => v1, ...)</code> — append one JSONL line to <code>~/.stryke/audit.log</code> (or <code>$STRYKE_AUDIT_LOG</code>). Never throws; returns 1/0.</p>
</article>
<article class="doc-entry" id="doc-audit-log-path">
<h3><a class="doc-anchor" href="#doc-audit-log-path">#</a> <code>audit_log_path</code></h3>
<p><code>audit_log_path()</code> → absolute path the next <code>audit_log</code> call will write to.</p>
</article>
<article class="doc-entry" id="doc-secrets-encrypt">
<h3><a class="doc-anchor" href="#doc-secrets-encrypt">#</a> <code>secrets_encrypt</code></h3>
<p><code>secrets_encrypt($plain, key => $key)</code> → base64 envelope (nonce(12) || ciphertext || tag(16)). AES-256-GCM. Key must be 32 raw bytes or 32-byte base64.</p>
</article>
<article class="doc-entry" id="doc-secrets-decrypt">
<h3><a class="doc-anchor" href="#doc-secrets-decrypt">#</a> <code>secrets_decrypt</code></h3>
<p><code>secrets_decrypt($envelope, key => $key)</code> → plaintext, or undef on auth failure.</p>
</article>
<article class="doc-entry" id="doc-secrets-random-key">
<h3><a class="doc-anchor" href="#doc-secrets-random-key">#</a> <code>secrets_random_key</code></h3>
<p><code>secrets_random_key()</code> → fresh 32-byte AES-256 key as base64. Reads <code>/dev/urandom</code> on Unix.</p>
</article>
<article class="doc-entry" id="doc-secrets-kdf">
<h3><a class="doc-anchor" href="#doc-secrets-kdf">#</a> <code>secrets_kdf</code></h3>
<p><code>secrets_kdf($password, salt => "...", iterations => 600_000)</code> → 32-byte key as base64. PBKDF2-HMAC-SHA256.</p>
</article>
</section>
<section class="tutorial-section" id="ch-pty-expect-docs-expect-feature-idea-md">
<h2>PTY / expect (docs/expect-feature-idea.md)</h2>
<p class="chapter-meta">13 topics</p>
<article class="doc-entry" id="doc-pty-spawn">
<h3><a class="doc-anchor" href="#doc-pty-spawn">#</a> <code>pty_spawn</code></h3>
<p><code>pty_spawn "cmd args"</code> or <code>pty_spawn("cmd", "arg1", "arg2")</code> — allocate a PTY, fork+exec the child, return a handle. Master fd is non-blocking.</p>
<pre><code class="lang-perl">my $h = pty_spawn("ssh user@host");
pty_expect($h, qr/password:/, 30);
pty_send($h, "hunter2\n");
pty_close($h);
</code></pre>
</article>
<article class="doc-entry" id="doc-pty-send">
<h3><a class="doc-anchor" href="#doc-pty-send">#</a> <code>pty_send</code></h3>
<p><code>pty_send $h, "text"</code> — write to the PTY master. Handles EAGAIN/EINTR; returns bytes written.</p>
</article>
<article class="doc-entry" id="doc-pty-read">
<h3><a class="doc-anchor" href="#doc-pty-read">#</a> <code>pty_read</code></h3>
<p><code>pty_read</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = pty_read $x
# or in a pipeline:
@list |> map pty_read |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pty-expect">
<h3><a class="doc-anchor" href="#doc-pty-expect">#</a> <code>pty_expect</code></h3>
<p><code>pty_expect $h, qr/regex/, $timeout_secs</code> — loop reading until the regex matches the accumulated buffer or <code>timeout_secs</code> elapses. Returns the matched substring or undef on timeout/EOF. Buffer is consumed up to (and including) the match.</p>
</article>
<article class="doc-entry" id="doc-pty-expect-table">
<h3><a class="doc-anchor" href="#doc-pty-expect-table">#</a> <code>pty_expect_table</code></h3>
<p><code>pty_expect_table $h, [+{re => qr/.../, do => sub {...}}, ...], $timeout</code> — multi-pattern dispatch (Tcl <code>expect { ... }</code> block). First match wins; the matched branch's <code>do</code> sub is called.</p>
</article>
<article class="doc-entry" id="doc-pty-buffer">
<h3><a class="doc-anchor" href="#doc-pty-buffer">#</a> <code>pty_buffer</code></h3>
<p><code>pty_buffer</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = pty_buffer $x
# or in a pipeline:
@list |> map pty_buffer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pty-alive">
<h3><a class="doc-anchor" href="#doc-pty-alive">#</a> <code>pty_alive</code></h3>
<p><code>pty_alive</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = pty_alive $x
# or in a pipeline:
@list |> map pty_alive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pty-eof">
<h3><a class="doc-anchor" href="#doc-pty-eof">#</a> <code>pty_eof</code></h3>
<p><code>pty_eof</code> — mcp (model context protocol) builtin.</p>
<pre><code class="lang-perl">my $result = pty_eof $x
# or in a pipeline:
@list |> map pty_eof |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pty-close">
<h3><a class="doc-anchor" href="#doc-pty-close">#</a> <code>pty_close</code></h3>
<p><code>pty_close $h</code> — SIGTERM → 200ms grace → SIGKILL. Returns exit status.</p>
</article>
<article class="doc-entry" id="doc-pty-interact">
<h3><a class="doc-anchor" href="#doc-pty-interact">#</a> <code>pty_interact</code></h3>
<p><code>pty_interact $h</code> — raw-mode handoff: forwards stdin → master and master → stdout until EOF or Ctrl-]. Saves and restores tty state.</p>
</article>
<article class="doc-entry" id="doc-pty-strip-ansi">
<h3><a class="doc-anchor" href="#doc-pty-strip-ansi">#</a> <code>pty_strip_ansi</code></h3>
<p><code>pty_strip_ansi $text</code> → string with CSI/OSC/ESC sequences removed. Useful before regex-matching against PTY output that mixes color codes into prompts.</p>
</article>
<article class="doc-entry" id="doc-pty-after-eof">
<h3><a class="doc-anchor" href="#doc-pty-after-eof">#</a> <code>pty_after_eof</code></h3>
<p><code>pty_after_eof $h, "callback_name"</code> — register an EOF callback. Spawns a watcher thread that flips a fired flag once the PTY closes. Pair with <code>pty_pending_events()</code> in your main loop.</p>
</article>
<article class="doc-entry" id="doc-pty-pending-events">
<h3><a class="doc-anchor" href="#doc-pty-pending-events">#</a> <code>pty_pending_events</code></h3>
<p><code>pty_pending_events()</code> → arrayref of <code>+{handle_id, callback}</code> for any <code>pty_after_eof</code> registrations that have fired since the last call. Drains the fired list.</p>
</article>
</section>
<section class="tutorial-section" id="ch-other">
<h2>Other</h2>
<p class="chapter-meta">6716 topics</p>
<article class="doc-entry" id="doc-pc">
<h3><a class="doc-anchor" href="#doc-pc">#</a> <code>%pc</code></h3>
<p><code>parsec</code> (alias <code>pc</code>) — pc ≈ 3.086×10¹⁶ m ≈ 3.26 ly. Common astronomical distance unit.</p>
<pre><code class="lang-perl">p pc # 3.0856775814913673e16 m
p pc / ly # ~3.26 light years
</code></pre>
</article>
<article class="doc-entry" id="doc-stryke-aliases">
<h3><a class="doc-anchor" href="#doc-stryke-aliases">#</a> <code>%stryke::aliases</code></h3>
<p><code>%stryke::aliases</code> (short: <code>%a</code>) — alias spelling → canonical primary.</p>
<p>Keys are the 2nd-and-later names in each <code>try_builtin</code> match arm. For O(1) *reverse* lookup (primary → all its aliases), use <code>%stryke::primaries</code> / <code>%p</code>.</p>
<pre><code class="lang-perl">p $a{tj} # "to_json"
p $a{bn} # "basename"
p scalar keys %a # total alias count
</code></pre>
</article>
<article class="doc-entry" id="doc-stryke-all">
<h3><a class="doc-anchor" href="#doc-stryke-all">#</a> <code>%stryke::all</code></h3>
<p><code>%stryke::all</code> (short: <code>%all</code>) — every callable *spelling* (primaries <strong>and</strong> aliases) → category. Aliases inherit their primary's category.</p>
<p>Use <code>%all</code> when you want "how many names can I type?" or want to look up an alias's category without hopping through <code>%aliases</code>. Use <code>%builtins</code> when you want unique operations.</p>
<pre><code class="lang-perl">p scalar keys %all # total callable-spellings count
p $all{tj} # "serialization" (alias resolves via inheritance)
p $all{to_json} # "serialization"
keys %all |> pager # browse every spelling
</code></pre>
</article>
<article class="doc-entry" id="doc-stryke-builtins">
<h3><a class="doc-anchor" href="#doc-stryke-builtins">#</a> <code>%stryke::builtins</code></h3>
<p><code>%stryke::builtins</code> (short: <code>%b</code>) — every <strong>primary</strong> callable name → its category. Primaries-only, so <code>scalar keys %b</code> is a clean unique-operation count. For the "everything you can type" view (primaries + aliases), use <code>%stryke::all</code> / <code>%all</code>.</p>
<pre><code class="lang-perl">p $b{pmap} # "parallel"
p $b{to_json} # "serialization"
p scalar keys %b # unique-op count
</code></pre>
</article>
<article class="doc-entry" id="doc-stryke-categories">
<h3><a class="doc-anchor" href="#doc-stryke-categories">#</a> <code>%stryke::categories</code></h3>
<p><code>%stryke::categories</code> (short: <code>%c</code>) — category string → arrayref of names in that category.</p>
<p>Inverted index on <code>%builtins</code>. Gives O(1) reverse-lookup for "list every op of kind X" queries that would otherwise be O(n) <code>grep</code>s. Name lists are alphabetized.</p>
<pre><code class="lang-perl">$c{parallel} |> e p # every parallel op
p scalar @{ $c{parallel} } # how many?
p join ", ", @{ $c{"array / list"} } # joined roster
keys %c |> sort |> p # all category names
</code></pre>
</article>
<article class="doc-entry" id="doc-stryke-descriptions">
<h3><a class="doc-anchor" href="#doc-stryke-descriptions">#</a> <code>%stryke::descriptions</code></h3>
<p><code>%stryke::descriptions</code> (short: <code>%d</code>) — name → one-line summary.</p>
<p>First sentence of each LSP hover doc (<code>doc_for_label_text</code>), harvested at build time. Sparse — only names that have a hover doc appear, so <code>exists $d{$name}</code> doubles as "is this documented?".</p>
<pre><code class="lang-perl">p $d{pmap} # one-line summary
p $d{to_json} # "Serialize a PerlValue to a JSON string."
p scalar keys %d # count of documented ops
keys %d |> grep { $d{_} =~ /parallel/i } |> sort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stryke-extensions">
<h3><a class="doc-anchor" href="#doc-stryke-extensions">#</a> <code>%stryke::extensions</code></h3>
<p><code>%stryke::extensions</code> (short: <code>%e</code>) — stryke-only names, name → category.</p>
<p>Disjoint from <code>%perl_compats</code>. Everything <code>--compat</code> mode rejects at parse time, plus dispatch primaries like <code>basename</code>/<code>ddump</code> that are extensions at runtime even without a parser entry.</p>
<pre><code class="lang-perl">p $e{pmap} # "parallel"
keys %e |> grep /^p/ |> sort |> p # every p* parallel op
</code></pre>
</article>
<article class="doc-entry" id="doc-stryke-perl-compats">
<h3><a class="doc-anchor" href="#doc-stryke-perl-compats">#</a> <code>%stryke::perl_compats</code></h3>
<p><code>%stryke::perl_compats</code> (short: <code>%pc</code>) — Perl 5 core names only, name → category.</p>
<p>Subset of <code>%builtins</code> restricted to names from <code>is_perl5_core</code>. Direct O(1) access for the "show me just Perl core" query.</p>
<pre><code class="lang-perl">p $pc{map} # "array / list"
p scalar keys %pc # core-only count
keys %pc |> sort |> p # enumerate every Perl core name
</code></pre>
</article>
<article class="doc-entry" id="doc-stryke-primaries">
<h3><a class="doc-anchor" href="#doc-stryke-primaries">#</a> <code>%stryke::primaries</code></h3>
<p><code>%stryke::primaries</code> (short: <code>%p</code>) — primary dispatcher name → arrayref of its aliases.</p>
<p>Inverted <code>%aliases</code>. Primaries with no aliases still have an entry (empty arrayref), so <code>exists $p{foo}</code> reliably answers "is foo a dispatch primary?" O(1).</p>
<pre><code class="lang-perl">$p{to_json} |> e p # ["tj"]
p scalar @{ $p{basename} } # how many aliases does basename have?
# find every primary that has at least one alias:
keys %p |> grep { scalar @{$p{_}} } |> sort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-core">
<h3><a class="doc-anchor" href="#doc-core">#</a> <code>CORE</code></h3>
<p><code>CORE::</code> — pseudo-namespace alias for every dispatch primary. Every callable bare name is also reachable as <code>CORE::name</code>, with identical semantics. The qualified spelling exists for tab-complete affordance and explicit-namespace style; stryke rejects redefining a builtin (<code>fn print { ... }</code> is a parse error), so there is nothing to shadow at runtime.</p>
<p>The set is built dynamically: any name in <code>keys %stryke::builtins</code> is a valid <code>CORE::name</code>. There's no separate <code>%CORE::</code> table — it's a virtual namespace resolved at dispatch time.</p>
<pre><code class="lang-perl">CORE::print "hello world\n" # ≡ print "hello world\n"
my $r = CORE::sum(1, 2, 3) # 6 — qualified call
map { CORE::sprintf("%d", _) } @nums # any builtin
</code></pre>
<p>The <code>s docs CORE::name</code> form resolves to the bare-name page (the alias and primary share docs). Aliases (<code>tj</code>, <code>bn</code>, <code>e</code>, …) also support <code>CORE::tj</code> / <code>CORE::bn</code> / <code>CORE::e</code>.</p>
</article>
<article class="doc-entry" id="doc-core-pipe">
<h3><a class="doc-anchor" href="#doc-core-pipe">#</a> <code>CORE::pipe</code></h3>
<p>Create a unidirectional pipe, returning a pair of connected filehandles: one for reading and one for writing. Data written to the write end can be read from the read end, making pipes the fundamental building block for inter-process communication. Commonly used with <code>fork</code> so the parent and child can exchange data.</p>
<pre><code class="lang-perl">pipe(my $rd, my $wr) or die "pipe: $!"
if (fork() == 0) {
close($rd)
print $wr "hello from child\n"
exit(0)
}
close($wr)
my $msg = <$rd>
p $msg # hello from child
</code></pre>
</article>
<article class="doc-entry" id="doc-a0">
<h3><a class="doc-anchor" href="#doc-a0">#</a> <code>a0</code></h3>
<p><code>bohr_radius</code> (alias <code>a0</code>) — a₀ ≈ 5.29×10⁻¹¹ m. Radius of hydrogen atom ground state.</p>
<pre><code class="lang-perl">p a0 # 5.29177210903e-11
</code></pre>
</article>
<article class="doc-entry" id="doc-a256">
<h3><a class="doc-anchor" href="#doc-a256">#</a> <code>a256</code></h3>
<p><code>a256</code> — color operations builtin. Alias for <code>ansi_256</code>.</p>
<pre><code class="lang-perl">my $result = a256 $x
# or in a pipeline:
@list |> map a256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-a3c-advantage-step">
<h3><a class="doc-anchor" href="#doc-a3c-advantage-step">#</a> <code>a3c_advantage_step</code></h3>
<p><code>a3c_advantage_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = a3c_advantage_step $x
# or in a pipeline:
@list |> map a3c_advantage_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-a85d">
<h3><a class="doc-anchor" href="#doc-a85d">#</a> <code>a85d</code></h3>
<p><code>base85_decode</code> (aliases <code>b85d</code>, <code>a85d</code>) decodes an Ascii85/Base85 encoded string.</p>
<pre><code class="lang-perl">p b85d(b85e("Hello")) # Hello
</code></pre>
</article>
<article class="doc-entry" id="doc-a85e">
<h3><a class="doc-anchor" href="#doc-a85e">#</a> <code>a85e</code></h3>
<p><code>base85_encode</code> (aliases <code>b85e</code>, <code>a85e</code>) encodes a string using Ascii85/Base85 encoding. More compact than Base64 (4:5 ratio vs 3:4).</p>
<pre><code class="lang-perl">p b85e("Hello") # encoded string
</code></pre>
</article>
<article class="doc-entry" id="doc-a-law-decode">
<h3><a class="doc-anchor" href="#doc-a-law-decode">#</a> <code>a_law_decode</code></h3>
<p><code>a_law_decode</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = a_law_decode $x
# or in a pipeline:
@list |> map a_law_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-a-law-encode">
<h3><a class="doc-anchor" href="#doc-a-law-encode">#</a> <code>a_law_encode</code></h3>
<p><code>a_law_encode</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = a_law_encode $x
# or in a pipeline:
@list |> map a_law_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ab1-step">
<h3><a class="doc-anchor" href="#doc-ab1-step">#</a> <code>ab1_step</code></h3>
<p><code>ab1_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = ab1_step $x
# or in a pipeline:
@list |> map ab1_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ab2-step">
<h3><a class="doc-anchor" href="#doc-ab2-step">#</a> <code>ab2_step</code></h3>
<p><code>ab2_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = ab2_step $x
# or in a pipeline:
@list |> map ab2_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ab3-step">
<h3><a class="doc-anchor" href="#doc-ab3-step">#</a> <code>ab3_step</code></h3>
<p><code>ab3_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = ab3_step $x
# or in a pipeline:
@list |> map ab3_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ab4">
<h3><a class="doc-anchor" href="#doc-ab4">#</a> <code>ab4</code></h3>
<p><code>ab4</code> — batch 19 builtin. Alias for <code>adams_bashforth_4</code>.</p>
<pre><code class="lang-perl">my $result = ab4 $x
# or in a pipeline:
@list |> map ab4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ab-coeff-sum">
<h3><a class="doc-anchor" href="#doc-ab-coeff-sum">#</a> <code>ab_coeff_sum</code></h3>
<p><code>ab_coeff_sum</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = ab_coeff_sum $x
# or in a pipeline:
@list |> map ab_coeff_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abelianization-quotient">
<h3><a class="doc-anchor" href="#doc-abelianization-quotient">#</a> <code>abelianization_quotient</code></h3>
<p><code>abelianization_quotient</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = abelianization_quotient $x
# or in a pipeline:
@list |> map abelianization_quotient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aberration-annual">
<h3><a class="doc-anchor" href="#doc-aberration-annual">#</a> <code>aberration_annual</code></h3>
<p><code>aberration_annual</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = aberration_annual $x
# or in a pipeline:
@list |> map aberration_annual |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aberth-step">
<h3><a class="doc-anchor" href="#doc-aberth-step">#</a> <code>aberth_step</code></h3>
<p><code>aberth_step</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = aberth_step $x
# or in a pipeline:
@list |> map aberth_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abs-ceil">
<h3><a class="doc-anchor" href="#doc-abs-ceil">#</a> <code>abs_ceil</code></h3>
<p><code>abs_ceil</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = abs_ceil $x
# or in a pipeline:
@list |> map abs_ceil |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abs-diff">
<h3><a class="doc-anchor" href="#doc-abs-diff">#</a> <code>abs_diff</code></h3>
<p><code>abs_diff</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = abs_diff $x
# or in a pipeline:
@list |> map abs_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abs-each">
<h3><a class="doc-anchor" href="#doc-abs-each">#</a> <code>abs_each</code></h3>
<p><code>abs_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = abs_each $x
# or in a pipeline:
@list |> map abs_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abs-floor">
<h3><a class="doc-anchor" href="#doc-abs-floor">#</a> <code>abs_floor</code></h3>
<p><code>abs_floor</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = abs_floor $x
# or in a pipeline:
@list |> map abs_floor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-absolute-magnitude">
<h3><a class="doc-anchor" href="#doc-absolute-magnitude">#</a> <code>absolute_magnitude</code></h3>
<p><code>absolute_magnitude</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = absolute_magnitude $x
# or in a pipeline:
@list |> map absolute_magnitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-absolute-vorticity-step">
<h3><a class="doc-anchor" href="#doc-absolute-vorticity-step">#</a> <code>absolute_vorticity_step</code></h3>
<p><code>absolute_vorticity_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = absolute_vorticity_step $x
# or in a pipeline:
@list |> map absolute_vorticity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-absorbed-short-wave">
<h3><a class="doc-anchor" href="#doc-absorbed-short-wave">#</a> <code>absorbed_short_wave</code></h3>
<p><code>absorbed_short_wave</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = absorbed_short_wave $x
# or in a pipeline:
@list |> map absorbed_short_wave |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abundant-numbers">
<h3><a class="doc-anchor" href="#doc-abundant-numbers">#</a> <code>abundant_numbers</code></h3>
<p><code>abundant_numbers</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = abundant_numbers $x
# or in a pipeline:
@list |> map abundant_numbers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abunnums">
<h3><a class="doc-anchor" href="#doc-abunnums">#</a> <code>abunnums</code></h3>
<p><code>abunnums</code> — number theory / primes builtin. Alias for <code>abundant_numbers</code>.</p>
<pre><code class="lang-perl">my $result = abunnums $x
# or in a pipeline:
@list |> map abunnums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abuse-test-voltage">
<h3><a class="doc-anchor" href="#doc-abuse-test-voltage">#</a> <code>abuse_test_voltage</code></h3>
<p><code>abuse_test_voltage</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = abuse_test_voltage $x
# or in a pipeline:
@list |> map abuse_test_voltage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-accept-lang-pick">
<h3><a class="doc-anchor" href="#doc-accept-lang-pick">#</a> <code>accept_lang_pick</code></h3>
<p><code>accept_lang_pick</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = accept_lang_pick $x
# or in a pipeline:
@list |> map accept_lang_pick |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acceptance-target">
<h3><a class="doc-anchor" href="#doc-acceptance-target">#</a> <code>acceptance_target</code></h3>
<p><code>acceptance_target</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = acceptance_target $x
# or in a pipeline:
@list |> map acceptance_target |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-accrint">
<h3><a class="doc-anchor" href="#doc-accrint">#</a> <code>accrint</code></h3>
<p><code>accrint</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = accrint $x
# or in a pipeline:
@list |> map accrint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-accrued-interest">
<h3><a class="doc-anchor" href="#doc-accrued-interest">#</a> <code>accrued_interest</code></h3>
<p><code>accrued_interest</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = accrued_interest $x
# or in a pipeline:
@list |> map accrued_interest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-accum">
<h3><a class="doc-anchor" href="#doc-accum">#</a> <code>accum</code></h3>
<p><code>accum</code> — python/ruby stdlib builtin. Alias for <code>accumulate</code>.</p>
<pre><code class="lang-perl">my $result = accum $x
# or in a pipeline:
@list |> map accum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-accumulate">
<h3><a class="doc-anchor" href="#doc-accumulate">#</a> <code>accumulate</code></h3>
<p><code>accumulate</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = accumulate $x
# or in a pipeline:
@list |> map accumulate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acf">
<h3><a class="doc-anchor" href="#doc-acf">#</a> <code>acf</code></h3>
<p><code>acf_fn</code> (alias <code>acf</code>) — autocorrelation function. Returns ACF values for lags 0..max_lag. Like R's acf().</p>
<pre><code class="lang-perl">my @a = @{acf([1,3,2,4,3,5,4,6], 5)}
p $a[0] # 1.0 (lag 0 is always 1)
p $a[1] # lag-1 autocorrelation
</code></pre>
</article>
<article class="doc-entry" id="doc-acf-basis">
<h3><a class="doc-anchor" href="#doc-acf-basis">#</a> <code>acf_basis</code></h3>
<p><code>acf_basis</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = acf_basis $x
# or in a pipeline:
@list |> map acf_basis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acirc">
<h3><a class="doc-anchor" href="#doc-acirc">#</a> <code>acirc</code></h3>
<p><code>acirc</code> — geometry / physics builtin. Alias for <code>area_circle</code>.</p>
<pre><code class="lang-perl">my $result = acirc $x
# or in a pipeline:
@list |> map acirc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acorr">
<h3><a class="doc-anchor" href="#doc-acorr">#</a> <code>acorr</code></h3>
<p><code>acorr</code> — math / numeric (uncategorized batch) builtin. Alias for <code>autocorrelation</code>.</p>
<pre><code class="lang-perl">my $result = acorr $x
# or in a pipeline:
@list |> map acorr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acos">
<h3><a class="doc-anchor" href="#doc-acos">#</a> <code>acos</code></h3>
<p><code>acos</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = acos $x
# or in a pipeline:
@list |> map acos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acosh">
<h3><a class="doc-anchor" href="#doc-acosh">#</a> <code>acosh</code></h3>
<p><code>acosh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = acosh $x
# or in a pipeline:
@list |> map acosh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acot">
<h3><a class="doc-anchor" href="#doc-acot">#</a> <code>acot</code></h3>
<p><code>acot</code> — trig extensions builtin.</p>
<pre><code class="lang-perl">my $result = acot $x
# or in a pipeline:
@list |> map acot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acro">
<h3><a class="doc-anchor" href="#doc-acro">#</a> <code>acro</code></h3>
<p><code>acro</code> — string processing (uncategorized batch) builtin. Alias for <code>acronym</code>.</p>
<pre><code class="lang-perl">my $result = acro $x
# or in a pipeline:
@list |> map acro |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acronym">
<h3><a class="doc-anchor" href="#doc-acronym">#</a> <code>acronym</code></h3>
<p><code>acronym</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = acronym $x
# or in a pipeline:
@list |> map acronym |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acsc">
<h3><a class="doc-anchor" href="#doc-acsc">#</a> <code>acsc</code></h3>
<p><code>acsc</code> — trig extensions builtin.</p>
<pre><code class="lang-perl">my $result = acsc $x
# or in a pipeline:
@list |> map acsc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adaboost-alpha">
<h3><a class="doc-anchor" href="#doc-adaboost-alpha">#</a> <code>adaboost_alpha</code></h3>
<p><code>adaboost_alpha</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = adaboost_alpha $x
# or in a pipeline:
@list |> map adaboost_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adagrad-step">
<h3><a class="doc-anchor" href="#doc-adagrad-step">#</a> <code>adagrad_step</code></h3>
<p><code>adagrad_step</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = adagrad_step $x
# or in a pipeline:
@list |> map adagrad_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adams-bashforth-4">
<h3><a class="doc-anchor" href="#doc-adams-bashforth-4">#</a> <code>adams_bashforth_4</code></h3>
<p><code>adams_bashforth_4</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = adams_bashforth_4 $x
# or in a pipeline:
@list |> map adams_bashforth_4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-add-days">
<h3><a class="doc-anchor" href="#doc-add-days">#</a> <code>add_days</code></h3>
<p><code>add_days</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = add_days $x
# or in a pipeline:
@list |> map add_days |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-add-hours">
<h3><a class="doc-anchor" href="#doc-add-hours">#</a> <code>add_hours</code></h3>
<p><code>add_hours</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = add_hours $x
# or in a pipeline:
@list |> map add_hours |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-add-minutes">
<h3><a class="doc-anchor" href="#doc-add-minutes">#</a> <code>add_minutes</code></h3>
<p><code>add_minutes</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = add_minutes $x
# or in a pipeline:
@list |> map add_minutes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-addd">
<h3><a class="doc-anchor" href="#doc-addd">#</a> <code>addd</code></h3>
<p><code>addd</code> — extended stdlib builtin. Alias for <code>add_days</code>.</p>
<pre><code class="lang-perl">my $result = addd $x
# or in a pipeline:
@list |> map addd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-addh">
<h3><a class="doc-anchor" href="#doc-addh">#</a> <code>addh</code></h3>
<p><code>addh</code> — extended stdlib builtin. Alias for <code>add_hours</code>.</p>
<pre><code class="lang-perl">my $result = addh $x
# or in a pipeline:
@list |> map addh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-addm">
<h3><a class="doc-anchor" href="#doc-addm">#</a> <code>addm</code></h3>
<p><code>addm</code> — extended stdlib builtin. Alias for <code>add_minutes</code>.</p>
<pre><code class="lang-perl">my $result = addm $x
# or in a pipeline:
@list |> map addm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adf-test-stat">
<h3><a class="doc-anchor" href="#doc-adf-test-stat">#</a> <code>adf_test_stat</code></h3>
<p><code>adf_test_stat</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = adf_test_stat $x
# or in a pipeline:
@list |> map adf_test_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adfuller">
<h3><a class="doc-anchor" href="#doc-adfuller">#</a> <code>adfuller</code></h3>
<p><code>adfuller</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = adfuller $x
# or in a pipeline:
@list |> map adfuller |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adiabatic-lapse-rate-dry">
<h3><a class="doc-anchor" href="#doc-adiabatic-lapse-rate-dry">#</a> <code>adiabatic_lapse_rate_dry</code></h3>
<p><code>adiabatic_lapse_rate_dry</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = adiabatic_lapse_rate_dry $x
# or in a pipeline:
@list |> map adiabatic_lapse_rate_dry |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adiabatic-lapse-rate-moist">
<h3><a class="doc-anchor" href="#doc-adiabatic-lapse-rate-moist">#</a> <code>adiabatic_lapse_rate_moist</code></h3>
<p><code>adiabatic_lapse_rate_moist</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = adiabatic_lapse_rate_moist $x
# or in a pipeline:
@list |> map adiabatic_lapse_rate_moist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adj-r2">
<h3><a class="doc-anchor" href="#doc-adj-r2">#</a> <code>adj_r2</code></h3>
<p><code>adj_r2</code> — batch 9 builtin. Alias for <code>adjusted_r_squared</code>.</p>
<pre><code class="lang-perl">my $result = adj_r2 $x
# or in a pipeline:
@list |> map adj_r2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adjacent-difference">
<h3><a class="doc-anchor" href="#doc-adjacent-difference">#</a> <code>adjacent_difference</code></h3>
<p><code>adjacent_difference</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = adjacent_difference $x
# or in a pipeline:
@list |> map adjacent_difference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adjacent-pairs">
<h3><a class="doc-anchor" href="#doc-adjacent-pairs">#</a> <code>adjacent_pairs</code></h3>
<p><code>adjacent_pairs</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = adjacent_pairs $x
# or in a pipeline:
@list |> map adjacent_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adjp">
<h3><a class="doc-anchor" href="#doc-adjp">#</a> <code>adjp</code></h3>
<p><code>adjp</code> — go/general functional utilities builtin. Alias for <code>adjacent_pairs</code>.</p>
<pre><code class="lang-perl">my $result = adjp $x
# or in a pipeline:
@list |> map adjp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adjusted-r-squared">
<h3><a class="doc-anchor" href="#doc-adjusted-r-squared">#</a> <code>adjusted_r_squared</code></h3>
<p><code>adjusted_r_squared</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = adjusted_r_squared $x
# or in a pipeline:
@list |> map adjusted_r_squared |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adjusted-winner-pct">
<h3><a class="doc-anchor" href="#doc-adjusted-winner-pct">#</a> <code>adjusted_winner_pct</code></h3>
<p><code>adjusted_winner_pct</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = adjusted_winner_pct $x
# or in a pipeline:
@list |> map adjusted_winner_pct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adl32">
<h3><a class="doc-anchor" href="#doc-adl32">#</a> <code>adl32</code></h3>
<p><code>adl32</code> — extended stdlib builtin. Alias for <code>adler32</code>.</p>
<pre><code class="lang-perl">my $result = adl32 $x
# or in a pipeline:
@list |> map adl32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adler32">
<h3><a class="doc-anchor" href="#doc-adler32">#</a> <code>adler32</code></h3>
<p><code>adler32</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = adler32 $x
# or in a pipeline:
@list |> map adler32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adler32-hash">
<h3><a class="doc-anchor" href="#doc-adler32-hash">#</a> <code>adler32_hash</code></h3>
<p><code>adler32_hash</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = adler32_hash $x
# or in a pipeline:
@list |> map adler32_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adm-mass-step">
<h3><a class="doc-anchor" href="#doc-adm-mass-step">#</a> <code>adm_mass_step</code></h3>
<p><code>adm_mass_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = adm_mass_step $x
# or in a pipeline:
@list |> map adm_mass_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-admm-dual-step">
<h3><a class="doc-anchor" href="#doc-admm-dual-step">#</a> <code>admm_dual_step</code></h3>
<p><code>admm_dual_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = admm_dual_step $x
# or in a pipeline:
@list |> map admm_dual_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-admm-primal-step">
<h3><a class="doc-anchor" href="#doc-admm-primal-step">#</a> <code>admm_primal_step</code></h3>
<p><code>admm_primal_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = admm_primal_step $x
# or in a pipeline:
@list |> map admm_primal_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ads-metric-step">
<h3><a class="doc-anchor" href="#doc-ads-metric-step">#</a> <code>ads_metric_step</code></h3>
<p><code>ads_metric_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = ads_metric_step $x
# or in a pipeline:
@list |> map ads_metric_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aellip">
<h3><a class="doc-anchor" href="#doc-aellip">#</a> <code>aellip</code></h3>
<p><code>aellip</code> — geometry / physics builtin. Alias for <code>area_ellipse</code>.</p>
<pre><code class="lang-perl">my $result = aellip $x
# or in a pipeline:
@list |> map aellip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aerosol-optical-depth">
<h3><a class="doc-anchor" href="#doc-aerosol-optical-depth">#</a> <code>aerosol_optical_depth</code></h3>
<p><code>aerosol_optical_depth</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = aerosol_optical_depth $x
# or in a pipeline:
@list |> map aerosol_optical_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-inv-sbox-byte">
<h3><a class="doc-anchor" href="#doc-aes-inv-sbox-byte">#</a> <code>aes_inv_sbox_byte</code></h3>
<p><code>aes_inv_sbox_byte</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = aes_inv_sbox_byte $x
# or in a pipeline:
@list |> map aes_inv_sbox_byte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-sbox-byte">
<h3><a class="doc-anchor" href="#doc-aes-sbox-byte">#</a> <code>aes_sbox_byte</code></h3>
<p><code>aes_sbox_byte</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = aes_sbox_byte $x
# or in a pipeline:
@list |> map aes_sbox_byte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-affine-encrypt">
<h3><a class="doc-anchor" href="#doc-affine-encrypt">#</a> <code>affine_encrypt</code></h3>
<p><code>affine_encrypt</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = affine_encrypt $x
# or in a pipeline:
@list |> map affine_encrypt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-african-monsoon-index">
<h3><a class="doc-anchor" href="#doc-african-monsoon-index">#</a> <code>african_monsoon_index</code></h3>
<p><code>african_monsoon_index</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = african_monsoon_index $x
# or in a pipeline:
@list |> map african_monsoon_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-after-n">
<h3><a class="doc-anchor" href="#doc-after-n">#</a> <code>after_n</code></h3>
<p><code>after_n</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = after_n $x
# or in a pipeline:
@list |> map after_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-age-at-date">
<h3><a class="doc-anchor" href="#doc-age-at-date">#</a> <code>age_at_date</code></h3>
<p><code>age_at_date</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = age_at_date $x
# or in a pipeline:
@list |> map age_at_date |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-age-at-z">
<h3><a class="doc-anchor" href="#doc-age-at-z">#</a> <code>age_at_z</code></h3>
<p><code>age_at_z</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = age_at_z $x
# or in a pipeline:
@list |> map age_at_z |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-age-from-birthdate">
<h3><a class="doc-anchor" href="#doc-age-from-birthdate">#</a> <code>age_from_birthdate</code></h3>
<p><code>age_from_birthdate</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = age_from_birthdate $x
# or in a pipeline:
@list |> map age_from_birthdate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-age-in-years">
<h3><a class="doc-anchor" href="#doc-age-in-years">#</a> <code>age_in_years</code></h3>
<p><code>age_in_years</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = age_in_years $x
# or in a pipeline:
@list |> map age_in_years |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ageyrs">
<h3><a class="doc-anchor" href="#doc-ageyrs">#</a> <code>ageyrs</code></h3>
<p><code>ageyrs</code> — extended stdlib batch 3 builtin. Alias for <code>age_in_years</code>.</p>
<pre><code class="lang-perl">my $result = ageyrs $x
# or in a pipeline:
@list |> map ageyrs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ai-agent">
<h3><a class="doc-anchor" href="#doc-ai-agent">#</a> <code>ai_agent</code></h3>
<p><code>ai_agent</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = ai_agent $x
# or in a pipeline:
@list |> map ai_agent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aic">
<h3><a class="doc-anchor" href="#doc-aic">#</a> <code>aic</code></h3>
<p><code>aic</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = aic $x
# or in a pipeline:
@list |> map aic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aig-simplify-step">
<h3><a class="doc-anchor" href="#doc-aig-simplify-step">#</a> <code>aig_simplify_step</code></h3>
<p><code>aig_simplify_step</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = aig_simplify_step $x
# or in a pipeline:
@list |> map aig_simplify_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ain">
<h3><a class="doc-anchor" href="#doc-ain">#</a> <code>ain</code></h3>
<p><code>ain</code> — algebraic match builtin. Alias for <code>assoc_in</code>.</p>
<pre><code class="lang-perl">my $result = ain $x
# or in a pipeline:
@list |> map ain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-air-mass-kasten">
<h3><a class="doc-anchor" href="#doc-air-mass-kasten">#</a> <code>air_mass_kasten</code></h3>
<p><code>air_mass_kasten</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = air_mass_kasten $x
# or in a pipeline:
@list |> map air_mass_kasten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-airy-disk-radius">
<h3><a class="doc-anchor" href="#doc-airy-disk-radius">#</a> <code>airy_disk_radius</code></h3>
<p><code>airy_disk_radius</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = airy_disk_radius $x
# or in a pipeline:
@list |> map airy_disk_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-airyai">
<h3><a class="doc-anchor" href="#doc-airyai">#</a> <code>airyai</code></h3>
<p><code>airyai</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = airyai $x
# or in a pipeline:
@list |> map airyai |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-airybi">
<h3><a class="doc-anchor" href="#doc-airybi">#</a> <code>airybi</code></h3>
<p><code>airybi</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = airybi $x
# or in a pipeline:
@list |> map airybi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aitken-delta-squared">
<h3><a class="doc-anchor" href="#doc-aitken-delta-squared">#</a> <code>aitken_delta_squared</code></h3>
<p><code>aitken_delta_squared</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = aitken_delta_squared $x
# or in a pipeline:
@list |> map aitken_delta_squared |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-akaike-info-crit">
<h3><a class="doc-anchor" href="#doc-akaike-info-crit">#</a> <code>akaike_info_crit</code></h3>
<p><code>akaike_info_crit</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = akaike_info_crit $x
# or in a pipeline:
@list |> map akaike_info_crit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aks-witness-count">
<h3><a class="doc-anchor" href="#doc-aks-witness-count">#</a> <code>aks_witness_count</code></h3>
<p><code>aks_witness_count</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = aks_witness_count $x
# or in a pipeline:
@list |> map aks_witness_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-albedo-blackbody-balance">
<h3><a class="doc-anchor" href="#doc-albedo-blackbody-balance">#</a> <code>albedo_blackbody_balance</code></h3>
<p><code>albedo_blackbody_balance</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = albedo_blackbody_balance $x
# or in a pipeline:
@list |> map albedo_blackbody_balance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-albers-conic-project">
<h3><a class="doc-anchor" href="#doc-albers-conic-project">#</a> <code>albers_conic_project</code></h3>
<p><code>albers_conic_project</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = albers_conic_project $x
# or in a pipeline:
@list |> map albers_conic_project |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-alexander-polynomial-at-one">
<h3><a class="doc-anchor" href="#doc-alexander-polynomial-at-one">#</a> <code>alexander_polynomial_at_one</code></h3>
<p><code>alexander_polynomial_at_one</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = alexander_polynomial_at_one $x
# or in a pipeline:
@list |> map alexander_polynomial_at_one |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-alfven-speed">
<h3><a class="doc-anchor" href="#doc-alfven-speed">#</a> <code>alfven_speed</code></h3>
<p><code>alfven_speed</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = alfven_speed $x
# or in a pipeline:
@list |> map alfven_speed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-algebraic-intersection-number">
<h3><a class="doc-anchor" href="#doc-algebraic-intersection-number">#</a> <code>algebraic_intersection_number</code></h3>
<p><code>algebraic_intersection_number</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = algebraic_intersection_number $x
# or in a pipeline:
@list |> map algebraic_intersection_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aliquot-sum">
<h3><a class="doc-anchor" href="#doc-aliquot-sum">#</a> <code>aliquot_sum</code></h3>
<p><code>aliquot_sum</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = aliquot_sum $x
# or in a pipeline:
@list |> map aliquot_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-distinct">
<h3><a class="doc-anchor" href="#doc-all-distinct">#</a> <code>all_distinct</code></h3>
<p><code>all_distinct</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = all_distinct $x
# or in a pipeline:
@list |> map all_distinct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-eq">
<h3><a class="doc-anchor" href="#doc-all-eq">#</a> <code>all_eq</code></h3>
<p><code>all_eq</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = all_eq $x
# or in a pipeline:
@list |> map all_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-match">
<h3><a class="doc-anchor" href="#doc-all-match">#</a> <code>all_match</code></h3>
<p><code>all_match</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = all_match $x
# or in a pipeline:
@list |> map all_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-pay-auction-step">
<h3><a class="doc-anchor" href="#doc-all-pay-auction-step">#</a> <code>all_pay_auction_step</code></h3>
<p><code>all_pay_auction_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = all_pay_auction_step $x
# or in a pipeline:
@list |> map all_pay_auction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-unique">
<h3><a class="doc-anchor" href="#doc-all-unique">#</a> <code>all_unique</code></h3>
<p><code>all_unique</code> — more list helpers builtin. Alias for <code>all_distinct</code>.</p>
<pre><code class="lang-perl">my $result = all_unique $x
# or in a pipeline:
@list |> map all_unique |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-allee-growth-step">
<h3><a class="doc-anchor" href="#doc-allee-growth-step">#</a> <code>allee_growth_step</code></h3>
<p><code>allee_growth_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = allee_growth_step $x
# or in a pipeline:
@list |> map allee_growth_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-allele-frequency">
<h3><a class="doc-anchor" href="#doc-allele-frequency">#</a> <code>allele_frequency</code></h3>
<p><code>allele_frequency</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = allele_frequency $x
# or in a pipeline:
@list |> map allele_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-alpha-fs">
<h3><a class="doc-anchor" href="#doc-alpha-fs">#</a> <code>alpha_fs</code></h3>
<p><code>fine_structure_constant</code> (alias <code>alpha_fs</code>) — α ≈ 1/137 ≈ 0.00730. Fundamental constant of electromagnetism.</p>
<pre><code class="lang-perl">p alpha_fs # 0.0072973525693
p 1 / alpha_fs # ~137.036
</code></pre>
</article>
<article class="doc-entry" id="doc-alt-az-to-ra-dec">
<h3><a class="doc-anchor" href="#doc-alt-az-to-ra-dec">#</a> <code>alt_az_to_ra_dec</code></h3>
<p><code>alt_az_to_ra_dec</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = alt_az_to_ra_dec $input
</code></pre>
</article>
<article class="doc-entry" id="doc-alternate-case">
<h3><a class="doc-anchor" href="#doc-alternate-case">#</a> <code>alternate_case</code></h3>
<p><code>alternate_case</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = alternate_case $x
# or in a pipeline:
@list |> map alternate_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-alternating-seq-sum">
<h3><a class="doc-anchor" href="#doc-alternating-seq-sum">#</a> <code>alternating_seq_sum</code></h3>
<p><code>alternating_seq_sum</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = alternating_seq_sum $x
# or in a pipeline:
@list |> map alternating_seq_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-always-false">
<h3><a class="doc-anchor" href="#doc-always-false">#</a> <code>always_false</code></h3>
<p><code>always_false</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = always_false $x
# or in a pipeline:
@list |> map always_false |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-always-true">
<h3><a class="doc-anchor" href="#doc-always-true">#</a> <code>always_true</code></h3>
<p><code>always_true</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = always_true $x
# or in a pipeline:
@list |> map always_true |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-am2-step">
<h3><a class="doc-anchor" href="#doc-am2-step">#</a> <code>am2_step</code></h3>
<p><code>am2_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = am2_step $x
# or in a pipeline:
@list |> map am2_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-am3-step">
<h3><a class="doc-anchor" href="#doc-am3-step">#</a> <code>am3_step</code></h3>
<p><code>am3_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = am3_step $x
# or in a pipeline:
@list |> map am3_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-am4-step">
<h3><a class="doc-anchor" href="#doc-am4-step">#</a> <code>am4_step</code></h3>
<p><code>am4_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = am4_step $x
# or in a pipeline:
@list |> map am4_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amari-alpha-div">
<h3><a class="doc-anchor" href="#doc-amari-alpha-div">#</a> <code>amari_alpha_div</code></h3>
<p><code>amari_alpha_div</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = amari_alpha_div $x
# or in a pipeline:
@list |> map amari_alpha_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amax">
<h3><a class="doc-anchor" href="#doc-amax">#</a> <code>amax</code></h3>
<p><code>amax</code> — extended stdlib builtin. Alias for <code>argmax</code>.</p>
<pre><code class="lang-perl">my $result = amax $x
# or in a pipeline:
@list |> map amax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amin">
<h3><a class="doc-anchor" href="#doc-amin">#</a> <code>amin</code></h3>
<p><code>amin</code> — extended stdlib builtin. Alias for <code>argmin</code>.</p>
<pre><code class="lang-perl">my $result = amin $x
# or in a pipeline:
@list |> map amin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amo-index-step">
<h3><a class="doc-anchor" href="#doc-amo-index-step">#</a> <code>amo_index_step</code></h3>
<p><code>amo_index_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = amo_index_step $x
# or in a pipeline:
@list |> map amo_index_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amort">
<h3><a class="doc-anchor" href="#doc-amort">#</a> <code>amort</code></h3>
<p><code>amortization_schedule($principal, $rate, $periods)</code> (alias <code>amort</code>) — generates a full amortization schedule. Returns arrayref of hashrefs with period, payment, principal, interest, balance.</p>
<pre><code class="lang-perl">my $sched = amort(10000, 0.05, 12)
for my $row (@$sched) {
p "Period $row->{period}: bal=$row->{balance}"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-amortization-total-interest">
<h3><a class="doc-anchor" href="#doc-amortization-total-interest">#</a> <code>amortization_total_interest</code></h3>
<p><code>amortization_total_interest</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = amortization_total_interest $x
# or in a pipeline:
@list |> map amortization_total_interest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amp-to-db">
<h3><a class="doc-anchor" href="#doc-amp-to-db">#</a> <code>amp_to_db</code></h3>
<p><code>amp_to_db</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = amp_to_db $input
</code></pre>
</article>
<article class="doc-entry" id="doc-amphoteric-check">
<h3><a class="doc-anchor" href="#doc-amphoteric-check">#</a> <code>amphoteric_check</code></h3>
<p><code>amphoteric_check</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = amphoteric_check $x
# or in a pipeline:
@list |> map amphoteric_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amplitude-damping-channel">
<h3><a class="doc-anchor" href="#doc-amplitude-damping-channel">#</a> <code>amplitude_damping_channel</code></h3>
<p><code>amplitude_damping_channel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = amplitude_damping_channel $x
# or in a pipeline:
@list |> map amplitude_damping_channel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amplitude-damping-excited">
<h3><a class="doc-anchor" href="#doc-amplitude-damping-excited">#</a> <code>amplitude_damping_excited</code></h3>
<p><code>amplitude_damping_excited</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = amplitude_damping_excited $x
# or in a pipeline:
@list |> map amplitude_damping_excited |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amu">
<h3><a class="doc-anchor" href="#doc-amu">#</a> <code>amu</code></h3>
<p><code>amu</code> — physics constants builtin. Alias for <code>atomic_mass_unit</code>.</p>
<pre><code class="lang-perl">my $result = amu $x
# or in a pipeline:
@list |> map amu |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-anagram-q">
<h3><a class="doc-anchor" href="#doc-anagram-q">#</a> <code>anagram_q</code></h3>
<p><code>anagram_q</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = anagram_q $x
# or in a pipeline:
@list |> map anagram_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-anaphora-distance">
<h3><a class="doc-anchor" href="#doc-anaphora-distance">#</a> <code>anaphora_distance</code></h3>
<p><code>anaphora_distance</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = anaphora_distance $x
# or in a pipeline:
@list |> map anaphora_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ancilla-alloc">
<h3><a class="doc-anchor" href="#doc-ancilla-alloc">#</a> <code>ancilla_alloc</code></h3>
<p><code>ancilla_alloc</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = ancilla_alloc $x
# or in a pipeline:
@list |> map ancilla_alloc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-and">
<h3><a class="doc-anchor" href="#doc-and">#</a> <code>and</code></h3>
<p><code>and</code> — control flow builtin.</p>
<pre><code class="lang-perl">my $result = and $x
# or in a pipeline:
@list |> map and |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-and-list">
<h3><a class="doc-anchor" href="#doc-and-list">#</a> <code>and_list</code></h3>
<p><code>and_list</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = and_list $x
# or in a pipeline:
@list |> map and_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-anderson-darling">
<h3><a class="doc-anchor" href="#doc-anderson-darling">#</a> <code>anderson_darling</code></h3>
<p><code>anderson_darling</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = anderson_darling $x
# or in a pipeline:
@list |> map anderson_darling |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-anderson-step">
<h3><a class="doc-anchor" href="#doc-anderson-step">#</a> <code>anderson_step</code></h3>
<p><code>anderson_step</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = anderson_step $x
# or in a pipeline:
@list |> map anderson_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-andl">
<h3><a class="doc-anchor" href="#doc-andl">#</a> <code>andl</code></h3>
<p><code>andl</code> — additional missing stdlib functions builtin. Alias for <code>and_list</code>.</p>
<pre><code class="lang-perl">my $result = andl $x
# or in a pipeline:
@list |> map andl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-andoyer-dist">
<h3><a class="doc-anchor" href="#doc-andoyer-dist">#</a> <code>andoyer_dist</code></h3>
<p><code>andoyer_dist</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = andoyer_dist $x
# or in a pipeline:
@list |> map andoyer_dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-andrew-monotone-chain">
<h3><a class="doc-anchor" href="#doc-andrew-monotone-chain">#</a> <code>andrew_monotone_chain</code></h3>
<p><code>andrew_monotone_chain</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = andrew_monotone_chain $x
# or in a pipeline:
@list |> map andrew_monotone_chain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angbet">
<h3><a class="doc-anchor" href="#doc-angbet">#</a> <code>angbet</code></h3>
<p><code>angbet</code> — geometry (extended) builtin. Alias for <code>angle_between</code>.</p>
<pre><code class="lang-perl">my $result = angbet $x
# or in a pipeline:
@list |> map angbet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angle-between">
<h3><a class="doc-anchor" href="#doc-angle-between">#</a> <code>angle_between</code></h3>
<p><code>angle_between($x1, $y1, $x2, $y2)</code> — computes the angle in radians between two 2D vectors from origin. Returns the angle using atan2.</p>
<pre><code class="lang-perl">my $angle = angle_between(1, 0, 0, 1)
p $angle # ~1.5708 (π/2 radians = 90°)
</code></pre>
</article>
<article class="doc-entry" id="doc-angle-between-deg">
<h3><a class="doc-anchor" href="#doc-angle-between-deg">#</a> <code>angle_between_deg</code></h3>
<p><code>angle_between_deg</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = angle_between_deg $x
# or in a pipeline:
@list |> map angle_between_deg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angle-bracket">
<h3><a class="doc-anchor" href="#doc-angle-bracket">#</a> <code>angle_bracket</code></h3>
<p><code>angle_bracket</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = angle_bracket $x
# or in a pipeline:
@list |> map angle_bracket |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angular-diameter-distance">
<h3><a class="doc-anchor" href="#doc-angular-diameter-distance">#</a> <code>angular_diameter_distance</code></h3>
<p><code>angular_diameter_distance</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = angular_diameter_distance $x
# or in a pipeline:
@list |> map angular_diameter_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angular-velocity">
<h3><a class="doc-anchor" href="#doc-angular-velocity">#</a> <code>angular_velocity</code></h3>
<p><code>angular_velocity</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = angular_velocity $x
# or in a pipeline:
@list |> map angular_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angvel">
<h3><a class="doc-anchor" href="#doc-angvel">#</a> <code>angvel</code></h3>
<p><code>angvel</code> — physics formulas builtin. Alias for <code>angular_velocity</code>.</p>
<pre><code class="lang-perl">my $result = angvel $x
# or in a pipeline:
@list |> map angvel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-annuity-due-an">
<h3><a class="doc-anchor" href="#doc-annuity-due-an">#</a> <code>annuity_due_an</code></h3>
<p><code>annuity_due_an</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = annuity_due_an $x
# or in a pipeline:
@list |> map annuity_due_an |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-annuity-future-value">
<h3><a class="doc-anchor" href="#doc-annuity-future-value">#</a> <code>annuity_future_value</code></h3>
<p><code>annuity_future_value</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = annuity_future_value $x
# or in a pipeline:
@list |> map annuity_future_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-annuity-immediate-an">
<h3><a class="doc-anchor" href="#doc-annuity-immediate-an">#</a> <code>annuity_immediate_an</code></h3>
<p><code>annuity_immediate_an</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = annuity_immediate_an $x
# or in a pipeline:
@list |> map annuity_immediate_an |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-annuity-present-value">
<h3><a class="doc-anchor" href="#doc-annuity-present-value">#</a> <code>annuity_present_value</code></h3>
<p><code>annuity_present_value</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = annuity_present_value $x
# or in a pipeline:
@list |> map annuity_present_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-anova">
<h3><a class="doc-anchor" href="#doc-anova">#</a> <code>anova</code></h3>
<p><code>anova_oneway</code> (aliases <code>anova</code>, <code>anova1</code>) performs one-way ANOVA. Returns [F-statistic, df_between, df_within].</p>
<pre><code class="lang-perl">my ($F, $dfb, $dfw) = @{anova([1,2,3], [4,5,6], [7,8,9])}
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-256">
<h3><a class="doc-anchor" href="#doc-ansi-256">#</a> <code>ansi_256</code></h3>
<p><code>ansi_256</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = ansi_256 $x
# or in a pipeline:
@list |> map ansi_256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-black">
<h3><a class="doc-anchor" href="#doc-ansi-black">#</a> <code>ansi_black</code></h3>
<p><code>ansi_black</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_black $x
# or in a pipeline:
@list |> map ansi_black |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-blue">
<h3><a class="doc-anchor" href="#doc-ansi-blue">#</a> <code>ansi_blue</code></h3>
<p><code>ansi_blue</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_blue $x
# or in a pipeline:
@list |> map ansi_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-bold">
<h3><a class="doc-anchor" href="#doc-ansi-bold">#</a> <code>ansi_bold</code></h3>
<p><code>ansi_bold</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_bold $x
# or in a pipeline:
@list |> map ansi_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-cyan">
<h3><a class="doc-anchor" href="#doc-ansi-cyan">#</a> <code>ansi_cyan</code></h3>
<p><code>ansi_cyan</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_cyan $x
# or in a pipeline:
@list |> map ansi_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-dim">
<h3><a class="doc-anchor" href="#doc-ansi-dim">#</a> <code>ansi_dim</code></h3>
<p><code>ansi_dim</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_dim $x
# or in a pipeline:
@list |> map ansi_dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-green">
<h3><a class="doc-anchor" href="#doc-ansi-green">#</a> <code>ansi_green</code></h3>
<p><code>ansi_green</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_green $x
# or in a pipeline:
@list |> map ansi_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-magenta">
<h3><a class="doc-anchor" href="#doc-ansi-magenta">#</a> <code>ansi_magenta</code></h3>
<p><code>ansi_magenta</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_magenta $x
# or in a pipeline:
@list |> map ansi_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-off">
<h3><a class="doc-anchor" href="#doc-ansi-off">#</a> <code>ansi_off</code></h3>
<p><code>ansi_off</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = ansi_off $x
# or in a pipeline:
@list |> map ansi_off |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-red">
<h3><a class="doc-anchor" href="#doc-ansi-red">#</a> <code>ansi_red</code></h3>
<p><code>ansi_red</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_red $x
# or in a pipeline:
@list |> map ansi_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-reverse">
<h3><a class="doc-anchor" href="#doc-ansi-reverse">#</a> <code>ansi_reverse</code></h3>
<p><code>ansi_reverse</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_reverse $x
# or in a pipeline:
@list |> map ansi_reverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-truecolor">
<h3><a class="doc-anchor" href="#doc-ansi-truecolor">#</a> <code>ansi_truecolor</code></h3>
<p><code>ansi_truecolor</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = ansi_truecolor $x
# or in a pipeline:
@list |> map ansi_truecolor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-underline">
<h3><a class="doc-anchor" href="#doc-ansi-underline">#</a> <code>ansi_underline</code></h3>
<p><code>ansi_underline</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_underline $x
# or in a pipeline:
@list |> map ansi_underline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-white">
<h3><a class="doc-anchor" href="#doc-ansi-white">#</a> <code>ansi_white</code></h3>
<p><code>ansi_white</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_white $x
# or in a pipeline:
@list |> map ansi_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-yellow">
<h3><a class="doc-anchor" href="#doc-ansi-yellow">#</a> <code>ansi_yellow</code></h3>
<p><code>ansi_yellow</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_yellow $x
# or in a pipeline:
@list |> map ansi_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-anti-de-sitter-radius-step">
<h3><a class="doc-anchor" href="#doc-anti-de-sitter-radius-step">#</a> <code>anti_de_sitter_radius_step</code></h3>
<p><code>anti_de_sitter_radius_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = anti_de_sitter_radius_step $x
# or in a pipeline:
@list |> map anti_de_sitter_radius_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-antoine-p">
<h3><a class="doc-anchor" href="#doc-antoine-p">#</a> <code>antoine_p</code></h3>
<p><code>antoine_p</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = antoine_p $x
# or in a pipeline:
@list |> map antoine_p |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-any-match">
<h3><a class="doc-anchor" href="#doc-any-match">#</a> <code>any_match</code></h3>
<p><code>any_match</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = any_match $x
# or in a pipeline:
@list |> map any_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aov">
<h3><a class="doc-anchor" href="#doc-aov">#</a> <code>aov</code></h3>
<p><code>aov</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = aov $x
# or in a pipeline:
@list |> map aov |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ap-jonker-volgenant-step">
<h3><a class="doc-anchor" href="#doc-ap-jonker-volgenant-step">#</a> <code>ap_jonker_volgenant_step</code></h3>
<p><code>ap_jonker_volgenant_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = ap_jonker_volgenant_step $x
# or in a pipeline:
@list |> map ap_jonker_volgenant_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apery">
<h3><a class="doc-anchor" href="#doc-apery">#</a> <code>apery</code></h3>
<p><code>apery</code> — math constants builtin. Alias for <code>apery_constant</code>.</p>
<pre><code class="lang-perl">my $result = apery $x
# or in a pipeline:
@list |> map apery |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apery-constant">
<h3><a class="doc-anchor" href="#doc-apery-constant">#</a> <code>apery_constant</code></h3>
<p><code>apery_constant</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = apery_constant $x
# or in a pipeline:
@list |> map apery_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apparent-horizon-step">
<h3><a class="doc-anchor" href="#doc-apparent-horizon-step">#</a> <code>apparent_horizon_step</code></h3>
<p><code>apparent_horizon_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = apparent_horizon_step $x
# or in a pipeline:
@list |> map apparent_horizon_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-append-elem">
<h3><a class="doc-anchor" href="#doc-append-elem">#</a> <code>append_elem</code></h3>
<p><code>append_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = append_elem $x
# or in a pipeline:
@list |> map append_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-append-redis">
<h3><a class="doc-anchor" href="#doc-append-redis">#</a> <code>append_redis</code></h3>
<p><code>append_redis</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = append_redis $x
# or in a pipeline:
@list |> map append_redis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-appl">
<h3><a class="doc-anchor" href="#doc-appl">#</a> <code>appl</code></h3>
<p><code>appl</code> — algebraic match builtin. Alias for <code>apply</code>.</p>
<pre><code class="lang-perl">my $result = appl $x
# or in a pipeline:
@list |> map appl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apply">
<h3><a class="doc-anchor" href="#doc-apply">#</a> <code>apply</code></h3>
<p><code>apply</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = apply $x
# or in a pipeline:
@list |> map apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apply-list">
<h3><a class="doc-anchor" href="#doc-apply-list">#</a> <code>apply_list</code></h3>
<p><code>apply_list</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = apply_list $x
# or in a pipeline:
@list |> map apply_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apply-window">
<h3><a class="doc-anchor" href="#doc-apply-window">#</a> <code>apply_window</code></h3>
<p><code>apply_window(\@signal, \@window)</code> — element-wise multiplies signal by window function. Use before FFT to reduce spectral leakage.</p>
<pre><code class="lang-perl">my $w = hann(scalar @signal)
my $windowed = apply_window(\@signal, $w)
my $spectrum = dft($windowed)
</code></pre>
</article>
<article class="doc-entry" id="doc-applywin">
<h3><a class="doc-anchor" href="#doc-applywin">#</a> <code>applywin</code></h3>
<p><code>applywin</code> — dsp / signal (extended) builtin. Alias for <code>apply_window</code>.</p>
<pre><code class="lang-perl">my $result = applywin $x
# or in a pipeline:
@list |> map applywin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-approval-voting-max">
<h3><a class="doc-anchor" href="#doc-approval-voting-max">#</a> <code>approval_voting_max</code></h3>
<p><code>approval_voting_max</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = approval_voting_max $x
# or in a pipeline:
@list |> map approval_voting_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-approx">
<h3><a class="doc-anchor" href="#doc-approx">#</a> <code>approx</code></h3>
<p><code>approx_fn</code> (alias <code>approx</code>) — piecewise linear interpolation at query points. Like R's approx().</p>
<pre><code class="lang-perl">my @y = @{approx([0,1,2], [0,10,0], [0.5, 1.0, 1.5])}
# [5, 10, 5]
</code></pre>
</article>
<article class="doc-entry" id="doc-approx-eq">
<h3><a class="doc-anchor" href="#doc-approx-eq">#</a> <code>approx_eq</code></h3>
<p><code>approx_eq</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = approx_eq $x
# or in a pipeline:
@list |> map approx_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-approximate-entropy">
<h3><a class="doc-anchor" href="#doc-approximate-entropy">#</a> <code>approximate_entropy</code></h3>
<p><code>approximate_entropy</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = approximate_entropy $x
# or in a pipeline:
@list |> map approximate_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apr-to-apy">
<h3><a class="doc-anchor" href="#doc-apr-to-apy">#</a> <code>apr_to_apy</code></h3>
<p><code>apr_to_apy</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = apr_to_apy $input
</code></pre>
</article>
<article class="doc-entry" id="doc-apsp">
<h3><a class="doc-anchor" href="#doc-apsp">#</a> <code>apsp</code></h3>
<p><code>floyd_warshall</code> (aliases <code>floydwarshall</code>, <code>apsp</code>) computes all-pairs shortest paths. Takes a distance matrix (use Inf for no edge).</p>
<pre><code class="lang-perl">my $d = apsp([[0,3,1e18],[1e18,0,1],[1e18,1e18,0]])
</code></pre>
</article>
<article class="doc-entry" id="doc-apy-to-apr">
<h3><a class="doc-anchor" href="#doc-apy-to-apr">#</a> <code>apy_to_apr</code></h3>
<p><code>apy_to_apr</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = apy_to_apr $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ar-model-likelihood">
<h3><a class="doc-anchor" href="#doc-ar-model-likelihood">#</a> <code>ar_model_likelihood</code></h3>
<p><code>ar_model_likelihood</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = ar_model_likelihood $x
# or in a pipeline:
@list |> map ar_model_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arange">
<h3><a class="doc-anchor" href="#doc-arange">#</a> <code>arange</code></h3>
<p><code>arange</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = arange $x
# or in a pipeline:
@list |> map arange |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arc-length">
<h3><a class="doc-anchor" href="#doc-arc-length">#</a> <code>arc_length</code></h3>
<p><code>arc_length($radius, $theta)</code> — computes the arc length of a circular arc. Theta is the central angle in radians. Returns <code>radius * theta</code>.</p>
<pre><code class="lang-perl">p arc_length(10, 3.14159) # ~31.4 (half circle)
p arc_length(5, 1.57) # ~7.85 (quarter circle)
</code></pre>
</article>
<article class="doc-entry" id="doc-arch-lm">
<h3><a class="doc-anchor" href="#doc-arch-lm">#</a> <code>arch_lm</code></h3>
<p><code>arch_lm</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = arch_lm $x
# or in a pipeline:
@list |> map arch_lm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arch-lm-test">
<h3><a class="doc-anchor" href="#doc-arch-lm-test">#</a> <code>arch_lm_test</code></h3>
<p><code>arch_lm_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = arch_lm_test $x
# or in a pipeline:
@list |> map arch_lm_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arclen">
<h3><a class="doc-anchor" href="#doc-arclen">#</a> <code>arclen</code></h3>
<p><code>arclen</code> — geometry (extended) builtin. Alias for <code>arc_length</code>.</p>
<pre><code class="lang-perl">my $result = arclen $x
# or in a pipeline:
@list |> map arclen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arctic-oscillation-step">
<h3><a class="doc-anchor" href="#doc-arctic-oscillation-step">#</a> <code>arctic_oscillation_step</code></h3>
<p><code>arctic_oscillation_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = arctic_oscillation_step $x
# or in a pipeline:
@list |> map arctic_oscillation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-circle">
<h3><a class="doc-anchor" href="#doc-area-circle">#</a> <code>area_circle</code></h3>
<p><code>area_circle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_circle $x
# or in a pipeline:
@list |> map area_circle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-ellipse">
<h3><a class="doc-anchor" href="#doc-area-ellipse">#</a> <code>area_ellipse</code></h3>
<p><code>area_ellipse</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_ellipse $x
# or in a pipeline:
@list |> map area_ellipse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-rectangle">
<h3><a class="doc-anchor" href="#doc-area-rectangle">#</a> <code>area_rectangle</code></h3>
<p><code>area_rectangle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_rectangle $x
# or in a pipeline:
@list |> map area_rectangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-trapezoid">
<h3><a class="doc-anchor" href="#doc-area-trapezoid">#</a> <code>area_trapezoid</code></h3>
<p><code>area_trapezoid</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_trapezoid $x
# or in a pipeline:
@list |> map area_trapezoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-triangle">
<h3><a class="doc-anchor" href="#doc-area-triangle">#</a> <code>area_triangle</code></h3>
<p><code>area_triangle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_triangle $x
# or in a pipeline:
@list |> map area_triangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arect">
<h3><a class="doc-anchor" href="#doc-arect">#</a> <code>arect</code></h3>
<p><code>arect</code> — geometry / physics builtin. Alias for <code>area_rectangle</code>.</p>
<pre><code class="lang-perl">my $result = arect $x
# or in a pipeline:
@list |> map arect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arellano-bond-step">
<h3><a class="doc-anchor" href="#doc-arellano-bond-step">#</a> <code>arellano_bond_step</code></h3>
<p><code>arellano_bond_step</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = arellano_bond_step $x
# or in a pipeline:
@list |> map arellano_bond_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argc">
<h3><a class="doc-anchor" href="#doc-argc">#</a> <code>argc</code></h3>
<p><code>argc</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = argc $x
# or in a pipeline:
@list |> map argc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argmax">
<h3><a class="doc-anchor" href="#doc-argmax">#</a> <code>argmax</code></h3>
<p><code>argmax</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = argmax $x
# or in a pipeline:
@list |> map argmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argmin">
<h3><a class="doc-anchor" href="#doc-argmin">#</a> <code>argmin</code></h3>
<p><code>argmin</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = argmin $x
# or in a pipeline:
@list |> map argmin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argon2-block-mix">
<h3><a class="doc-anchor" href="#doc-argon2-block-mix">#</a> <code>argon2_block_mix</code></h3>
<p><code>argon2_block_mix</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = argon2_block_mix $x
# or in a pipeline:
@list |> map argon2_block_mix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argpartition">
<h3><a class="doc-anchor" href="#doc-argpartition">#</a> <code>argpartition</code></h3>
<p><code>argpartition</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = argpartition $x
# or in a pipeline:
@list |> map argpartition |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argsort">
<h3><a class="doc-anchor" href="#doc-argsort">#</a> <code>argsort</code></h3>
<p><code>argsort</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = argsort $x
# or in a pipeline:
@list |> map argsort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ari">
<h3><a class="doc-anchor" href="#doc-ari">#</a> <code>ari</code></h3>
<p><code>ari</code> — batch 9 builtin. Alias for <code>automated_readability_index</code>.</p>
<pre><code class="lang-perl">my $result = ari $x
# or in a pipeline:
@list |> map ari |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arias-intensity">
<h3><a class="doc-anchor" href="#doc-arias-intensity">#</a> <code>arias_intensity</code></h3>
<p><code>arias_intensity</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = arias_intensity $x
# or in a pipeline:
@list |> map arias_intensity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arima-diff">
<h3><a class="doc-anchor" href="#doc-arima-diff">#</a> <code>arima_diff</code></h3>
<p><code>arima_diff</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = arima_diff $x
# or in a pipeline:
@list |> map arima_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arima-fit">
<h3><a class="doc-anchor" href="#doc-arima-fit">#</a> <code>arima_fit</code></h3>
<p><code>arima_fit</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = arima_fit $x
# or in a pipeline:
@list |> map arima_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arima-forecast">
<h3><a class="doc-anchor" href="#doc-arima-forecast">#</a> <code>arima_forecast</code></h3>
<p><code>arima_forecast</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = arima_forecast $x
# or in a pipeline:
@list |> map arima_forecast |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arithmetic-coding-interval">
<h3><a class="doc-anchor" href="#doc-arithmetic-coding-interval">#</a> <code>arithmetic_coding_interval</code></h3>
<p><code>arithmetic_coding_interval</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = arithmetic_coding_interval $x
# or in a pipeline:
@list |> map arithmetic_coding_interval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arithmetic-decode-interval">
<h3><a class="doc-anchor" href="#doc-arithmetic-decode-interval">#</a> <code>arithmetic_decode_interval</code></h3>
<p><code>arithmetic_decode_interval</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = arithmetic_decode_interval $x
# or in a pipeline:
@list |> map arithmetic_decode_interval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arithmetic-sequence">
<h3><a class="doc-anchor" href="#doc-arithmetic-sequence">#</a> <code>arithmetic_sequence</code></h3>
<p><code>arithmetic_sequence</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = arithmetic_sequence $x
# or in a pipeline:
@list |> map arithmetic_sequence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arithmetic-series">
<h3><a class="doc-anchor" href="#doc-arithmetic-series">#</a> <code>arithmetic_series</code></h3>
<p><code>arithmetic_series($a1, $d, $n)</code> (alias <code>arithser</code>) — sum of n terms of arithmetic sequence starting at a1 with common difference d. Formula: n/2 × (2a1 + (n-1)d).</p>
<pre><code class="lang-perl">p arithser(1, 1, 100) # 5050 (1+2+...+100)
p arithser(2, 3, 10) # 155 (2+5+8+...+29)
</code></pre>
</article>
<article class="doc-entry" id="doc-arity-of">
<h3><a class="doc-anchor" href="#doc-arity-of">#</a> <code>arity_of</code></h3>
<p><code>arity_of</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = arity_of $x
# or in a pipeline:
@list |> map arity_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arma-model-innovation">
<h3><a class="doc-anchor" href="#doc-arma-model-innovation">#</a> <code>arma_model_innovation</code></h3>
<p><code>arma_model_innovation</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = arma_model_innovation $x
# or in a pipeline:
@list |> map arma_model_innovation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arma-order-select">
<h3><a class="doc-anchor" href="#doc-arma-order-select">#</a> <code>arma_order_select</code></h3>
<p><code>arma_order_select</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = arma_order_select $x
# or in a pipeline:
@list |> map arma_order_select |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-armstrong-q">
<h3><a class="doc-anchor" href="#doc-armstrong-q">#</a> <code>armstrong_q</code></h3>
<p><code>armstrong_q</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = armstrong_q $x
# or in a pipeline:
@list |> map armstrong_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-agg">
<h3><a class="doc-anchor" href="#doc-array-agg">#</a> <code>array_agg</code></h3>
<p><code>array_agg</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = array_agg $x
# or in a pipeline:
@list |> map array_agg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-difference">
<h3><a class="doc-anchor" href="#doc-array-difference">#</a> <code>array_difference</code></h3>
<p><code>array_difference</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = array_difference $x
# or in a pipeline:
@list |> map array_difference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-intersection">
<h3><a class="doc-anchor" href="#doc-array-intersection">#</a> <code>array_intersection</code></h3>
<p><code>array_intersection</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = array_intersection $x
# or in a pipeline:
@list |> map array_intersection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-position">
<h3><a class="doc-anchor" href="#doc-array-position">#</a> <code>array_position</code></h3>
<p><code>array_position</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = array_position $x
# or in a pipeline:
@list |> map array_position |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-positions">
<h3><a class="doc-anchor" href="#doc-array-positions">#</a> <code>array_positions</code></h3>
<p><code>array_positions</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = array_positions $x
# or in a pipeline:
@list |> map array_positions |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-remove">
<h3><a class="doc-anchor" href="#doc-array-remove">#</a> <code>array_remove</code></h3>
<p><code>array_remove</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = array_remove $x
# or in a pipeline:
@list |> map array_remove |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-replace">
<h3><a class="doc-anchor" href="#doc-array-replace">#</a> <code>array_replace</code></h3>
<p><code>array_replace</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = array_replace $x
# or in a pipeline:
@list |> map array_replace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-to-hstore">
<h3><a class="doc-anchor" href="#doc-array-to-hstore">#</a> <code>array_to_hstore</code></h3>
<p><code>array_to_hstore</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = array_to_hstore $input
</code></pre>
</article>
<article class="doc-entry" id="doc-array-to-jsonb">
<h3><a class="doc-anchor" href="#doc-array-to-jsonb">#</a> <code>array_to_jsonb</code></h3>
<p><code>array_to_jsonb</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = array_to_jsonb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-array-to-string">
<h3><a class="doc-anchor" href="#doc-array-to-string">#</a> <code>array_to_string</code></h3>
<p><code>array_to_string</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = array_to_string $input
</code></pre>
</article>
<article class="doc-entry" id="doc-array-union">
<h3><a class="doc-anchor" href="#doc-array-union">#</a> <code>array_union</code></h3>
<p><code>array_union</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = array_union $x
# or in a pipeline:
@list |> map array_union |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arrhenius-k">
<h3><a class="doc-anchor" href="#doc-arrhenius-k">#</a> <code>arrhenius_k</code></h3>
<p><code>arrhenius_k</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = arrhenius_k $x
# or in a pipeline:
@list |> map arrhenius_k |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arrhenius-temp-q10">
<h3><a class="doc-anchor" href="#doc-arrhenius-temp-q10">#</a> <code>arrhenius_temp_q10</code></h3>
<p><code>arrhenius_temp_q10</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = arrhenius_temp_q10 $x
# or in a pipeline:
@list |> map arrhenius_temp_q10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arrow-impossibility-check">
<h3><a class="doc-anchor" href="#doc-arrow-impossibility-check">#</a> <code>arrow_impossibility_check</code></h3>
<p><code>arrow_impossibility_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = arrow_impossibility_check $x
# or in a pipeline:
@list |> map arrow_impossibility_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arrow-independence">
<h3><a class="doc-anchor" href="#doc-arrow-independence">#</a> <code>arrow_independence</code></h3>
<p><code>arrow_independence</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = arrow_independence $x
# or in a pipeline:
@list |> map arrow_independence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arrow-pareto-check">
<h3><a class="doc-anchor" href="#doc-arrow-pareto-check">#</a> <code>arrow_pareto_check</code></h3>
<p><code>arrow_pareto_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = arrow_pareto_check $input
</code></pre>
</article>
<article class="doc-entry" id="doc-articulation-point">
<h3><a class="doc-anchor" href="#doc-articulation-point">#</a> <code>articulation_point</code></h3>
<p><code>articulation_point</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = articulation_point $x
# or in a pipeline:
@list |> map articulation_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-articulation-points">
<h3><a class="doc-anchor" href="#doc-articulation-points">#</a> <code>articulation_points</code></h3>
<p><code>articulation_points</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = articulation_points $x
# or in a pipeline:
@list |> map articulation_points |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ascent-parser-step">
<h3><a class="doc-anchor" href="#doc-ascent-parser-step">#</a> <code>ascent_parser_step</code></h3>
<p><code>ascent_parser_step</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = ascent_parser_step $x
# or in a pipeline:
@list |> map ascent_parser_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ascii">
<h3><a class="doc-anchor" href="#doc-ascii">#</a> <code>ascii</code></h3>
<p><code>ascii</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = ascii $x
# or in a pipeline:
@list |> map ascii |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ascii-chr">
<h3><a class="doc-anchor" href="#doc-ascii-chr">#</a> <code>ascii_chr</code></h3>
<p><code>ascii_chr</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = ascii_chr $x
# or in a pipeline:
@list |> map ascii_chr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ascii-ord">
<h3><a class="doc-anchor" href="#doc-ascii-ord">#</a> <code>ascii_ord</code></h3>
<p><code>ascii_ord</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = ascii_ord $x
# or in a pipeline:
@list |> map ascii_ord |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ascii-table">
<h3><a class="doc-anchor" href="#doc-ascii-table">#</a> <code>ascii_table</code></h3>
<p><code>ascii_table</code> — batch 9 builtin. Alias for <code>format_table_simple</code>.</p>
<pre><code class="lang-perl">my $result = ascii_table $x
# or in a pipeline:
@list |> map ascii_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asec">
<h3><a class="doc-anchor" href="#doc-asec">#</a> <code>asec</code></h3>
<p><code>asec</code> — trig extensions builtin.</p>
<pre><code class="lang-perl">my $result = asec $x
# or in a pipeline:
@list |> map asec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asian-call-mc">
<h3><a class="doc-anchor" href="#doc-asian-call-mc">#</a> <code>asian_call_mc</code></h3>
<p><code>asian_call_mc</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = asian_call_mc $x
# or in a pipeline:
@list |> map asian_call_mc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asin">
<h3><a class="doc-anchor" href="#doc-asin">#</a> <code>asin</code></h3>
<p><code>asin</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = asin $x
# or in a pipeline:
@list |> map asin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asinh">
<h3><a class="doc-anchor" href="#doc-asinh">#</a> <code>asinh</code></h3>
<p><code>asinh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = asinh $x
# or in a pipeline:
@list |> map asinh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asrt">
<h3><a class="doc-anchor" href="#doc-asrt">#</a> <code>asrt</code></h3>
<p><code>asrt</code> — extended stdlib builtin. Alias for <code>argsort</code>.</p>
<pre><code class="lang-perl">my $result = asrt $x
# or in a pipeline:
@list |> map asrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-type">
<h3><a class="doc-anchor" href="#doc-assert-type">#</a> <code>assert_type</code></h3>
<p><code>assert_type</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = assert_type $x
# or in a pipeline:
@list |> map assert_type |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assignment-lower-bound">
<h3><a class="doc-anchor" href="#doc-assignment-lower-bound">#</a> <code>assignment_lower_bound</code></h3>
<p><code>assignment_lower_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = assignment_lower_bound $x
# or in a pipeline:
@list |> map assignment_lower_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assoc">
<h3><a class="doc-anchor" href="#doc-assoc">#</a> <code>assoc</code></h3>
<p><code>assoc</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = assoc $x
# or in a pipeline:
@list |> map assoc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assoc-fn">
<h3><a class="doc-anchor" href="#doc-assoc-fn">#</a> <code>assoc_fn</code></h3>
<p><code>assoc_fn</code> — go/general functional utilities builtin. Alias for <code>associate</code>.</p>
<pre><code class="lang-perl">my $result = assoc_fn $x
# or in a pipeline:
@list |> map assoc_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assoc-in">
<h3><a class="doc-anchor" href="#doc-assoc-in">#</a> <code>assoc_in</code></h3>
<p><code>assoc_in</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = assoc_in $x
# or in a pipeline:
@list |> map assoc_in |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-associate">
<h3><a class="doc-anchor" href="#doc-associate">#</a> <code>associate</code></h3>
<p><code>associate</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = associate $x
# or in a pipeline:
@list |> map associate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-astar-search">
<h3><a class="doc-anchor" href="#doc-astar-search">#</a> <code>astar_search</code></h3>
<p><code>astar_search</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = astar_search $x
# or in a pipeline:
@list |> map astar_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-astronomical-unit">
<h3><a class="doc-anchor" href="#doc-astronomical-unit">#</a> <code>astronomical_unit</code></h3>
<p><code>astronomical_unit</code> (alias <code>au</code>) — AU ≈ 1.496×10¹¹ m. Mean Earth-Sun distance.</p>
<pre><code class="lang-perl">p au # 1.495978707e11 m
p au / 1000 # ~149.6 million km
</code></pre>
</article>
<article class="doc-entry" id="doc-at-content">
<h3><a class="doc-anchor" href="#doc-at-content">#</a> <code>at_content</code></h3>
<p><code>at_content</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = at_content $x
# or in a pipeline:
@list |> map at_content |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-at-index">
<h3><a class="doc-anchor" href="#doc-at-index">#</a> <code>at_index</code></h3>
<p><code>at_index</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = at_index $x
# or in a pipeline:
@list |> map at_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atan">
<h3><a class="doc-anchor" href="#doc-atan">#</a> <code>atan</code></h3>
<p><code>atan</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = atan $x
# or in a pipeline:
@list |> map atan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atanh">
<h3><a class="doc-anchor" href="#doc-atanh">#</a> <code>atanh</code></h3>
<p><code>atanh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = atanh $x
# or in a pipeline:
@list |> map atanh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atbash">
<h3><a class="doc-anchor" href="#doc-atbash">#</a> <code>atbash</code></h3>
<p><code>atbash</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = atbash $x
# or in a pipeline:
@list |> map atbash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atbash-cipher">
<h3><a class="doc-anchor" href="#doc-atbash-cipher">#</a> <code>atbash_cipher</code></h3>
<p><code>atbash_cipher</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = atbash_cipher $x
# or in a pipeline:
@list |> map atbash_cipher |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atc">
<h3><a class="doc-anchor" href="#doc-atc">#</a> <code>atc</code></h3>
<p><code>atc</code> — color operations builtin. Alias for <code>ansi_truecolor</code>.</p>
<pre><code class="lang-perl">my $result = atc $x
# or in a pipeline:
@list |> map atc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ati">
<h3><a class="doc-anchor" href="#doc-ati">#</a> <code>ati</code></h3>
<p><code>ati</code> — javascript array/object methods builtin. Alias for <code>at_index</code>.</p>
<pre><code class="lang-perl">my $result = ati $x
# or in a pipeline:
@list |> map ati |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atime">
<h3><a class="doc-anchor" href="#doc-atime">#</a> <code>atime</code></h3>
<p><code>atime</code> — file stat / path builtin. Alias for <code>file_atime</code>.</p>
<pre><code class="lang-perl">my $result = atime $x
# or in a pipeline:
@list |> map atime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atm-to-pa">
<h3><a class="doc-anchor" href="#doc-atm-to-pa">#</a> <code>atm_to_pa</code></h3>
<p><code>atm_to_pa</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = atm_to_pa $input
</code></pre>
</article>
<article class="doc-entry" id="doc-atomic-mass-unit">
<h3><a class="doc-anchor" href="#doc-atomic-mass-unit">#</a> <code>atomic_mass_unit</code></h3>
<p><code>atomic_mass_unit</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = atomic_mass_unit $x
# or in a pipeline:
@list |> map atomic_mass_unit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atomic-radius-pm">
<h3><a class="doc-anchor" href="#doc-atomic-radius-pm">#</a> <code>atomic_radius_pm</code></h3>
<p><code>atomic_radius_pm</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = atomic_radius_pm $x
# or in a pipeline:
@list |> map atomic_radius_pm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atrap">
<h3><a class="doc-anchor" href="#doc-atrap">#</a> <code>atrap</code></h3>
<p><code>atrap</code> — geometry / physics builtin. Alias for <code>area_trapezoid</code>.</p>
<pre><code class="lang-perl">my $result = atrap $x
# or in a pipeline:
@list |> map atrap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atri">
<h3><a class="doc-anchor" href="#doc-atri">#</a> <code>atri</code></h3>
<p><code>atri</code> — geometry / physics builtin. Alias for <code>area_triangle</code>.</p>
<pre><code class="lang-perl">my $result = atri $x
# or in a pipeline:
@list |> map atri |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-attack-rate">
<h3><a class="doc-anchor" href="#doc-attack-rate">#</a> <code>attack_rate</code></h3>
<p><code>attack_rate</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = attack_rate $x
# or in a pipeline:
@list |> map attack_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-attempt">
<h3><a class="doc-anchor" href="#doc-attempt">#</a> <code>attempt</code></h3>
<p><code>attempt</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = attempt $x
# or in a pipeline:
@list |> map attempt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-attributable-fraction-pop">
<h3><a class="doc-anchor" href="#doc-attributable-fraction-pop">#</a> <code>attributable_fraction_pop</code></h3>
<p><code>attributable_fraction_pop</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = attributable_fraction_pop $x
# or in a pipeline:
@list |> map attributable_fraction_pop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-au-to-km">
<h3><a class="doc-anchor" href="#doc-au-to-km">#</a> <code>au_to_km</code></h3>
<p><code>au_to_km</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = au_to_km $input
</code></pre>
</article>
<article class="doc-entry" id="doc-au-to-m">
<h3><a class="doc-anchor" href="#doc-au-to-m">#</a> <code>au_to_m</code></h3>
<p><code>au_to_m</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = au_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-augmented-lagrangian-step">
<h3><a class="doc-anchor" href="#doc-augmented-lagrangian-step">#</a> <code>augmented_lagrangian_step</code></h3>
<p><code>augmented_lagrangian_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = augmented_lagrangian_step $x
# or in a pipeline:
@list |> map augmented_lagrangian_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-autocorrelation">
<h3><a class="doc-anchor" href="#doc-autocorrelation">#</a> <code>autocorrelation</code></h3>
<p><code>autocorrelation</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = autocorrelation $x
# or in a pipeline:
@list |> map autocorrelation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-automated-readability-index">
<h3><a class="doc-anchor" href="#doc-automated-readability-index">#</a> <code>automated_readability_index</code></h3>
<p><code>automated_readability_index</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = automated_readability_index $x
# or in a pipeline:
@list |> map automated_readability_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-average">
<h3><a class="doc-anchor" href="#doc-average">#</a> <code>average</code></h3>
<p><code>average</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = average $x
# or in a pipeline:
@list |> map average |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-averageif">
<h3><a class="doc-anchor" href="#doc-averageif">#</a> <code>averageif</code></h3>
<p><code>averageif</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = averageif $x
# or in a pipeline:
@list |> map averageif |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-averageifs">
<h3><a class="doc-anchor" href="#doc-averageifs">#</a> <code>averageifs</code></h3>
<p><code>averageifs</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = averageifs $x
# or in a pipeline:
@list |> map averageifs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avg">
<h3><a class="doc-anchor" href="#doc-avg">#</a> <code>avg</code></h3>
<p><code>avg</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = avg $x
# or in a pipeline:
@list |> map avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avg-degree">
<h3><a class="doc-anchor" href="#doc-avg-degree">#</a> <code>avg_degree</code></h3>
<p><code>avg_degree</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = avg_degree $x
# or in a pipeline:
@list |> map avg_degree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avogadro">
<h3><a class="doc-anchor" href="#doc-avogadro">#</a> <code>avogadro</code></h3>
<p><code>avogadro</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = avogadro $x
# or in a pipeline:
@list |> map avogadro |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avogadro-constant">
<h3><a class="doc-anchor" href="#doc-avogadro-constant">#</a> <code>avogadro_constant</code></h3>
<p><code>avogadro_constant</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = avogadro_constant $x
# or in a pipeline:
@list |> map avogadro_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avogadro-count">
<h3><a class="doc-anchor" href="#doc-avogadro-count">#</a> <code>avogadro_count</code></h3>
<p><code>avogadro_count</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = avogadro_count $x
# or in a pipeline:
@list |> map avogadro_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avogadro-number">
<h3><a class="doc-anchor" href="#doc-avogadro-number">#</a> <code>avogadro_number</code></h3>
<p><code>avogadro_number</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = avogadro_number $x
# or in a pipeline:
@list |> map avogadro_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avogadros-number">
<h3><a class="doc-anchor" href="#doc-avogadros-number">#</a> <code>avogadros_number</code></h3>
<p><code>avogadros_number</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = avogadros_number $x
# or in a pipeline:
@list |> map avogadros_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b2gray">
<h3><a class="doc-anchor" href="#doc-b2gray">#</a> <code>b2gray</code></h3>
<p><code>b2gray</code> — base / gray code builtin. Alias for <code>binary_to_gray</code>.</p>
<pre><code class="lang-perl">my $result = b2gray $x
# or in a pipeline:
@list |> map b2gray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b2i">
<h3><a class="doc-anchor" href="#doc-b2i">#</a> <code>b2i</code></h3>
<p><code>b2i</code> — boolean combinators builtin. Alias for <code>bool_to_int</code>.</p>
<pre><code class="lang-perl">my $result = b2i $x
# or in a pipeline:
@list |> map b2i |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b64d">
<h3><a class="doc-anchor" href="#doc-b64d">#</a> <code>b64d</code></h3>
<p><code>b64d</code> — crypto / encoding builtin. Alias for <code>base64_decode</code>.</p>
<pre><code class="lang-perl">my $result = b64d $x
# or in a pipeline:
@list |> map b64d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b64e">
<h3><a class="doc-anchor" href="#doc-b64e">#</a> <code>b64e</code></h3>
<p><code>b64e</code> — crypto / encoding builtin. Alias for <code>base64_encode</code>.</p>
<pre><code class="lang-perl">my $result = b64e $x
# or in a pipeline:
@list |> map b64e |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b-to-kb">
<h3><a class="doc-anchor" href="#doc-b-to-kb">#</a> <code>b_to_kb</code></h3>
<p><code>b_to_kb</code> — unit conversions builtin. Alias for <code>bytes_to_kb</code>.</p>
<pre><code class="lang-perl">my $result = b_to_kb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-b-wien">
<h3><a class="doc-anchor" href="#doc-b-wien">#</a> <code>b_wien</code></h3>
<p><code>b_wien</code> — physics constants builtin. Alias for <code>wien_constant</code>.</p>
<pre><code class="lang-perl">my $result = b_wien $x
# or in a pipeline:
@list |> map b_wien |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-babip">
<h3><a class="doc-anchor" href="#doc-babip">#</a> <code>babip</code></h3>
<p><code>babip</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = babip $x
# or in a pipeline:
@list |> map babip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bac">
<h3><a class="doc-anchor" href="#doc-bac">#</a> <code>bac</code></h3>
<p><code>bac</code> — finance builtin. Alias for <code>bac_estimate</code>.</p>
<pre><code class="lang-perl">my $result = bac $x
# or in a pipeline:
@list |> map bac |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bac-estimate">
<h3><a class="doc-anchor" href="#doc-bac-estimate">#</a> <code>bac_estimate</code></h3>
<p><code>bac_estimate</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = bac_estimate $x
# or in a pipeline:
@list |> map bac_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bachelier-call">
<h3><a class="doc-anchor" href="#doc-bachelier-call">#</a> <code>bachelier_call</code></h3>
<p><code>bachelier_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = bachelier_call $x
# or in a pipeline:
@list |> map bachelier_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-backward-euler">
<h3><a class="doc-anchor" href="#doc-backward-euler">#</a> <code>backward_euler</code></h3>
<p><code>backward_euler</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = backward_euler $x
# or in a pipeline:
@list |> map backward_euler |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-badi-year-from-fixed">
<h3><a class="doc-anchor" href="#doc-badi-year-from-fixed">#</a> <code>badi_year_from_fixed</code></h3>
<p><code>badi_year_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = badi_year_from_fixed $x
# or in a pipeline:
@list |> map badi_year_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bahai-from-fixed">
<h3><a class="doc-anchor" href="#doc-bahai-from-fixed">#</a> <code>bahai_from_fixed</code></h3>
<p><code>bahai_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = bahai_from_fixed $x
# or in a pipeline:
@list |> map bahai_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bairstow">
<h3><a class="doc-anchor" href="#doc-bairstow">#</a> <code>bairstow</code></h3>
<p><code>bairstow</code> — batch 10 builtin. Alias for <code>lin_bairstow_step</code>.</p>
<pre><code class="lang-perl">my $result = bairstow $x
# or in a pipeline:
@list |> map bairstow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-balanced-accuracy">
<h3><a class="doc-anchor" href="#doc-balanced-accuracy">#</a> <code>balanced_accuracy</code></h3>
<p><code>balanced_accuracy</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = balanced_accuracy $x
# or in a pipeline:
@list |> map balanced_accuracy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bandpass-filter">
<h3><a class="doc-anchor" href="#doc-bandpass-filter">#</a> <code>bandpass_filter</code></h3>
<p><code>bandpass_filter(\@signal, $low, $high)</code> (alias <code>bpf</code>) — applies a band-pass filter passing frequencies between low and high cutoffs. Combines low-pass and high-pass.</p>
<pre><code class="lang-perl">my $filtered = bpf(\@signal, 0.1, 0.3)
</code></pre>
</article>
<article class="doc-entry" id="doc-banzhaf-index-two">
<h3><a class="doc-anchor" href="#doc-banzhaf-index-two">#</a> <code>banzhaf_index_two</code></h3>
<p><code>banzhaf_index_two</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = banzhaf_index_two $x
# or in a pipeline:
@list |> map banzhaf_index_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bao-scale-today">
<h3><a class="doc-anchor" href="#doc-bao-scale-today">#</a> <code>bao_scale_today</code></h3>
<p><code>bao_scale_today</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = bao_scale_today $x
# or in a pipeline:
@list |> map bao_scale_today |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bar-to-pascals">
<h3><a class="doc-anchor" href="#doc-bar-to-pascals">#</a> <code>bar_to_pascals</code></h3>
<p><code>bar_to_pascals</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = bar_to_pascals $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bargaining-set-check">
<h3><a class="doc-anchor" href="#doc-bargaining-set-check">#</a> <code>bargaining_set_check</code></h3>
<p><code>bargaining_set_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = bargaining_set_check $x
# or in a pipeline:
@list |> map bargaining_set_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-barrier-up-out-call">
<h3><a class="doc-anchor" href="#doc-barrier-up-out-call">#</a> <code>barrier_up_out_call</code></h3>
<p><code>barrier_up_out_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = barrier_up_out_call $x
# or in a pipeline:
@list |> map barrier_up_out_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-barthann-w">
<h3><a class="doc-anchor" href="#doc-barthann-w">#</a> <code>barthann_w</code></h3>
<p><code>barthann_w</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = barthann_w $x
# or in a pipeline:
@list |> map barthann_w |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bartlett-window">
<h3><a class="doc-anchor" href="#doc-bartlett-window">#</a> <code>bartlett_window</code></h3>
<p><code>bartlett_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = bartlett_window $x
# or in a pipeline:
@list |> map bartlett_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-base-convert">
<h3><a class="doc-anchor" href="#doc-base-convert">#</a> <code>base_convert</code></h3>
<p><code>base_convert</code> — base / gray code builtin.</p>
<pre><code class="lang-perl">my $result = base_convert $x
# or in a pipeline:
@list |> map base_convert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-batch">
<h3><a class="doc-anchor" href="#doc-batch">#</a> <code>batch</code></h3>
<p><code>batch</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = batch $x
# or in a pipeline:
@list |> map batch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-batched">
<h3><a class="doc-anchor" href="#doc-batched">#</a> <code>batched</code></h3>
<p><code>batched</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = batched $x
# or in a pipeline:
@list |> map batched |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-batchelor-scale-step">
<h3><a class="doc-anchor" href="#doc-batchelor-scale-step">#</a> <code>batchelor_scale_step</code></h3>
<p><code>batchelor_scale_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = batchelor_scale_step $x
# or in a pipeline:
@list |> map batchelor_scale_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-battle-sexes-payoff">
<h3><a class="doc-anchor" href="#doc-battle-sexes-payoff">#</a> <code>battle_sexes_payoff</code></h3>
<p><code>battle_sexes_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = battle_sexes_payoff $x
# or in a pipeline:
@list |> map battle_sexes_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bauer-furuta-step">
<h3><a class="doc-anchor" href="#doc-bauer-furuta-step">#</a> <code>bauer_furuta_step</code></h3>
<p><code>bauer_furuta_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = bauer_furuta_step $x
# or in a pipeline:
@list |> map bauer_furuta_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bayes-posterior">
<h3><a class="doc-anchor" href="#doc-bayes-posterior">#</a> <code>bayes_posterior</code></h3>
<p><code>bayes_posterior</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = bayes_posterior $x
# or in a pipeline:
@list |> map bayes_posterior |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bayesian-info-crit">
<h3><a class="doc-anchor" href="#doc-bayesian-info-crit">#</a> <code>bayesian_info_crit</code></h3>
<p><code>bayesian_info_crit</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = bayesian_info_crit $x
# or in a pipeline:
@list |> map bayesian_info_crit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bayesian-step">
<h3><a class="doc-anchor" href="#doc-bayesian-step">#</a> <code>bayesian_step</code></h3>
<p><code>bayesian_step</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = bayesian_step $x
# or in a pipeline:
@list |> map bayesian_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bbox">
<h3><a class="doc-anchor" href="#doc-bbox">#</a> <code>bbox</code></h3>
<p><code>bounding_box(@points)</code> (alias <code>bbox</code>) — computes the axis-aligned bounding box of 2D points. Returns [min_x, min_y, max_x, max_y].</p>
<pre><code class="lang-perl">my @pts = (1,2, 3,4, 0,1, 5,3)
my $bb = bbox(@pts)
p @$bb # (0, 1, 5, 4)
</code></pre>
</article>
<article class="doc-entry" id="doc-bbox-from-points">
<h3><a class="doc-anchor" href="#doc-bbox-from-points">#</a> <code>bbox_from_points</code></h3>
<p><code>bbox_from_points</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = bbox_from_points $x
# or in a pipeline:
@list |> map bbox_from_points |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bconv">
<h3><a class="doc-anchor" href="#doc-bconv">#</a> <code>bconv</code></h3>
<p><code>bconv</code> — base / gray code builtin. Alias for <code>base_convert</code>.</p>
<pre><code class="lang-perl">my $result = bconv $x
# or in a pipeline:
@list |> map bconv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bcount">
<h3><a class="doc-anchor" href="#doc-bcount">#</a> <code>bcount</code></h3>
<p><code>bcount</code> — extended stdlib batch 3 builtin. Alias for <code>count_bytes</code>.</p>
<pre><code class="lang-perl">my $result = bcount $x
# or in a pipeline:
@list |> map bcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bcrypt-cost-iters">
<h3><a class="doc-anchor" href="#doc-bcrypt-cost-iters">#</a> <code>bcrypt_cost_iters</code></h3>
<p><code>bcrypt_cost_iters</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = bcrypt_cost_iters $x
# or in a pipeline:
@list |> map bcrypt_cost_iters |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdd-apply">
<h3><a class="doc-anchor" href="#doc-bdd-apply">#</a> <code>bdd_apply</code></h3>
<p><code>bdd_apply</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = bdd_apply $x
# or in a pipeline:
@list |> map bdd_apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdd-quantify">
<h3><a class="doc-anchor" href="#doc-bdd-quantify">#</a> <code>bdd_quantify</code></h3>
<p><code>bdd_quantify</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = bdd_quantify $x
# or in a pipeline:
@list |> map bdd_quantify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdd-restrict">
<h3><a class="doc-anchor" href="#doc-bdd-restrict">#</a> <code>bdd_restrict</code></h3>
<p><code>bdd_restrict</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = bdd_restrict $x
# or in a pipeline:
@list |> map bdd_restrict |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdf1-step">
<h3><a class="doc-anchor" href="#doc-bdf1-step">#</a> <code>bdf1_step</code></h3>
<p><code>bdf1_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = bdf1_step $x
# or in a pipeline:
@list |> map bdf1_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdf2-step">
<h3><a class="doc-anchor" href="#doc-bdf2-step">#</a> <code>bdf2_step</code></h3>
<p><code>bdf2_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = bdf2_step $x
# or in a pipeline:
@list |> map bdf2_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdf3-step">
<h3><a class="doc-anchor" href="#doc-bdf3-step">#</a> <code>bdf3_step</code></h3>
<p><code>bdf3_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = bdf3_step $x
# or in a pipeline:
@list |> map bdf3_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdf4-step">
<h3><a class="doc-anchor" href="#doc-bdf4-step">#</a> <code>bdf4_step</code></h3>
<p><code>bdf4_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = bdf4_step $x
# or in a pipeline:
@list |> map bdf4_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdf5-step">
<h3><a class="doc-anchor" href="#doc-bdf5-step">#</a> <code>bdf5_step</code></h3>
<p><code>bdf5_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = bdf5_step $x
# or in a pipeline:
@list |> map bdf5_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bdf6-step">
<h3><a class="doc-anchor" href="#doc-bdf6-step">#</a> <code>bdf6_step</code></h3>
<p><code>bdf6_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = bdf6_step $x
# or in a pipeline:
@list |> map bdf6_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bearing">
<h3><a class="doc-anchor" href="#doc-bearing">#</a> <code>bearing</code></h3>
<p><code>bearing</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = bearing $x
# or in a pipeline:
@list |> map bearing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-beat-frequency">
<h3><a class="doc-anchor" href="#doc-beat-frequency">#</a> <code>beat_frequency</code></h3>
<p><code>beat_frequency</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = beat_frequency $x
# or in a pipeline:
@list |> map beat_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-beat-to-seconds">
<h3><a class="doc-anchor" href="#doc-beat-to-seconds">#</a> <code>beat_to_seconds</code></h3>
<p><code>beat_to_seconds</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = beat_to_seconds $input
</code></pre>
</article>
<article class="doc-entry" id="doc-beaufort">
<h3><a class="doc-anchor" href="#doc-beaufort">#</a> <code>beaufort</code></h3>
<p><code>beaufort</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = beaufort $x
# or in a pipeline:
@list |> map beaufort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-before-n">
<h3><a class="doc-anchor" href="#doc-before-n">#</a> <code>before_n</code></h3>
<p><code>before_n</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = before_n $x
# or in a pipeline:
@list |> map before_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bekenstein-entropy-step">
<h3><a class="doc-anchor" href="#doc-bekenstein-entropy-step">#</a> <code>bekenstein_entropy_step</code></h3>
<p><code>bekenstein_entropy_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = bekenstein_entropy_step $x
# or in a pipeline:
@list |> map bekenstein_entropy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bell-inequality-chsh">
<h3><a class="doc-anchor" href="#doc-bell-inequality-chsh">#</a> <code>bell_inequality_chsh</code></h3>
<p><code>bell_inequality_chsh</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = bell_inequality_chsh $x
# or in a pipeline:
@list |> map bell_inequality_chsh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bell-number">
<h3><a class="doc-anchor" href="#doc-bell-number">#</a> <code>bell_number</code></h3>
<p><code>bell_number</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = bell_number $x
# or in a pipeline:
@list |> map bell_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bell-state">
<h3><a class="doc-anchor" href="#doc-bell-state">#</a> <code>bell_state</code></h3>
<p><code>bell_state</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = bell_state $x
# or in a pipeline:
@list |> map bell_state |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bell-state-index">
<h3><a class="doc-anchor" href="#doc-bell-state-index">#</a> <code>bell_state_index</code></h3>
<p><code>bell_state_index</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = bell_state_index $x
# or in a pipeline:
@list |> map bell_state_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bellman-equation-step">
<h3><a class="doc-anchor" href="#doc-bellman-equation-step">#</a> <code>bellman_equation_step</code></h3>
<p><code>bellman_equation_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = bellman_equation_step $x
# or in a pipeline:
@list |> map bellman_equation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bellman-ford">
<h3><a class="doc-anchor" href="#doc-bellman-ford">#</a> <code>bellman_ford</code></h3>
<p><code>bellman_ford</code> (alias <code>bellmanford</code>) computes shortest paths from a source in a graph with negative weights. Takes edges [[u,v,w],...], node count, source index.</p>
<pre><code class="lang-perl">my $d = bellmanford([[0,1,4],[0,2,5],[1,2,-3]], 3, 0)
</code></pre>
</article>
<article class="doc-entry" id="doc-bellman-ford-relax">
<h3><a class="doc-anchor" href="#doc-bellman-ford-relax">#</a> <code>bellman_ford_relax</code></h3>
<p><code>bellman_ford_relax</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = bellman_ford_relax $x
# or in a pipeline:
@list |> map bellman_ford_relax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-belln">
<h3><a class="doc-anchor" href="#doc-belln">#</a> <code>belln</code></h3>
<p><code>belln</code> — math / numeric (uncategorized batch) builtin. Alias for <code>bell_number</code>.</p>
<pre><code class="lang-perl">my $result = belln $x
# or in a pipeline:
@list |> map belln |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-benders-decomposition-step">
<h3><a class="doc-anchor" href="#doc-benders-decomposition-step">#</a> <code>benders_decomposition_step</code></h3>
<p><code>benders_decomposition_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = benders_decomposition_step $x
# or in a pipeline:
@list |> map benders_decomposition_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-berger-parker">
<h3><a class="doc-anchor" href="#doc-berger-parker">#</a> <code>berger_parker</code></h3>
<p><code>berger_parker</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = berger_parker $x
# or in a pipeline:
@list |> map berger_parker |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bergmann-adjust">
<h3><a class="doc-anchor" href="#doc-bergmann-adjust">#</a> <code>bergmann_adjust</code></h3>
<p><code>bergmann_adjust</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = bergmann_adjust $x
# or in a pipeline:
@list |> map bergmann_adjust |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bernoulli">
<h3><a class="doc-anchor" href="#doc-bernoulli">#</a> <code>bernoulli</code></h3>
<p><code>bernoulli_number</code> (alias <code>bernoulli</code>) computes the nth Bernoulli number. B(0)=1, B(1)=-0.5, odd B(n>1)=0.</p>
<pre><code class="lang-perl">p bernoulli(0) # 1
p bernoulli(2) # 0.1667
p bernoulli(4) # -0.0333
</code></pre>
</article>
<article class="doc-entry" id="doc-berry-phase-spin-half">
<h3><a class="doc-anchor" href="#doc-berry-phase-spin-half">#</a> <code>berry_phase_spin_half</code></h3>
<p><code>berry_phase_spin_half</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = berry_phase_spin_half $x
# or in a pipeline:
@list |> map berry_phase_spin_half |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bertrand-eq">
<h3><a class="doc-anchor" href="#doc-bertrand-eq">#</a> <code>bertrand_eq</code></h3>
<p><code>bertrand_eq</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = bertrand_eq $x
# or in a pipeline:
@list |> map bertrand_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bertrand-price-step">
<h3><a class="doc-anchor" href="#doc-bertrand-price-step">#</a> <code>bertrand_price_step</code></h3>
<p><code>bertrand_price_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = bertrand_price_step $x
# or in a pipeline:
@list |> map bertrand_price_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-in-general">
<h3><a class="doc-anchor" href="#doc-bessel-in-general">#</a> <code>bessel_in_general</code></h3>
<p><code>bessel_in_general</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = bessel_in_general $x
# or in a pipeline:
@list |> map bessel_in_general |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-jn-general">
<h3><a class="doc-anchor" href="#doc-bessel-jn-general">#</a> <code>bessel_jn_general</code></h3>
<p><code>bessel_jn_general</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = bessel_jn_general $x
# or in a pipeline:
@list |> map bessel_jn_general |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-lp">
<h3><a class="doc-anchor" href="#doc-bessel-lp">#</a> <code>bessel_lp</code></h3>
<p><code>bessel_lp</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = bessel_lp $x
# or in a pipeline:
@list |> map bessel_lp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-best-response-dynamic">
<h3><a class="doc-anchor" href="#doc-best-response-dynamic">#</a> <code>best_response_dynamic</code></h3>
<p><code>best_response_dynamic</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = best_response_dynamic $x
# or in a pipeline:
@list |> map best_response_dynamic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-beta-pdf">
<h3><a class="doc-anchor" href="#doc-beta-pdf">#</a> <code>beta_pdf</code></h3>
<p><code>beta_pdf</code> (alias <code>betapdf</code>) evaluates the Beta distribution PDF at x with shape parameters alpha and beta.</p>
<pre><code class="lang-perl">p betapdf(0.5, 2, 5) # Beta(2,5) at x=0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-betti-one">
<h3><a class="doc-anchor" href="#doc-betti-one">#</a> <code>betti_one</code></h3>
<p><code>betti_one</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = betti_one $x
# or in a pipeline:
@list |> map betti_one |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-betti-two">
<h3><a class="doc-anchor" href="#doc-betti-two">#</a> <code>betti_two</code></h3>
<p><code>betti_two</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = betti_two $x
# or in a pipeline:
@list |> map betti_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-betti-zero">
<h3><a class="doc-anchor" href="#doc-betti-zero">#</a> <code>betti_zero</code></h3>
<p><code>betti_zero</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = betti_zero $x
# or in a pipeline:
@list |> map betti_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-between">
<h3><a class="doc-anchor" href="#doc-between">#</a> <code>between</code></h3>
<p><code>between</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = between $x
# or in a pipeline:
@list |> map between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-beylkin-wavelet-step">
<h3><a class="doc-anchor" href="#doc-beylkin-wavelet-step">#</a> <code>beylkin_wavelet_step</code></h3>
<p><code>beylkin_wavelet_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = beylkin_wavelet_step $x
# or in a pipeline:
@list |> map beylkin_wavelet_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfgs-h-update-1d">
<h3><a class="doc-anchor" href="#doc-bfgs-h-update-1d">#</a> <code>bfgs_h_update_1d</code></h3>
<p><code>bfgs_h_update_1d</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = bfgs_h_update_1d $x
# or in a pipeline:
@list |> map bfgs_h_update_1d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfield-solenoid">
<h3><a class="doc-anchor" href="#doc-bfield-solenoid">#</a> <code>bfield_solenoid</code></h3>
<p><code>bfield_solenoid</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = bfield_solenoid $x
# or in a pipeline:
@list |> map bfield_solenoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfield-wire">
<h3><a class="doc-anchor" href="#doc-bfield-wire">#</a> <code>bfield_wire</code></h3>
<p><code>bfield_wire</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = bfield_wire $x
# or in a pipeline:
@list |> map bfield_wire |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfs">
<h3><a class="doc-anchor" href="#doc-bfs">#</a> <code>bfs</code></h3>
<p><code>bfs</code> — extended stdlib builtin. Alias for <code>bfs_traverse</code>.</p>
<pre><code class="lang-perl">my $result = bfs $x
# or in a pipeline:
@list |> map bfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfs-count">
<h3><a class="doc-anchor" href="#doc-bfs-count">#</a> <code>bfs_count</code></h3>
<p><code>bfs_count</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = bfs_count $x
# or in a pipeline:
@list |> map bfs_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfs-distances">
<h3><a class="doc-anchor" href="#doc-bfs-distances">#</a> <code>bfs_distances</code></h3>
<p><code>bfs_distances</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = bfs_distances $x
# or in a pipeline:
@list |> map bfs_distances |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfs-traverse">
<h3><a class="doc-anchor" href="#doc-bfs-traverse">#</a> <code>bfs_traverse</code></h3>
<p><code>bfs_traverse</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = bfs_traverse $x
# or in a pipeline:
@list |> map bfs_traverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-black">
<h3><a class="doc-anchor" href="#doc-bg-black">#</a> <code>bg_black</code></h3>
<p><code>bg_black</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_black $x
# or in a pipeline:
@list |> map bg_black |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-blue">
<h3><a class="doc-anchor" href="#doc-bg-blue">#</a> <code>bg_blue</code></h3>
<p><code>bg_blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_blue $x
# or in a pipeline:
@list |> map bg_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-blue">
<h3><a class="doc-anchor" href="#doc-bg-bright-blue">#</a> <code>bg_bright_blue</code></h3>
<p><code>bg_bright_blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_blue $x
# or in a pipeline:
@list |> map bg_bright_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-cyan">
<h3><a class="doc-anchor" href="#doc-bg-bright-cyan">#</a> <code>bg_bright_cyan</code></h3>
<p><code>bg_bright_cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_cyan $x
# or in a pipeline:
@list |> map bg_bright_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-green">
<h3><a class="doc-anchor" href="#doc-bg-bright-green">#</a> <code>bg_bright_green</code></h3>
<p><code>bg_bright_green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_green $x
# or in a pipeline:
@list |> map bg_bright_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-magenta">
<h3><a class="doc-anchor" href="#doc-bg-bright-magenta">#</a> <code>bg_bright_magenta</code></h3>
<p><code>bg_bright_magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_magenta $x
# or in a pipeline:
@list |> map bg_bright_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-red">
<h3><a class="doc-anchor" href="#doc-bg-bright-red">#</a> <code>bg_bright_red</code></h3>
<p><code>bg_bright_red</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_red $x
# or in a pipeline:
@list |> map bg_bright_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-white">
<h3><a class="doc-anchor" href="#doc-bg-bright-white">#</a> <code>bg_bright_white</code></h3>
<p><code>bg_bright_white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_white $x
# or in a pipeline:
@list |> map bg_bright_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-yellow">
<h3><a class="doc-anchor" href="#doc-bg-bright-yellow">#</a> <code>bg_bright_yellow</code></h3>
<p><code>bg_bright_yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_yellow $x
# or in a pipeline:
@list |> map bg_bright_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-c256">
<h3><a class="doc-anchor" href="#doc-bg-c256">#</a> <code>bg_c256</code></h3>
<p><code>bg_c256</code> — color / ansi builtin. Alias for <code>bg_color256</code>.</p>
<pre><code class="lang-perl">my $result = bg_c256 $x
# or in a pipeline:
@list |> map bg_c256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-color256">
<h3><a class="doc-anchor" href="#doc-bg-color256">#</a> <code>bg_color256</code></h3>
<p><code>bg_color256</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = bg_color256 $x
# or in a pipeline:
@list |> map bg_color256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-cyan">
<h3><a class="doc-anchor" href="#doc-bg-cyan">#</a> <code>bg_cyan</code></h3>
<p><code>bg_cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_cyan $x
# or in a pipeline:
@list |> map bg_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-green">
<h3><a class="doc-anchor" href="#doc-bg-green">#</a> <code>bg_green</code></h3>
<p><code>bg_green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_green $x
# or in a pipeline:
@list |> map bg_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-magenta">
<h3><a class="doc-anchor" href="#doc-bg-magenta">#</a> <code>bg_magenta</code></h3>
<p><code>bg_magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_magenta $x
# or in a pipeline:
@list |> map bg_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-red">
<h3><a class="doc-anchor" href="#doc-bg-red">#</a> <code>bg_red</code></h3>
<p><code>bg_red</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_red $x
# or in a pipeline:
@list |> map bg_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-rgb">
<h3><a class="doc-anchor" href="#doc-bg-rgb">#</a> <code>bg_rgb</code></h3>
<p><code>bg_rgb</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = bg_rgb $x
# or in a pipeline:
@list |> map bg_rgb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-white">
<h3><a class="doc-anchor" href="#doc-bg-white">#</a> <code>bg_white</code></h3>
<p><code>bg_white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_white $x
# or in a pipeline:
@list |> map bg_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-yellow">
<h3><a class="doc-anchor" href="#doc-bg-yellow">#</a> <code>bg_yellow</code></h3>
<p><code>bg_yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_yellow $x
# or in a pipeline:
@list |> map bg_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bh-adjusted-p">
<h3><a class="doc-anchor" href="#doc-bh-adjusted-p">#</a> <code>bh_adjusted_p</code></h3>
<p><code>bh_adjusted_p</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = bh_adjusted_p $x
# or in a pipeline:
@list |> map bh_adjusted_p |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bh-entropy">
<h3><a class="doc-anchor" href="#doc-bh-entropy">#</a> <code>bh_entropy</code></h3>
<p><code>bh_entropy</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = bh_entropy $x
# or in a pipeline:
@list |> map bh_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bh-evaporation-time">
<h3><a class="doc-anchor" href="#doc-bh-evaporation-time">#</a> <code>bh_evaporation_time</code></h3>
<p><code>bh_evaporation_time</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = bh_evaporation_time $x
# or in a pipeline:
@list |> map bh_evaporation_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bhattacharyya-coefficient">
<h3><a class="doc-anchor" href="#doc-bhattacharyya-coefficient">#</a> <code>bhattacharyya_coefficient</code></h3>
<p><code>bhattacharyya_coefficient</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = bhattacharyya_coefficient $x
# or in a pipeline:
@list |> map bhattacharyya_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bianchi-first-identity-check">
<h3><a class="doc-anchor" href="#doc-bianchi-first-identity-check">#</a> <code>bianchi_first_identity_check</code></h3>
<p><code>bianchi_first_identity_check</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = bianchi_first_identity_check $x
# or in a pipeline:
@list |> map bianchi_first_identity_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bianchi-second-identity-check">
<h3><a class="doc-anchor" href="#doc-bianchi-second-identity-check">#</a> <code>bianchi_second_identity_check</code></h3>
<p><code>bianchi_second_identity_check</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = bianchi_second_identity_check $x
# or in a pipeline:
@list |> map bianchi_second_identity_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bic">
<h3><a class="doc-anchor" href="#doc-bic">#</a> <code>bic</code></h3>
<p><code>bic</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = bic $x
# or in a pipeline:
@list |> map bic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biconnected-components">
<h3><a class="doc-anchor" href="#doc-biconnected-components">#</a> <code>biconnected_components</code></h3>
<p><code>biconnected_components</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = biconnected_components $x
# or in a pipeline:
@list |> map biconnected_components |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bidirectional-dijkstra">
<h3><a class="doc-anchor" href="#doc-bidirectional-dijkstra">#</a> <code>bidirectional_dijkstra</code></h3>
<p><code>bidirectional_dijkstra</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = bidirectional_dijkstra $x
# or in a pipeline:
@list |> map bidirectional_dijkstra |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bielliptic-total">
<h3><a class="doc-anchor" href="#doc-bielliptic-total">#</a> <code>bielliptic_total</code></h3>
<p><code>bielliptic_total</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = bielliptic_total $x
# or in a pipeline:
@list |> map bielliptic_total |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bigram">
<h3><a class="doc-anchor" href="#doc-bigram">#</a> <code>bigram</code></h3>
<p><code>bigram</code> — string processing (uncategorized batch) builtin. Alias for <code>bigrams</code>.</p>
<pre><code class="lang-perl">my $result = bigram $x
# or in a pipeline:
@list |> map bigram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bigram-perplexity">
<h3><a class="doc-anchor" href="#doc-bigram-perplexity">#</a> <code>bigram_perplexity</code></h3>
<p><code>bigram_perplexity</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = bigram_perplexity $x
# or in a pipeline:
@list |> map bigram_perplexity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bigrams">
<h3><a class="doc-anchor" href="#doc-bigrams">#</a> <code>bigrams</code></h3>
<p><code>bigrams</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = bigrams $x
# or in a pipeline:
@list |> map bigrams |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bilinear-xform">
<h3><a class="doc-anchor" href="#doc-bilinear-xform">#</a> <code>bilinear_xform</code></h3>
<p><code>bilinear_xform</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = bilinear_xform $x
# or in a pipeline:
@list |> map bilinear_xform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bilinear-zpk-xform">
<h3><a class="doc-anchor" href="#doc-bilinear-zpk-xform">#</a> <code>bilinear_zpk_xform</code></h3>
<p><code>bilinear_zpk_xform</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = bilinear_zpk_xform $x
# or in a pipeline:
@list |> map bilinear_zpk_xform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bin-of">
<h3><a class="doc-anchor" href="#doc-bin-of">#</a> <code>bin_of</code></h3>
<p><code>bin_of</code> — base conversion builtin. Alias for <code>to_bin</code>.</p>
<pre><code class="lang-perl">my $result = bin_of $x
# or in a pipeline:
@list |> map bin_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bin-packing-best-fit">
<h3><a class="doc-anchor" href="#doc-bin-packing-best-fit">#</a> <code>bin_packing_best_fit</code></h3>
<p><code>bin_packing_best_fit</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = bin_packing_best_fit $x
# or in a pipeline:
@list |> map bin_packing_best_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bin-packing-first-fit">
<h3><a class="doc-anchor" href="#doc-bin-packing-first-fit">#</a> <code>bin_packing_first_fit</code></h3>
<p><code>bin_packing_first_fit</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = bin_packing_first_fit $x
# or in a pipeline:
@list |> map bin_packing_first_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bin-packing-lower-bound-l1">
<h3><a class="doc-anchor" href="#doc-bin-packing-lower-bound-l1">#</a> <code>bin_packing_lower_bound_l1</code></h3>
<p><code>bin_packing_lower_bound_l1</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = bin_packing_lower_bound_l1 $x
# or in a pipeline:
@list |> map bin_packing_lower_bound_l1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bin-packing-next-fit">
<h3><a class="doc-anchor" href="#doc-bin-packing-next-fit">#</a> <code>bin_packing_next_fit</code></h3>
<p><code>bin_packing_next_fit</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = bin_packing_next_fit $x
# or in a pipeline:
@list |> map bin_packing_next_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bin-to-gray">
<h3><a class="doc-anchor" href="#doc-bin-to-gray">#</a> <code>bin_to_gray</code></h3>
<p><code>bin_to_gray</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = bin_to_gray $input
</code></pre>
</article>
<article class="doc-entry" id="doc-binary-insert">
<h3><a class="doc-anchor" href="#doc-binary-insert">#</a> <code>binary_insert</code></h3>
<p><code>binary_insert</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = binary_insert $x
# or in a pipeline:
@list |> map binary_insert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binary-search">
<h3><a class="doc-anchor" href="#doc-binary-search">#</a> <code>binary_search</code></h3>
<p><code>binary_search</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = binary_search $x
# or in a pipeline:
@list |> map binary_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binary-to-gray">
<h3><a class="doc-anchor" href="#doc-binary-to-gray">#</a> <code>binary_to_gray</code></h3>
<p><code>binary_to_gray</code> — base / gray code builtin.</p>
<pre><code class="lang-perl">my $result = binary_to_gray $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bincount">
<h3><a class="doc-anchor" href="#doc-bincount">#</a> <code>bincount</code></h3>
<p><code>bincount</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = bincount $x
# or in a pipeline:
@list |> map bincount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binder-content-optimal">
<h3><a class="doc-anchor" href="#doc-binder-content-optimal">#</a> <code>binder_content_optimal</code></h3>
<p><code>binder_content_optimal</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = binder_content_optimal $x
# or in a pipeline:
@list |> map binder_content_optimal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binom">
<h3><a class="doc-anchor" href="#doc-binom">#</a> <code>binom</code></h3>
<p><code>binom</code> — extended stdlib batch 3 builtin. Alias for <code>binomial</code>.</p>
<pre><code class="lang-perl">my $result = binom $x
# or in a pipeline:
@list |> map binom |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binom-test">
<h3><a class="doc-anchor" href="#doc-binom-test">#</a> <code>binom_test</code></h3>
<p><code>binom_test</code> — exact binomial test. Returns two-sided p-value. Like R's binom.test().</p>
<pre><code class="lang-perl">my $p = binomtest(7, 10, 0.5) # p-value for 7/10 successes vs p=0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-binomial">
<h3><a class="doc-anchor" href="#doc-binomial">#</a> <code>binomial</code></h3>
<p><code>binomial</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = binomial $x
# or in a pipeline:
@list |> map binomial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binsert">
<h3><a class="doc-anchor" href="#doc-binsert">#</a> <code>binsert</code></h3>
<p><code>binsert</code> — matrix operations (uncategorized batch) builtin. Alias for <code>binary_insert</code>.</p>
<pre><code class="lang-perl">my $result = binsert $x
# or in a pipeline:
@list |> map binsert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biorthogonal-step">
<h3><a class="doc-anchor" href="#doc-biorthogonal-step">#</a> <code>biorthogonal_step</code></h3>
<p><code>biorthogonal_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = biorthogonal_step $x
# or in a pipeline:
@list |> map biorthogonal_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biot-number-step">
<h3><a class="doc-anchor" href="#doc-biot-number-step">#</a> <code>biot_number_step</code></h3>
<p><code>biot_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = biot_number_step $x
# or in a pipeline:
@list |> map biot_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-allpass-coeffs">
<h3><a class="doc-anchor" href="#doc-biquad-allpass-coeffs">#</a> <code>biquad_allpass_coeffs</code></h3>
<p><code>biquad_allpass_coeffs</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_allpass_coeffs $x
# or in a pipeline:
@list |> map biquad_allpass_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-bandpass-coeffs">
<h3><a class="doc-anchor" href="#doc-biquad-bandpass-coeffs">#</a> <code>biquad_bandpass_coeffs</code></h3>
<p><code>biquad_bandpass_coeffs</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_bandpass_coeffs $x
# or in a pipeline:
@list |> map biquad_bandpass_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-highpass-coeffs">
<h3><a class="doc-anchor" href="#doc-biquad-highpass-coeffs">#</a> <code>biquad_highpass_coeffs</code></h3>
<p><code>biquad_highpass_coeffs</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_highpass_coeffs $x
# or in a pipeline:
@list |> map biquad_highpass_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-highshelf-coeffs">
<h3><a class="doc-anchor" href="#doc-biquad-highshelf-coeffs">#</a> <code>biquad_highshelf_coeffs</code></h3>
<p><code>biquad_highshelf_coeffs</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_highshelf_coeffs $x
# or in a pipeline:
@list |> map biquad_highshelf_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-lowpass-coeffs">
<h3><a class="doc-anchor" href="#doc-biquad-lowpass-coeffs">#</a> <code>biquad_lowpass_coeffs</code></h3>
<p><code>biquad_lowpass_coeffs</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_lowpass_coeffs $x
# or in a pipeline:
@list |> map biquad_lowpass_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-lowshelf-coeffs">
<h3><a class="doc-anchor" href="#doc-biquad-lowshelf-coeffs">#</a> <code>biquad_lowshelf_coeffs</code></h3>
<p><code>biquad_lowshelf_coeffs</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_lowshelf_coeffs $x
# or in a pipeline:
@list |> map biquad_lowshelf_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-notch-coeffs">
<h3><a class="doc-anchor" href="#doc-biquad-notch-coeffs">#</a> <code>biquad_notch_coeffs</code></h3>
<p><code>biquad_notch_coeffs</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_notch_coeffs $x
# or in a pipeline:
@list |> map biquad_notch_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-peak-coeffs">
<h3><a class="doc-anchor" href="#doc-biquad-peak-coeffs">#</a> <code>biquad_peak_coeffs</code></h3>
<p><code>biquad_peak_coeffs</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_peak_coeffs $x
# or in a pipeline:
@list |> map biquad_peak_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-biquad-step">
<h3><a class="doc-anchor" href="#doc-biquad-step">#</a> <code>biquad_step</code></h3>
<p><code>biquad_step</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = biquad_step $x
# or in a pipeline:
@list |> map biquad_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-birnbaum-saunders-pdf">
<h3><a class="doc-anchor" href="#doc-birnbaum-saunders-pdf">#</a> <code>birnbaum_saunders_pdf</code></h3>
<p><code>birnbaum_saunders_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = birnbaum_saunders_pdf $x
# or in a pipeline:
@list |> map birnbaum_saunders_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bisect">
<h3><a class="doc-anchor" href="#doc-bisect">#</a> <code>bisect</code></h3>
<p><code>bisection</code> (alias <code>bisect</code>) finds a root of f(x)=0 in [a,b] via the bisection method. Takes a code ref, a, b, and optional tolerance.</p>
<pre><code class="lang-perl">my $root = bisect(fn { $_[0]**2 - 2 }, 1, 2) # √2 ≈ 1.4142
</code></pre>
</article>
<article class="doc-entry" id="doc-bisimulation-step">
<h3><a class="doc-anchor" href="#doc-bisimulation-step">#</a> <code>bisimulation_step</code></h3>
<p><code>bisimulation_step</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = bisimulation_step $x
# or in a pipeline:
@list |> map bisimulation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-and">
<h3><a class="doc-anchor" href="#doc-bit-and">#</a> <code>bit_and</code></h3>
<p><code>bit_and</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_and $x
# or in a pipeline:
@list |> map bit_and |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-build">
<h3><a class="doc-anchor" href="#doc-bit-build">#</a> <code>bit_build</code></h3>
<p><code>bit_build</code> — batch 10 builtin. Alias for <code>fenwick_build</code>.</p>
<pre><code class="lang-perl">my $result = bit_build $x
# or in a pipeline:
@list |> map bit_build |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-clear">
<h3><a class="doc-anchor" href="#doc-bit-clear">#</a> <code>bit_clear</code></h3>
<p><code>bit_clear</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_clear $x
# or in a pipeline:
@list |> map bit_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-flip-prob">
<h3><a class="doc-anchor" href="#doc-bit-flip-prob">#</a> <code>bit_flip_prob</code></h3>
<p><code>bit_flip_prob</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = bit_flip_prob $x
# or in a pipeline:
@list |> map bit_flip_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-length">
<h3><a class="doc-anchor" href="#doc-bit-length">#</a> <code>bit_length</code></h3>
<p><code>bit_length</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = bit_length $x
# or in a pipeline:
@list |> map bit_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-not">
<h3><a class="doc-anchor" href="#doc-bit-not">#</a> <code>bit_not</code></h3>
<p><code>bit_not</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_not $x
# or in a pipeline:
@list |> map bit_not |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-or">
<h3><a class="doc-anchor" href="#doc-bit-or">#</a> <code>bit_or</code></h3>
<p><code>bit_or</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_or $x
# or in a pipeline:
@list |> map bit_or |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-query">
<h3><a class="doc-anchor" href="#doc-bit-query">#</a> <code>bit_query</code></h3>
<p><code>bit_query</code> — batch 10 builtin. Alias for <code>fenwick_query</code>.</p>
<pre><code class="lang-perl">my $result = bit_query $x
# or in a pipeline:
@list |> map bit_query |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-reverse">
<h3><a class="doc-anchor" href="#doc-bit-reverse">#</a> <code>bit_reverse</code></h3>
<p><code>bit_reverse</code> — batch 10 builtin. Alias for <code>bit_reverse_32</code>.</p>
<pre><code class="lang-perl">my $result = bit_reverse $x
# or in a pipeline:
@list |> map bit_reverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-reverse-32">
<h3><a class="doc-anchor" href="#doc-bit-reverse-32">#</a> <code>bit_reverse_32</code></h3>
<p><code>bit_reverse_32</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = bit_reverse_32 $x
# or in a pipeline:
@list |> map bit_reverse_32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-reverse-64">
<h3><a class="doc-anchor" href="#doc-bit-reverse-64">#</a> <code>bit_reverse_64</code></h3>
<p><code>bit_reverse_64</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = bit_reverse_64 $x
# or in a pipeline:
@list |> map bit_reverse_64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-set">
<h3><a class="doc-anchor" href="#doc-bit-set">#</a> <code>bit_set</code></h3>
<p><code>bit_set</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_set $x
# or in a pipeline:
@list |> map bit_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-test">
<h3><a class="doc-anchor" href="#doc-bit-test">#</a> <code>bit_test</code></h3>
<p><code>bit_test</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_test $x
# or in a pipeline:
@list |> map bit_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-toggle">
<h3><a class="doc-anchor" href="#doc-bit-toggle">#</a> <code>bit_toggle</code></h3>
<p><code>bit_toggle</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_toggle $x
# or in a pipeline:
@list |> map bit_toggle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-xor">
<h3><a class="doc-anchor" href="#doc-bit-xor">#</a> <code>bit_xor</code></h3>
<p><code>bit_xor</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_xor $x
# or in a pipeline:
@list |> map bit_xor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitcount">
<h3><a class="doc-anchor" href="#doc-bitcount">#</a> <code>bitcount</code></h3>
<p><code>bitcount</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = bitcount $x
# or in a pipeline:
@list |> map bitcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitlen">
<h3><a class="doc-anchor" href="#doc-bitlen">#</a> <code>bitlen</code></h3>
<p><code>bitlen</code> — base conversion builtin. Alias for <code>bit_length</code>.</p>
<pre><code class="lang-perl">my $result = bitlen $x
# or in a pipeline:
@list |> map bitlen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitop">
<h3><a class="doc-anchor" href="#doc-bitop">#</a> <code>bitop</code></h3>
<p><code>bitop</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = bitop $x
# or in a pipeline:
@list |> map bitop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitpos">
<h3><a class="doc-anchor" href="#doc-bitpos">#</a> <code>bitpos</code></h3>
<p><code>bitpos</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = bitpos $x
# or in a pipeline:
@list |> map bitpos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bits-count">
<h3><a class="doc-anchor" href="#doc-bits-count">#</a> <code>bits_count</code></h3>
<p><code>bits_count</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = bits_count $x
# or in a pipeline:
@list |> map bits_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bits-to-bytes">
<h3><a class="doc-anchor" href="#doc-bits-to-bytes">#</a> <code>bits_to_bytes</code></h3>
<p><code>bits_to_bytes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bits_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bitset-clear">
<h3><a class="doc-anchor" href="#doc-bitset-clear">#</a> <code>bitset_clear</code></h3>
<p><code>bitset_clear</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = bitset_clear $x
# or in a pipeline:
@list |> map bitset_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitset-new">
<h3><a class="doc-anchor" href="#doc-bitset-new">#</a> <code>bitset_new</code></h3>
<p><code>bitset_new</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = bitset_new $x
# or in a pipeline:
@list |> map bitset_new |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitset-set">
<h3><a class="doc-anchor" href="#doc-bitset-set">#</a> <code>bitset_set</code></h3>
<p><code>bitset_set</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = bitset_set $x
# or in a pipeline:
@list |> map bitset_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitset-test">
<h3><a class="doc-anchor" href="#doc-bitset-test">#</a> <code>bitset_test</code></h3>
<p><code>bitset_test</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = bitset_test $x
# or in a pipeline:
@list |> map bitset_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bkt">
<h3><a class="doc-anchor" href="#doc-bkt">#</a> <code>bkt</code></h3>
<p><code>bkt</code> — matrix operations (uncategorized batch) builtin. Alias for <code>bucket</code>.</p>
<pre><code class="lang-perl">my $result = bkt $x
# or in a pipeline:
@list |> map bkt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bl">
<h3><a class="doc-anchor" href="#doc-bl">#</a> <code>bl</code></h3>
<p><code>bl</code> — algebraic match builtin. Alias for <code>butlast</code>.</p>
<pre><code class="lang-perl">my $result = bl $x
# or in a pipeline:
@list |> map bl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-black">
<h3><a class="doc-anchor" href="#doc-black">#</a> <code>black</code></h3>
<p><code>black</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = black $x
# or in a pipeline:
@list |> map black |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-black76-call">
<h3><a class="doc-anchor" href="#doc-black76-call">#</a> <code>black76_call</code></h3>
<p><code>black76_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = black76_call $x
# or in a pipeline:
@list |> map black76_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-black-karasinski-drift">
<h3><a class="doc-anchor" href="#doc-black-karasinski-drift">#</a> <code>black_karasinski_drift</code></h3>
<p><code>black_karasinski_drift</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = black_karasinski_drift $x
# or in a pipeline:
@list |> map black_karasinski_drift |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-black-method-winner">
<h3><a class="doc-anchor" href="#doc-black-method-winner">#</a> <code>black_method_winner</code></h3>
<p><code>black_method_winner</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = black_method_winner $x
# or in a pipeline:
@list |> map black_method_winner |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-black-scholes-call">
<h3><a class="doc-anchor" href="#doc-black-scholes-call">#</a> <code>black_scholes_call</code></h3>
<p><code>black_scholes_call($S, $K, $r, $T, $sigma)</code> (alias <code>bscall</code>) — computes Black-Scholes price for a European call option. S=spot, K=strike, r=rate, T=time to expiry, sigma=volatility.</p>
<pre><code class="lang-perl">p bscall(100, 100, 0.05, 1, 0.2) # ~10.45
</code></pre>
</article>
<article class="doc-entry" id="doc-black-scholes-put">
<h3><a class="doc-anchor" href="#doc-black-scholes-put">#</a> <code>black_scholes_put</code></h3>
<p><code>black_scholes_put($S, $K, $r, $T, $sigma)</code> (alias <code>bsput</code>) — computes Black-Scholes price for a European put option.</p>
<pre><code class="lang-perl">p bsput(100, 100, 0.05, 1, 0.2) # ~5.57
</code></pre>
</article>
<article class="doc-entry" id="doc-blackman">
<h3><a class="doc-anchor" href="#doc-blackman">#</a> <code>blackman</code></h3>
<p><code>window_blackman($n)</code> (alias <code>blackman</code>) — generates a Blackman window of length n. Provides excellent sidelobe suppression at the cost of main lobe width.</p>
<pre><code class="lang-perl">my $w = blackman(1024)
</code></pre>
</article>
<article class="doc-entry" id="doc-blackman-harris-window">
<h3><a class="doc-anchor" href="#doc-blackman-harris-window">#</a> <code>blackman_harris_window</code></h3>
<p><code>blackman_harris_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = blackman_harris_window $x
# or in a pipeline:
@list |> map blackman_harris_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blackman-w">
<h3><a class="doc-anchor" href="#doc-blackman-w">#</a> <code>blackman_w</code></h3>
<p><code>blackman_w</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = blackman_w $x
# or in a pipeline:
@list |> map blackman_w |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blackman-window">
<h3><a class="doc-anchor" href="#doc-blackman-window">#</a> <code>blackman_window</code></h3>
<p><code>blackman_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = blackman_window $x
# or in a pipeline:
@list |> map blackman_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blackscholes-call">
<h3><a class="doc-anchor" href="#doc-blackscholes-call">#</a> <code>blackscholes_call</code></h3>
<p><code>blackscholes_call</code> — batch 20 builtin. Alias for <code>bs_call</code>.</p>
<pre><code class="lang-perl">my $result = blackscholes_call $x
# or in a pipeline:
@list |> map blackscholes_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blackscholes-put">
<h3><a class="doc-anchor" href="#doc-blackscholes-put">#</a> <code>blackscholes_put</code></h3>
<p><code>blackscholes_put</code> — batch 20 builtin. Alias for <code>bs_put</code>.</p>
<pre><code class="lang-perl">my $result = blackscholes_put $x
# or in a pipeline:
@list |> map blackscholes_put |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blessed">
<h3><a class="doc-anchor" href="#doc-blessed">#</a> <code>blessed</code></h3>
<p><code>blessed</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = blessed $x
# or in a pipeline:
@list |> map blessed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blink">
<h3><a class="doc-anchor" href="#doc-blink">#</a> <code>blink</code></h3>
<p><code>blink</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = blink $x
# or in a pipeline:
@list |> map blink |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bloch-purity-check">
<h3><a class="doc-anchor" href="#doc-bloch-purity-check">#</a> <code>bloch_purity_check</code></h3>
<p><code>bloch_purity_check</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = bloch_purity_check $x
# or in a pipeline:
@list |> map bloch_purity_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bloch-sphere-x">
<h3><a class="doc-anchor" href="#doc-bloch-sphere-x">#</a> <code>bloch_sphere_x</code></h3>
<p><code>bloch_sphere_x</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = bloch_sphere_x $x
# or in a pipeline:
@list |> map bloch_sphere_x |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bloch-sphere-z">
<h3><a class="doc-anchor" href="#doc-bloch-sphere-z">#</a> <code>bloch_sphere_z</code></h3>
<p><code>bloch_sphere_z</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = bloch_sphere_z $x
# or in a pipeline:
@list |> map bloch_sphere_z |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bloch-to-density-real">
<h3><a class="doc-anchor" href="#doc-bloch-to-density-real">#</a> <code>bloch_to_density_real</code></h3>
<p><code>bloch_to_density_real</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = bloch_to_density_real $input
</code></pre>
</article>
<article class="doc-entry" id="doc-block-devices">
<h3><a class="doc-anchor" href="#doc-block-devices">#</a> <code>block_devices</code></h3>
<p><code>block_devices</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = block_devices $x
# or in a pipeline:
@list |> map block_devices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blossom-match-step">
<h3><a class="doc-anchor" href="#doc-blossom-match-step">#</a> <code>blossom_match_step</code></h3>
<p><code>blossom_match_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = blossom_match_step $x
# or in a pipeline:
@list |> map blossom_match_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blosum45-score">
<h3><a class="doc-anchor" href="#doc-blosum45-score">#</a> <code>blosum45_score</code></h3>
<p><code>blosum45_score</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = blosum45_score $x
# or in a pipeline:
@list |> map blosum45_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blue">
<h3><a class="doc-anchor" href="#doc-blue">#</a> <code>blue</code></h3>
<p><code>blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = blue $x
# or in a pipeline:
@list |> map blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blue-bold">
<h3><a class="doc-anchor" href="#doc-blue-bold">#</a> <code>blue_bold</code></h3>
<p><code>blue_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = blue_bold $x
# or in a pipeline:
@list |> map blue_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bm-horspool">
<h3><a class="doc-anchor" href="#doc-bm-horspool">#</a> <code>bm_horspool</code></h3>
<p><code>bm_horspool</code> — batch 10 builtin. Alias for <code>horspool_search</code>.</p>
<pre><code class="lang-perl">my $result = bm_horspool $x
# or in a pipeline:
@list |> map bm_horspool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bmi">
<h3><a class="doc-anchor" href="#doc-bmi">#</a> <code>bmi</code></h3>
<p><code>bmi</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = bmi $x
# or in a pipeline:
@list |> map bmi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bmi-calc">
<h3><a class="doc-anchor" href="#doc-bmi-calc">#</a> <code>bmi_calc</code></h3>
<p><code>bmi_calc</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = bmi_calc $x
# or in a pipeline:
@list |> map bmi_calc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bmr-harris-benedict-female">
<h3><a class="doc-anchor" href="#doc-bmr-harris-benedict-female">#</a> <code>bmr_harris_benedict_female</code></h3>
<p><code>bmr_harris_benedict_female</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = bmr_harris_benedict_female $x
# or in a pipeline:
@list |> map bmr_harris_benedict_female |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bmr-harris-benedict-male">
<h3><a class="doc-anchor" href="#doc-bmr-harris-benedict-male">#</a> <code>bmr_harris_benedict_male</code></h3>
<p><code>bmr_harris_benedict_male</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = bmr_harris_benedict_male $x
# or in a pipeline:
@list |> map bmr_harris_benedict_male |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bode-gain-margin">
<h3><a class="doc-anchor" href="#doc-bode-gain-margin">#</a> <code>bode_gain_margin</code></h3>
<p><code>bode_gain_margin</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = bode_gain_margin $x
# or in a pipeline:
@list |> map bode_gain_margin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bode-phase">
<h3><a class="doc-anchor" href="#doc-bode-phase">#</a> <code>bode_phase</code></h3>
<p><code>bode_phase</code> — batch 6 builtin. Alias for <code>bode_phase_deg</code>.</p>
<pre><code class="lang-perl">my $result = bode_phase $x
# or in a pipeline:
@list |> map bode_phase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bode-phase-margin">
<h3><a class="doc-anchor" href="#doc-bode-phase-margin">#</a> <code>bode_phase_margin</code></h3>
<p><code>bode_phase_margin</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = bode_phase_margin $x
# or in a pipeline:
@list |> map bode_phase_margin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-body-surface-area-dubois">
<h3><a class="doc-anchor" href="#doc-body-surface-area-dubois">#</a> <code>body_surface_area_dubois</code></h3>
<p><code>body_surface_area_dubois</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = body_surface_area_dubois $x
# or in a pipeline:
@list |> map body_surface_area_dubois |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-body-wave-mb">
<h3><a class="doc-anchor" href="#doc-body-wave-mb">#</a> <code>body_wave_mb</code></h3>
<p><code>body_wave_mb</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = body_wave_mb $x
# or in a pipeline:
@list |> map body_wave_mb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bogacki-shampine-step">
<h3><a class="doc-anchor" href="#doc-bogacki-shampine-step">#</a> <code>bogacki_shampine_step</code></h3>
<p><code>bogacki_shampine_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = bogacki_shampine_step $x
# or in a pipeline:
@list |> map bogacki_shampine_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bohr-energy-ev">
<h3><a class="doc-anchor" href="#doc-bohr-energy-ev">#</a> <code>bohr_energy_ev</code></h3>
<p><code>bohr_energy_ev</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = bohr_energy_ev $x
# or in a pipeline:
@list |> map bohr_energy_ev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bohr-magneton">
<h3><a class="doc-anchor" href="#doc-bohr-magneton">#</a> <code>bohr_magneton</code></h3>
<p><code>bohr_magneton</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = bohr_magneton $x
# or in a pipeline:
@list |> map bohr_magneton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bohr-radius-n">
<h3><a class="doc-anchor" href="#doc-bohr-radius-n">#</a> <code>bohr_radius_n</code></h3>
<p><code>bohr_radius_n</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = bohr_radius_n $x
# or in a pipeline:
@list |> map bohr_radius_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold">
<h3><a class="doc-anchor" href="#doc-bold">#</a> <code>bold</code></h3>
<p><code>bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold $x
# or in a pipeline:
@list |> map bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-blue">
<h3><a class="doc-anchor" href="#doc-bold-blue">#</a> <code>bold_blue</code></h3>
<p><code>bold_blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_blue $x
# or in a pipeline:
@list |> map bold_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-cyan">
<h3><a class="doc-anchor" href="#doc-bold-cyan">#</a> <code>bold_cyan</code></h3>
<p><code>bold_cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_cyan $x
# or in a pipeline:
@list |> map bold_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-green">
<h3><a class="doc-anchor" href="#doc-bold-green">#</a> <code>bold_green</code></h3>
<p><code>bold_green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_green $x
# or in a pipeline:
@list |> map bold_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-magenta">
<h3><a class="doc-anchor" href="#doc-bold-magenta">#</a> <code>bold_magenta</code></h3>
<p><code>bold_magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_magenta $x
# or in a pipeline:
@list |> map bold_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-red">
<h3><a class="doc-anchor" href="#doc-bold-red">#</a> <code>bold_red</code></h3>
<p><code>bold_red</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_red $x
# or in a pipeline:
@list |> map bold_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-white">
<h3><a class="doc-anchor" href="#doc-bold-white">#</a> <code>bold_white</code></h3>
<p><code>bold_white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_white $x
# or in a pipeline:
@list |> map bold_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-yellow">
<h3><a class="doc-anchor" href="#doc-bold-yellow">#</a> <code>bold_yellow</code></h3>
<p><code>bold_yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_yellow $x
# or in a pipeline:
@list |> map bold_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boltz">
<h3><a class="doc-anchor" href="#doc-boltz">#</a> <code>boltz</code></h3>
<p><code>boltz</code> — constants builtin. Alias for <code>boltzmann_constant</code>.</p>
<pre><code class="lang-perl">my $result = boltz $x
# or in a pipeline:
@list |> map boltz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boltzmann">
<h3><a class="doc-anchor" href="#doc-boltzmann">#</a> <code>boltzmann</code></h3>
<p><code>boltzmann</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = boltzmann $x
# or in a pipeline:
@list |> map boltzmann |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boltzmann-const">
<h3><a class="doc-anchor" href="#doc-boltzmann-const">#</a> <code>boltzmann_const</code></h3>
<p><code>boltzmann_const</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = boltzmann_const $x
# or in a pipeline:
@list |> map boltzmann_const |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boltzmann-constant">
<h3><a class="doc-anchor" href="#doc-boltzmann-constant">#</a> <code>boltzmann_constant</code></h3>
<p><code>boltzmann_constant</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = boltzmann_constant $x
# or in a pipeline:
@list |> map boltzmann_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boltzmann-softmax-action">
<h3><a class="doc-anchor" href="#doc-boltzmann-softmax-action">#</a> <code>boltzmann_softmax_action</code></h3>
<p><code>boltzmann_softmax_action</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = boltzmann_softmax_action $x
# or in a pipeline:
@list |> map boltzmann_softmax_action |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bond-duration">
<h3><a class="doc-anchor" href="#doc-bond-duration">#</a> <code>bond_duration</code></h3>
<p><code>duration($face, $coupon_rate, $ytm, $periods)</code> (alias <code>bond_duration</code>) — computes the Macaulay duration of a bond, measuring interest rate sensitivity as weighted average time to receive cash flows.</p>
<pre><code class="lang-perl">p duration(1000, 0.05, 0.05, 10) # ~7.7 years
</code></pre>
</article>
<article class="doc-entry" id="doc-bond-price">
<h3><a class="doc-anchor" href="#doc-bond-price">#</a> <code>bond_price</code></h3>
<p><code>bond_price($face, $coupon_rate, $ytm, $periods)</code> — computes the present value (price) of a bond given face value, coupon rate, yield to maturity, and number of periods.</p>
<pre><code class="lang-perl">p bond_price(1000, 0.05, 0.04, 10) # ~1081 (premium)
p bond_price(1000, 0.05, 0.06, 10) # ~926 (discount)
</code></pre>
</article>
<article class="doc-entry" id="doc-bond-yield">
<h3><a class="doc-anchor" href="#doc-bond-yield">#</a> <code>bond_yield</code></h3>
<p><code>bond_yield($price, $face, $coupon_rate, $periods)</code> — computes the yield to maturity of a bond given its current price. Uses Newton-Raphson iteration.</p>
<pre><code class="lang-perl">p bond_yield(950, 1000, 0.05, 10) # ~5.7%
</code></pre>
</article>
<article class="doc-entry" id="doc-bondi-mass-step">
<h3><a class="doc-anchor" href="#doc-bondi-mass-step">#</a> <code>bondi_mass_step</code></h3>
<p><code>bondi_mass_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = bondi_mass_step $x
# or in a pipeline:
@list |> map bondi_mass_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bondprc">
<h3><a class="doc-anchor" href="#doc-bondprc">#</a> <code>bondprc</code></h3>
<p><code>bondprc</code> — finance (extended) builtin. Alias for <code>bond_price</code>.</p>
<pre><code class="lang-perl">my $result = bondprc $x
# or in a pipeline:
@list |> map bondprc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bondyld">
<h3><a class="doc-anchor" href="#doc-bondyld">#</a> <code>bondyld</code></h3>
<p><code>bondyld</code> — finance (extended) builtin. Alias for <code>bond_yield</code>.</p>
<pre><code class="lang-perl">my $result = bondyld $x
# or in a pipeline:
@list |> map bondyld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bool-each">
<h3><a class="doc-anchor" href="#doc-bool-each">#</a> <code>bool_each</code></h3>
<p><code>bool_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = bool_each $x
# or in a pipeline:
@list |> map bool_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bool-to-int">
<h3><a class="doc-anchor" href="#doc-bool-to-int">#</a> <code>bool_to_int</code></h3>
<p><code>bool_to_int</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = bool_to_int $input
</code></pre>
</article>
<article class="doc-entry" id="doc-boole-int">
<h3><a class="doc-anchor" href="#doc-boole-int">#</a> <code>boole_int</code></h3>
<p><code>boole_int</code> — batch 19 builtin. Alias for <code>boole_rule</code>.</p>
<pre><code class="lang-perl">my $result = boole_int $x
# or in a pipeline:
@list |> map boole_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boole-rule">
<h3><a class="doc-anchor" href="#doc-boole-rule">#</a> <code>boole_rule</code></h3>
<p><code>boole_rule</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = boole_rule $x
# or in a pipeline:
@list |> map boole_rule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bootstrap-se-estimate">
<h3><a class="doc-anchor" href="#doc-bootstrap-se-estimate">#</a> <code>bootstrap_se_estimate</code></h3>
<p><code>bootstrap_se_estimate</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = bootstrap_se_estimate $x
# or in a pipeline:
@list |> map bootstrap_se_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-borda-count-step">
<h3><a class="doc-anchor" href="#doc-borda-count-step">#</a> <code>borda_count_step</code></h3>
<p><code>borda_count_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = borda_count_step $x
# or in a pipeline:
@list |> map borda_count_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-borders-of-string">
<h3><a class="doc-anchor" href="#doc-borders-of-string">#</a> <code>borders_of_string</code></h3>
<p><code>borders_of_string</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = borders_of_string $x
# or in a pipeline:
@list |> map borders_of_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bornhuetter-ferguson">
<h3><a class="doc-anchor" href="#doc-bornhuetter-ferguson">#</a> <code>bornhuetter_ferguson</code></h3>
<p><code>bornhuetter_ferguson</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = bornhuetter_ferguson $x
# or in a pipeline:
@list |> map bornhuetter_ferguson |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boruvka-step">
<h3><a class="doc-anchor" href="#doc-boruvka-step">#</a> <code>boruvka_step</code></h3>
<p><code>boruvka_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = boruvka_step $x
# or in a pipeline:
@list |> map boruvka_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bose-einstein-g">
<h3><a class="doc-anchor" href="#doc-bose-einstein-g">#</a> <code>bose_einstein_g</code></h3>
<p><code>bose_einstein_g</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = bose_einstein_g $x
# or in a pipeline:
@list |> map bose_einstein_g |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bose-einstein-pmf">
<h3><a class="doc-anchor" href="#doc-bose-einstein-pmf">#</a> <code>bose_einstein_pmf</code></h3>
<p><code>bose_einstein_pmf</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = bose_einstein_pmf $x
# or in a pipeline:
@list |> map bose_einstein_pmf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boston-mechanism-step">
<h3><a class="doc-anchor" href="#doc-boston-mechanism-step">#</a> <code>boston_mechanism_step</code></h3>
<p><code>boston_mechanism_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = boston_mechanism_step $x
# or in a pipeline:
@list |> map boston_mechanism_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-both">
<h3><a class="doc-anchor" href="#doc-both">#</a> <code>both</code></h3>
<p><code>both</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = both $x
# or in a pipeline:
@list |> map both |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bowley-skewness">
<h3><a class="doc-anchor" href="#doc-bowley-skewness">#</a> <code>bowley_skewness</code></h3>
<p><code>bowley_skewness</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = bowley_skewness $x
# or in a pipeline:
@list |> map bowley_skewness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-box-blur-kernel">
<h3><a class="doc-anchor" href="#doc-box-blur-kernel">#</a> <code>box_blur_kernel</code></h3>
<p><code>box_blur_kernel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = box_blur_kernel $x
# or in a pipeline:
@list |> map box_blur_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-box-pierce-test">
<h3><a class="doc-anchor" href="#doc-box-pierce-test">#</a> <code>box_pierce_test</code></h3>
<p><code>box_pierce_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = box_pierce_test $x
# or in a pipeline:
@list |> map box_pierce_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boyer-lindquist-step">
<h3><a class="doc-anchor" href="#doc-boyer-lindquist-step">#</a> <code>boyer_lindquist_step</code></h3>
<p><code>boyer_lindquist_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = boyer_lindquist_step $x
# or in a pipeline:
@list |> map boyer_lindquist_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boykov-kolmogorov-step">
<h3><a class="doc-anchor" href="#doc-boykov-kolmogorov-step">#</a> <code>boykov_kolmogorov_step</code></h3>
<p><code>boykov_kolmogorov_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = boykov_kolmogorov_step $x
# or in a pipeline:
@list |> map boykov_kolmogorov_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bp-elevation">
<h3><a class="doc-anchor" href="#doc-bp-elevation">#</a> <code>bp_elevation</code></h3>
<p><code>bp_elevation</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = bp_elevation $x
# or in a pipeline:
@list |> map bp_elevation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bpm-to-midi-tick-us">
<h3><a class="doc-anchor" href="#doc-bpm-to-midi-tick-us">#</a> <code>bpm_to_midi_tick_us</code></h3>
<p><code>bpm_to_midi_tick_us</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = bpm_to_midi_tick_us $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bpm-to-period">
<h3><a class="doc-anchor" href="#doc-bpm-to-period">#</a> <code>bpm_to_period</code></h3>
<p><code>bpm_to_period</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = bpm_to_period $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bpm-to-spb">
<h3><a class="doc-anchor" href="#doc-bpm-to-spb">#</a> <code>bpm_to_spb</code></h3>
<p><code>bpm_to_spb</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = bpm_to_spb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bracelet-count">
<h3><a class="doc-anchor" href="#doc-bracelet-count">#</a> <code>bracelet_count</code></h3>
<p><code>bracelet_count</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = bracelet_count $x
# or in a pipeline:
@list |> map bracelet_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bracket">
<h3><a class="doc-anchor" href="#doc-bracket">#</a> <code>bracket</code></h3>
<p><code>bracket</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = bracket $x
# or in a pipeline:
@list |> map bracket |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-braille">
<h3><a class="doc-anchor" href="#doc-braille">#</a> <code>braille</code></h3>
<p><code>braille</code> — encoding / phonetics builtin. Alias for <code>braille_encode</code>.</p>
<pre><code class="lang-perl">my $result = braille $x
# or in a pipeline:
@list |> map braille |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-braille-encode">
<h3><a class="doc-anchor" href="#doc-braille-encode">#</a> <code>braille_encode</code></h3>
<p><code>braille_encode</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = braille_encode $x
# or in a pipeline:
@list |> map braille_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-branch-and-bound-step">
<h3><a class="doc-anchor" href="#doc-branch-and-bound-step">#</a> <code>branch_and_bound_step</code></h3>
<p><code>branch_and_bound_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = branch_and_bound_step $x
# or in a pipeline:
@list |> map branch_and_bound_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-branch-length-substitutions">
<h3><a class="doc-anchor" href="#doc-branch-length-substitutions">#</a> <code>branch_length_substitutions</code></h3>
<p><code>branch_length_substitutions</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = branch_length_substitutions $x
# or in a pipeline:
@list |> map branch_length_substitutions |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brans-dicke-step">
<h3><a class="doc-anchor" href="#doc-brans-dicke-step">#</a> <code>brans_dicke_step</code></h3>
<p><code>brans_dicke_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = brans_dicke_step $x
# or in a pipeline:
@list |> map brans_dicke_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brayton-efficiency">
<h3><a class="doc-anchor" href="#doc-brayton-efficiency">#</a> <code>brayton_efficiency</code></h3>
<p><code>brayton_efficiency</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = brayton_efficiency $x
# or in a pipeline:
@list |> map brayton_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-break-even">
<h3><a class="doc-anchor" href="#doc-break-even">#</a> <code>break_even</code></h3>
<p><code>break_even</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = break_even $x
# or in a pipeline:
@list |> map break_even |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-break-fn">
<h3><a class="doc-anchor" href="#doc-break-fn">#</a> <code>break_fn</code></h3>
<p><code>break_fn</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = break_fn $x
# or in a pipeline:
@list |> map break_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-breakeven">
<h3><a class="doc-anchor" href="#doc-breakeven">#</a> <code>breakeven</code></h3>
<p><code>breakeven</code> — finance builtin. Alias for <code>break_even</code>.</p>
<pre><code class="lang-perl">my $result = breakeven $x
# or in a pipeline:
@list |> map breakeven |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brent">
<h3><a class="doc-anchor" href="#doc-brent">#</a> <code>brent</code></h3>
<p><code>brent</code> — batch 19 builtin. Alias for <code>brent_root</code>.</p>
<pre><code class="lang-perl">my $result = brent $x
# or in a pipeline:
@list |> map brent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brent-root">
<h3><a class="doc-anchor" href="#doc-brent-root">#</a> <code>brent_root</code></h3>
<p><code>brent_root</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = brent_root $x
# or in a pipeline:
@list |> map brent_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-breusch-godfrey">
<h3><a class="doc-anchor" href="#doc-breusch-godfrey">#</a> <code>breusch_godfrey</code></h3>
<p><code>breusch_godfrey</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = breusch_godfrey $x
# or in a pipeline:
@list |> map breusch_godfrey |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-breusch-godfrey-test">
<h3><a class="doc-anchor" href="#doc-breusch-godfrey-test">#</a> <code>breusch_godfrey_test</code></h3>
<p><code>breusch_godfrey_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = breusch_godfrey_test $x
# or in a pipeline:
@list |> map breusch_godfrey_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-breusch-pagan-lm">
<h3><a class="doc-anchor" href="#doc-breusch-pagan-lm">#</a> <code>breusch_pagan_lm</code></h3>
<p><code>breusch_pagan_lm</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = breusch_pagan_lm $x
# or in a pipeline:
@list |> map breusch_pagan_lm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-breusch-pagan-test">
<h3><a class="doc-anchor" href="#doc-breusch-pagan-test">#</a> <code>breusch_pagan_test</code></h3>
<p><code>breusch_pagan_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = breusch_pagan_test $x
# or in a pipeline:
@list |> map breusch_pagan_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brewster">
<h3><a class="doc-anchor" href="#doc-brewster">#</a> <code>brewster</code></h3>
<p><code>brewster</code> — physics formulas builtin. Alias for <code>brewster_angle</code>.</p>
<pre><code class="lang-perl">my $result = brewster $x
# or in a pipeline:
@list |> map brewster |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brewster-angle">
<h3><a class="doc-anchor" href="#doc-brewster-angle">#</a> <code>brewster_angle</code></h3>
<p><code>brewster_angle</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = brewster_angle $x
# or in a pipeline:
@list |> map brewster_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bridge-edge">
<h3><a class="doc-anchor" href="#doc-bridge-edge">#</a> <code>bridge_edge</code></h3>
<p><code>bridge_edge</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = bridge_edge $x
# or in a pipeline:
@list |> map bridge_edge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bridges">
<h3><a class="doc-anchor" href="#doc-bridges">#</a> <code>bridges</code></h3>
<p><code>bridges</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = bridges $x
# or in a pipeline:
@list |> map bridges |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bridges-edges">
<h3><a class="doc-anchor" href="#doc-bridges-edges">#</a> <code>bridges_edges</code></h3>
<p><code>bridges_edges</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = bridges_edges $x
# or in a pipeline:
@list |> map bridges_edges |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brier-score">
<h3><a class="doc-anchor" href="#doc-brier-score">#</a> <code>brier_score</code></h3>
<p><code>brier_score</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = brier_score $x
# or in a pipeline:
@list |> map brier_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-blue">
<h3><a class="doc-anchor" href="#doc-bright-blue">#</a> <code>bright_blue</code></h3>
<p><code>bright_blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_blue $x
# or in a pipeline:
@list |> map bright_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-cyan">
<h3><a class="doc-anchor" href="#doc-bright-cyan">#</a> <code>bright_cyan</code></h3>
<p><code>bright_cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_cyan $x
# or in a pipeline:
@list |> map bright_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-green">
<h3><a class="doc-anchor" href="#doc-bright-green">#</a> <code>bright_green</code></h3>
<p><code>bright_green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_green $x
# or in a pipeline:
@list |> map bright_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-magenta">
<h3><a class="doc-anchor" href="#doc-bright-magenta">#</a> <code>bright_magenta</code></h3>
<p><code>bright_magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_magenta $x
# or in a pipeline:
@list |> map bright_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-red">
<h3><a class="doc-anchor" href="#doc-bright-red">#</a> <code>bright_red</code></h3>
<p><code>bright_red</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_red $x
# or in a pipeline:
@list |> map bright_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-white">
<h3><a class="doc-anchor" href="#doc-bright-white">#</a> <code>bright_white</code></h3>
<p><code>bright_white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_white $x
# or in a pipeline:
@list |> map bright_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-yellow">
<h3><a class="doc-anchor" href="#doc-bright-yellow">#</a> <code>bright_yellow</code></h3>
<p><code>bright_yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_yellow $x
# or in a pipeline:
@list |> map bright_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brkf">
<h3><a class="doc-anchor" href="#doc-brkf">#</a> <code>brkf</code></h3>
<p><code>brkf</code> — haskell list functions builtin. Alias for <code>break_fn</code>.</p>
<pre><code class="lang-perl">my $result = brkf $x
# or in a pipeline:
@list |> map brkf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bron-kerbosch">
<h3><a class="doc-anchor" href="#doc-bron-kerbosch">#</a> <code>bron_kerbosch</code></h3>
<p><code>bron_kerbosch</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = bron_kerbosch $x
# or in a pipeline:
@list |> map bron_kerbosch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brotli-distance-code-count">
<h3><a class="doc-anchor" href="#doc-brotli-distance-code-count">#</a> <code>brotli_distance_code_count</code></h3>
<p><code>brotli_distance_code_count</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = brotli_distance_code_count $x
# or in a pipeline:
@list |> map brotli_distance_code_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brotli-encode-meta">
<h3><a class="doc-anchor" href="#doc-brotli-encode-meta">#</a> <code>brotli_encode_meta</code></h3>
<p><code>brotli_encode_meta</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = brotli_encode_meta $x
# or in a pipeline:
@list |> map brotli_encode_meta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brotli-huffman-table">
<h3><a class="doc-anchor" href="#doc-brotli-huffman-table">#</a> <code>brotli_huffman_table</code></h3>
<p><code>brotli_huffman_table</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = brotli_huffman_table $x
# or in a pipeline:
@list |> map brotli_huffman_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brotli-meta-block">
<h3><a class="doc-anchor" href="#doc-brotli-meta-block">#</a> <code>brotli_meta_block</code></h3>
<p><code>brotli_meta_block</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = brotli_meta_block $x
# or in a pipeline:
@list |> map brotli_meta_block |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brown-york-quasilocal">
<h3><a class="doc-anchor" href="#doc-brown-york-quasilocal">#</a> <code>brown_york_quasilocal</code></h3>
<p><code>brown_york_quasilocal</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = brown_york_quasilocal $x
# or in a pipeline:
@list |> map brown_york_quasilocal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brunt-vaisala-full">
<h3><a class="doc-anchor" href="#doc-brunt-vaisala-full">#</a> <code>brunt_vaisala_full</code></h3>
<p><code>brunt_vaisala_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = brunt_vaisala_full $x
# or in a pipeline:
@list |> map brunt_vaisala_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brzozowski-derivative">
<h3><a class="doc-anchor" href="#doc-brzozowski-derivative">#</a> <code>brzozowski_derivative</code></h3>
<p><code>brzozowski_derivative</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = brzozowski_derivative $x
# or in a pipeline:
@list |> map brzozowski_derivative |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-call">
<h3><a class="doc-anchor" href="#doc-bs-call">#</a> <code>bs_call</code></h3>
<p><code>bs_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = bs_call $x
# or in a pipeline:
@list |> map bs_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-delta">
<h3><a class="doc-anchor" href="#doc-bs-delta">#</a> <code>bs_delta</code></h3>
<p><code>bs_delta</code> (aliases <code>bsdelta</code>, <code>option_delta</code>) computes the Black-Scholes delta (∂C/∂S). Args: S, K, T, r, sigma.</p>
<pre><code class="lang-perl">p bsdelta(100, 100, 1, 0.05, 0.2) # ≈ 0.64
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-gamma">
<h3><a class="doc-anchor" href="#doc-bs-gamma">#</a> <code>bs_gamma</code></h3>
<p><code>bs_gamma</code> computes the Black-Scholes gamma (∂²C/∂S²). Measures convexity of option value.</p>
<pre><code class="lang-perl">p bsgamma(100, 100, 1, 0.05, 0.2) # ≈ 0.019
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-put">
<h3><a class="doc-anchor" href="#doc-bs-put">#</a> <code>bs_put</code></h3>
<p><code>bs_put</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = bs_put $x
# or in a pipeline:
@list |> map bs_put |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-rho">
<h3><a class="doc-anchor" href="#doc-bs-rho">#</a> <code>bs_rho</code></h3>
<p><code>bs_rho</code> computes the Black-Scholes rho (∂C/∂r). Sensitivity to interest rate.</p>
<pre><code class="lang-perl">p bsrho(100, 100, 1, 0.05, 0.2) # ≈ 46
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-rho-call">
<h3><a class="doc-anchor" href="#doc-bs-rho-call">#</a> <code>bs_rho_call</code></h3>
<p><code>bs_rho_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = bs_rho_call $x
# or in a pipeline:
@list |> map bs_rho_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-theta">
<h3><a class="doc-anchor" href="#doc-bs-theta">#</a> <code>bs_theta</code></h3>
<p><code>bs_theta</code> computes the Black-Scholes theta (∂C/∂t). Time decay per unit time.</p>
<pre><code class="lang-perl">p bstheta(100, 100, 1, 0.05, 0.2) # negative (time decay)
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-theta-call">
<h3><a class="doc-anchor" href="#doc-bs-theta-call">#</a> <code>bs_theta_call</code></h3>
<p><code>bs_theta_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = bs_theta_call $x
# or in a pipeline:
@list |> map bs_theta_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-vega">
<h3><a class="doc-anchor" href="#doc-bs-vega">#</a> <code>bs_vega</code></h3>
<p><code>bs_vega</code> computes the Black-Scholes vega (∂C/∂σ). Sensitivity to volatility.</p>
<pre><code class="lang-perl">p bsvega(100, 100, 1, 0.05, 0.2) # ≈ 37.5
</code></pre>
</article>
<article class="doc-entry" id="doc-bsa-dubois">
<h3><a class="doc-anchor" href="#doc-bsa-dubois">#</a> <code>bsa_dubois</code></h3>
<p><code>bsa_dubois</code> — batch 12 builtin. Alias for <code>body_surface_area_dubois</code>.</p>
<pre><code class="lang-perl">my $result = bsa_dubois $x
# or in a pipeline:
@list |> map bsa_dubois |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bsearch">
<h3><a class="doc-anchor" href="#doc-bsearch">#</a> <code>bsearch</code></h3>
<p><code>bsearch</code> — collection (batch 2) builtin. Alias for <code>binary_search</code>.</p>
<pre><code class="lang-perl">my $result = bsearch $x
# or in a pipeline:
@list |> map bsearch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bsgs-discrete-log">
<h3><a class="doc-anchor" href="#doc-bsgs-discrete-log">#</a> <code>bsgs_discrete_log</code></h3>
<p><code>bsgs_discrete_log</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = bsgs_discrete_log $x
# or in a pipeline:
@list |> map bsgs_discrete_log |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bsize">
<h3><a class="doc-anchor" href="#doc-bsize">#</a> <code>bsize</code></h3>
<p><code>bsize</code> — misc / utility builtin. Alias for <code>byte_size</code>.</p>
<pre><code class="lang-perl">my $result = bsize $x
# or in a pipeline:
@list |> map bsize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-btc-addr-check">
<h3><a class="doc-anchor" href="#doc-btc-addr-check">#</a> <code>btc_addr_check</code></h3>
<p><code>btc_addr_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = btc_addr_check $x
# or in a pipeline:
@list |> map btc_addr_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-btch">
<h3><a class="doc-anchor" href="#doc-btch">#</a> <code>btch</code></h3>
<p><code>btch</code> — additional missing stdlib functions builtin. Alias for <code>batched</code>.</p>
<pre><code class="lang-perl">my $result = btch $x
# or in a pipeline:
@list |> map btch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-btrim">
<h3><a class="doc-anchor" href="#doc-btrim">#</a> <code>btrim</code></h3>
<p><code>btrim</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = btrim $x
# or in a pipeline:
@list |> map btrim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-btu-to-joules">
<h3><a class="doc-anchor" href="#doc-btu-to-joules">#</a> <code>btu_to_joules</code></h3>
<p><code>btu_to_joules</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = btu_to_joules $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bucket">
<h3><a class="doc-anchor" href="#doc-bucket">#</a> <code>bucket</code></h3>
<p><code>bucket</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = bucket $x
# or in a pipeline:
@list |> map bucket |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-buffer-capacity-acid-base">
<h3><a class="doc-anchor" href="#doc-buffer-capacity-acid-base">#</a> <code>buffer_capacity_acid_base</code></h3>
<p><code>buffer_capacity_acid_base</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = buffer_capacity_acid_base $x
# or in a pipeline:
@list |> map buffer_capacity_acid_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bulirsch-stoer-step">
<h3><a class="doc-anchor" href="#doc-bulirsch-stoer-step">#</a> <code>bulirsch_stoer_step</code></h3>
<p><code>bulirsch_stoer_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = bulirsch_stoer_step $x
# or in a pipeline:
@list |> map bulirsch_stoer_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-burr-xii-cdf">
<h3><a class="doc-anchor" href="#doc-burr-xii-cdf">#</a> <code>burr_xii_cdf</code></h3>
<p><code>burr_xii_cdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = burr_xii_cdf $x
# or in a pipeline:
@list |> map burr_xii_cdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-burr-xii-pdf">
<h3><a class="doc-anchor" href="#doc-burr-xii-pdf">#</a> <code>burr_xii_pdf</code></h3>
<p><code>burr_xii_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = burr_xii_pdf $x
# or in a pipeline:
@list |> map burr_xii_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-business-days-between">
<h3><a class="doc-anchor" href="#doc-business-days-between">#</a> <code>business_days_between</code></h3>
<p><code>business_days_between</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = business_days_between $x
# or in a pipeline:
@list |> map business_days_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-butlast">
<h3><a class="doc-anchor" href="#doc-butlast">#</a> <code>butlast</code></h3>
<p><code>butlast</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = butlast $x
# or in a pipeline:
@list |> map butlast |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-butler-volmer-current">
<h3><a class="doc-anchor" href="#doc-butler-volmer-current">#</a> <code>butler_volmer_current</code></h3>
<p><code>butler_volmer_current</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = butler_volmer_current $x
# or in a pipeline:
@list |> map butler_volmer_current |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-butter-hp-mag">
<h3><a class="doc-anchor" href="#doc-butter-hp-mag">#</a> <code>butter_hp_mag</code></h3>
<p><code>butter_hp_mag</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = butter_hp_mag $x
# or in a pipeline:
@list |> map butter_hp_mag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-butter-lp-re">
<h3><a class="doc-anchor" href="#doc-butter-lp-re">#</a> <code>butter_lp_re</code></h3>
<p><code>butter_lp_re</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = butter_lp_re $x
# or in a pipeline:
@list |> map butter_lp_re |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-butterworth-order">
<h3><a class="doc-anchor" href="#doc-butterworth-order">#</a> <code>butterworth_order</code></h3>
<p><code>butterworth_order</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = butterworth_order $x
# or in a pipeline:
@list |> map butterworth_order |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-butterworth-prewarp">
<h3><a class="doc-anchor" href="#doc-butterworth-prewarp">#</a> <code>butterworth_prewarp</code></h3>
<p><code>butterworth_prewarp</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = butterworth_prewarp $x
# or in a pipeline:
@list |> map butterworth_prewarp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bwt-decode">
<h3><a class="doc-anchor" href="#doc-bwt-decode">#</a> <code>bwt_decode</code></h3>
<p><code>bwt_decode</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = bwt_decode $x
# or in a pipeline:
@list |> map bwt_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bwt-encode">
<h3><a class="doc-anchor" href="#doc-bwt-encode">#</a> <code>bwt_encode</code></h3>
<p><code>bwt_encode</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = bwt_encode $x
# or in a pipeline:
@list |> map bwt_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-byte-length">
<h3><a class="doc-anchor" href="#doc-byte-length">#</a> <code>byte_length</code></h3>
<p><code>byte_length</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = byte_length $x
# or in a pipeline:
@list |> map byte_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-byte-size">
<h3><a class="doc-anchor" href="#doc-byte-size">#</a> <code>byte_size</code></h3>
<p><code>byte_size</code> — misc / utility builtin.</p>
<pre><code class="lang-perl">my $result = byte_size $x
# or in a pipeline:
@list |> map byte_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bytecode-disasm-step">
<h3><a class="doc-anchor" href="#doc-bytecode-disasm-step">#</a> <code>bytecode_disasm_step</code></h3>
<p><code>bytecode_disasm_step</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = bytecode_disasm_step $x
# or in a pipeline:
@list |> map bytecode_disasm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-bits">
<h3><a class="doc-anchor" href="#doc-bytes-to-bits">#</a> <code>bytes_to_bits</code></h3>
<p><code>bytes_to_bits</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_bits $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-gb">
<h3><a class="doc-anchor" href="#doc-bytes-to-gb">#</a> <code>bytes_to_gb</code></h3>
<p><code>bytes_to_gb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_gb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-hex-str">
<h3><a class="doc-anchor" href="#doc-bytes-to-hex-str">#</a> <code>bytes_to_hex_str</code></h3>
<p><code>bytes_to_hex_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_hex_str $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-kb">
<h3><a class="doc-anchor" href="#doc-bytes-to-kb">#</a> <code>bytes_to_kb</code></h3>
<p><code>bytes_to_kb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_kb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-mb">
<h3><a class="doc-anchor" href="#doc-bytes-to-mb">#</a> <code>bytes_to_mb</code></h3>
<p><code>bytes_to_mb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_mb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bz2-encode-step">
<h3><a class="doc-anchor" href="#doc-bz2-encode-step">#</a> <code>bz2_encode_step</code></h3>
<p><code>bz2_encode_step</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = bz2_encode_step $x
# or in a pipeline:
@list |> map bz2_encode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-c256">
<h3><a class="doc-anchor" href="#doc-c256">#</a> <code>c256</code></h3>
<p><code>c256</code> — color / ansi builtin. Alias for <code>color256</code>.</p>
<pre><code class="lang-perl">my $result = c256 $x
# or in a pipeline:
@list |> map c256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-c2s">
<h3><a class="doc-anchor" href="#doc-c2s">#</a> <code>c2s</code></h3>
<p><code>c2s</code> — string processing (uncategorized batch) builtin. Alias for <code>camel_to_snake</code>.</p>
<pre><code class="lang-perl">my $result = c2s $x
# or in a pipeline:
@list |> map c2s |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-c-parallel">
<h3><a class="doc-anchor" href="#doc-c-parallel">#</a> <code>c_parallel</code></h3>
<p><code>c_parallel</code> — batch 12 builtin. Alias for <code>capacitance_parallel</code>.</p>
<pre><code class="lang-perl">my $result = c_parallel $x
# or in a pipeline:
@list |> map c_parallel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-c-series">
<h3><a class="doc-anchor" href="#doc-c-series">#</a> <code>c_series</code></h3>
<p><code>c_series</code> — batch 12 builtin. Alias for <code>capacitance_series</code>.</p>
<pre><code class="lang-perl">my $result = c_series $x
# or in a pipeline:
@list |> map c_series |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-c-to-f">
<h3><a class="doc-anchor" href="#doc-c-to-f">#</a> <code>c_to_f</code></h3>
<p><code>c_to_f</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = c_to_f $input
</code></pre>
</article>
<article class="doc-entry" id="doc-c-to-k">
<h3><a class="doc-anchor" href="#doc-c-to-k">#</a> <code>c_to_k</code></h3>
<p><code>c_to_k</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = c_to_k $input
</code></pre>
</article>
<article class="doc-entry" id="doc-cabling-pair-signature">
<h3><a class="doc-anchor" href="#doc-cabling-pair-signature">#</a> <code>cabling_pair_signature</code></h3>
<p><code>cabling_pair_signature</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = cabling_pair_signature $x
# or in a pipeline:
@list |> map cabling_pair_signature |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cache-clear">
<h3><a class="doc-anchor" href="#doc-cache-clear">#</a> <code>cache_clear</code></h3>
<p><code>cache_clear</code> — caching builtin.</p>
<pre><code class="lang-perl">my $result = cache_clear $x
# or in a pipeline:
@list |> map cache_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cache-control-parse">
<h3><a class="doc-anchor" href="#doc-cache-control-parse">#</a> <code>cache_control_parse</code></h3>
<p><code>cache_control_parse</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = cache_control_parse $x
# or in a pipeline:
@list |> map cache_control_parse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cache-exists">
<h3><a class="doc-anchor" href="#doc-cache-exists">#</a> <code>cache_exists</code></h3>
<p><code>cache_exists</code> — caching builtin.</p>
<pre><code class="lang-perl">my $result = cache_exists $x
# or in a pipeline:
@list |> map cache_exists |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cache-stats">
<h3><a class="doc-anchor" href="#doc-cache-stats">#</a> <code>cache_stats</code></h3>
<p><code>cache_stats</code> — caching builtin.</p>
<pre><code class="lang-perl">my $result = cache_stats $x
# or in a pipeline:
@list |> map cache_stats |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cacheview">
<h3><a class="doc-anchor" href="#doc-cacheview">#</a> <code>cacheview</code></h3>
<p><code>cacheview</code> — caching builtin.</p>
<pre><code class="lang-perl">my $result = cacheview $x
# or in a pipeline:
@list |> map cacheview |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-caesar-shift">
<h3><a class="doc-anchor" href="#doc-caesar-shift">#</a> <code>caesar_shift</code></h3>
<p><code>caesar_shift</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = caesar_shift $x
# or in a pipeline:
@list |> map caesar_shift |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cagr">
<h3><a class="doc-anchor" href="#doc-cagr">#</a> <code>cagr</code></h3>
<p><code>cagr</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = cagr $x
# or in a pipeline:
@list |> map cagr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cake-number">
<h3><a class="doc-anchor" href="#doc-cake-number">#</a> <code>cake_number</code></h3>
<p><code>cake_number</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = cake_number $x
# or in a pipeline:
@list |> map cake_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cal-to-joules">
<h3><a class="doc-anchor" href="#doc-cal-to-joules">#</a> <code>cal_to_joules</code></h3>
<p><code>cal_to_joules</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = cal_to_joules $input
</code></pre>
</article>
<article class="doc-entry" id="doc-calmar-ratio">
<h3><a class="doc-anchor" href="#doc-calmar-ratio">#</a> <code>calmar_ratio</code></h3>
<p><code>calmar_ratio</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = calmar_ratio $x
# or in a pipeline:
@list |> map calmar_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-calorimeter-dt">
<h3><a class="doc-anchor" href="#doc-calorimeter-dt">#</a> <code>calorimeter_dt</code></h3>
<p><code>calorimeter_dt</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = calorimeter_dt $x
# or in a pipeline:
@list |> map calorimeter_dt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-calorimetric-heat-battery">
<h3><a class="doc-anchor" href="#doc-calorimetric-heat-battery">#</a> <code>calorimetric_heat_battery</code></h3>
<p><code>calorimetric_heat_battery</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = calorimetric_heat_battery $x
# or in a pipeline:
@list |> map calorimetric_heat_battery |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-camel-to-snake">
<h3><a class="doc-anchor" href="#doc-camel-to-snake">#</a> <code>camel_to_snake</code></h3>
<p><code>camel_to_snake</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = camel_to_snake $input
</code></pre>
</article>
<article class="doc-entry" id="doc-camel-words">
<h3><a class="doc-anchor" href="#doc-camel-words">#</a> <code>camel_words</code></h3>
<p><code>camel_words</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = camel_words $x
# or in a pipeline:
@list |> map camel_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-canny-threshold-step">
<h3><a class="doc-anchor" href="#doc-canny-threshold-step">#</a> <code>canny_threshold_step</code></h3>
<p><code>canny_threshold_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = canny_threshold_step $x
# or in a pipeline:
@list |> map canny_threshold_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cap">
<h3><a class="doc-anchor" href="#doc-cap">#</a> <code>cap</code></h3>
<p><code>cap</code> — trivial string ops builtin. Alias for <code>capitalize</code>.</p>
<pre><code class="lang-perl">my $result = cap $x
# or in a pipeline:
@list |> map cap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capacitance">
<h3><a class="doc-anchor" href="#doc-capacitance">#</a> <code>capacitance</code></h3>
<p><code>capacitance</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = capacitance $x
# or in a pipeline:
@list |> map capacitance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capacitance-parallel">
<h3><a class="doc-anchor" href="#doc-capacitance-parallel">#</a> <code>capacitance_parallel</code></h3>
<p><code>capacitance_parallel</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = capacitance_parallel $x
# or in a pipeline:
@list |> map capacitance_parallel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capacitance-parallel-sum">
<h3><a class="doc-anchor" href="#doc-capacitance-parallel-sum">#</a> <code>capacitance_parallel_sum</code></h3>
<p><code>capacitance_parallel_sum</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = capacitance_parallel_sum $x
# or in a pipeline:
@list |> map capacitance_parallel_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capacitance-series">
<h3><a class="doc-anchor" href="#doc-capacitance-series">#</a> <code>capacitance_series</code></h3>
<p><code>capacitance_series</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = capacitance_series $x
# or in a pipeline:
@list |> map capacitance_series |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capacitor-charge">
<h3><a class="doc-anchor" href="#doc-capacitor-charge">#</a> <code>capacitor_charge</code></h3>
<p><code>capacitor_charge</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = capacitor_charge $x
# or in a pipeline:
@list |> map capacitor_charge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capacitor-energy">
<h3><a class="doc-anchor" href="#doc-capacitor-energy">#</a> <code>capacitor_energy</code></h3>
<p><code>capacitor_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = capacitor_energy $x
# or in a pipeline:
@list |> map capacitor_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capenergy">
<h3><a class="doc-anchor" href="#doc-capenergy">#</a> <code>capenergy</code></h3>
<p><code>capenergy</code> — physics formulas builtin. Alias for <code>capacitor_energy</code>.</p>
<pre><code class="lang-perl">my $result = capenergy $x
# or in a pipeline:
@list |> map capenergy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capg">
<h3><a class="doc-anchor" href="#doc-capg">#</a> <code>capg</code></h3>
<p><code>capg</code> — extended stdlib builtin. Alias for <code>capture_groups</code>.</p>
<pre><code class="lang-perl">my $result = capg $x
# or in a pipeline:
@list |> map capg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capitalize">
<h3><a class="doc-anchor" href="#doc-capitalize">#</a> <code>capitalize</code></h3>
<p><code>capitalize</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = capitalize $x
# or in a pipeline:
@list |> map capitalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capitalize-words">
<h3><a class="doc-anchor" href="#doc-capitalize-words">#</a> <code>capitalize_words</code></h3>
<p><code>capitalize_words</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = capitalize_words $x
# or in a pipeline:
@list |> map capitalize_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capm">
<h3><a class="doc-anchor" href="#doc-capm">#</a> <code>capm</code></h3>
<p><code>capm($risk_free, $beta, $market_return)</code> — computes expected return using the Capital Asset Pricing Model: rf + β(rm - rf).</p>
<pre><code class="lang-perl">p capm(0.02, 1.2, 0.08) # 9.2% expected return
</code></pre>
</article>
<article class="doc-entry" id="doc-capm-expected-return">
<h3><a class="doc-anchor" href="#doc-capm-expected-return">#</a> <code>capm_expected_return</code></h3>
<p><code>capm_expected_return</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = capm_expected_return $x
# or in a pipeline:
@list |> map capm_expected_return |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capture-groups">
<h3><a class="doc-anchor" href="#doc-capture-groups">#</a> <code>capture_groups</code></h3>
<p><code>capture_groups</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = capture_groups $x
# or in a pipeline:
@list |> map capture_groups |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-carmichael-q">
<h3><a class="doc-anchor" href="#doc-carmichael-q">#</a> <code>carmichael_q</code></h3>
<p><code>carmichael_q</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = carmichael_q $x
# or in a pipeline:
@list |> map carmichael_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-carnot-efficiency">
<h3><a class="doc-anchor" href="#doc-carnot-efficiency">#</a> <code>carnot_efficiency</code></h3>
<p><code>carnot_efficiency</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = carnot_efficiency $x
# or in a pipeline:
@list |> map carnot_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-carrying-capacity-from-data">
<h3><a class="doc-anchor" href="#doc-carrying-capacity-from-data">#</a> <code>carrying_capacity_from_data</code></h3>
<p><code>carrying_capacity_from_data</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = carrying_capacity_from_data $x
# or in a pipeline:
@list |> map carrying_capacity_from_data |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cart-n">
<h3><a class="doc-anchor" href="#doc-cart-n">#</a> <code>cart_n</code></h3>
<p><code>cart_n</code> — batch 10 builtin. Alias for <code>cartesian_product_n</code>.</p>
<pre><code class="lang-perl">my $result = cart_n $x
# or in a pipeline:
@list |> map cart_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartan-determinant-a2">
<h3><a class="doc-anchor" href="#doc-cartan-determinant-a2">#</a> <code>cartan_determinant_a2</code></h3>
<p><code>cartan_determinant_a2</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = cartan_determinant_a2 $x
# or in a pipeline:
@list |> map cartan_determinant_a2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartan-matrix-b2">
<h3><a class="doc-anchor" href="#doc-cartan-matrix-b2">#</a> <code>cartan_matrix_b2</code></h3>
<p><code>cartan_matrix_b2</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = cartan_matrix_b2 $x
# or in a pipeline:
@list |> map cartan_matrix_b2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartesian-power">
<h3><a class="doc-anchor" href="#doc-cartesian-power">#</a> <code>cartesian_power</code></h3>
<p><code>cartesian_power</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = cartesian_power $x
# or in a pipeline:
@list |> map cartesian_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartesian-product">
<h3><a class="doc-anchor" href="#doc-cartesian-product">#</a> <code>cartesian_product</code></h3>
<p><code>cartesian_product</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = cartesian_product $x
# or in a pipeline:
@list |> map cartesian_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartesian-product-n">
<h3><a class="doc-anchor" href="#doc-cartesian-product-n">#</a> <code>cartesian_product_n</code></h3>
<p><code>cartesian_product_n</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = cartesian_product_n $x
# or in a pipeline:
@list |> map cartesian_product_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartpow">
<h3><a class="doc-anchor" href="#doc-cartpow">#</a> <code>cartpow</code></h3>
<p><code>cartpow</code> — extended stdlib batch 3 builtin. Alias for <code>cartesian_power</code>.</p>
<pre><code class="lang-perl">my $result = cartpow $x
# or in a pipeline:
@list |> map cartpow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-admm-lasso-step">
<h3><a class="doc-anchor" href="#doc-cas-admm-lasso-step">#</a> <code>cas_admm_lasso_step</code></h3>
<p><code>cas_admm_lasso_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_admm_lasso_step $x
# or in a pipeline:
@list |> map cas_admm_lasso_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-alternating-projection">
<h3><a class="doc-anchor" href="#doc-cas-alternating-projection">#</a> <code>cas_alternating_projection</code></h3>
<p><code>cas_alternating_projection</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_alternating_projection $x
# or in a pipeline:
@list |> map cas_alternating_projection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-arnoldi-iteration-step">
<h3><a class="doc-anchor" href="#doc-cas-arnoldi-iteration-step">#</a> <code>cas_arnoldi_iteration_step</code></h3>
<p><code>cas_arnoldi_iteration_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_arnoldi_iteration_step $x
# or in a pipeline:
@list |> map cas_arnoldi_iteration_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-basis-pursuit-step">
<h3><a class="doc-anchor" href="#doc-cas-basis-pursuit-step">#</a> <code>cas_basis_pursuit_step</code></h3>
<p><code>cas_basis_pursuit_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_basis_pursuit_step $x
# or in a pipeline:
@list |> map cas_basis_pursuit_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-block-lu-step">
<h3><a class="doc-anchor" href="#doc-cas-block-lu-step">#</a> <code>cas_block_lu_step</code></h3>
<p><code>cas_block_lu_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_block_lu_step $x
# or in a pipeline:
@list |> map cas_block_lu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-buchberger-step">
<h3><a class="doc-anchor" href="#doc-cas-buchberger-step">#</a> <code>cas_buchberger_step</code></h3>
<p><code>cas_buchberger_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_buchberger_step $x
# or in a pipeline:
@list |> map cas_buchberger_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-bunch-kaufman-step">
<h3><a class="doc-anchor" href="#doc-cas-bunch-kaufman-step">#</a> <code>cas_bunch_kaufman_step</code></h3>
<p><code>cas_bunch_kaufman_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_bunch_kaufman_step $x
# or in a pipeline:
@list |> map cas_bunch_kaufman_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-burnside-count-step">
<h3><a class="doc-anchor" href="#doc-cas-burnside-count-step">#</a> <code>cas_burnside_count_step</code></h3>
<p><code>cas_burnside_count_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_burnside_count_step $x
# or in a pipeline:
@list |> map cas_burnside_count_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-chebyshev-eval">
<h3><a class="doc-anchor" href="#doc-cas-chebyshev-eval">#</a> <code>cas_chebyshev_eval</code></h3>
<p><code>cas_chebyshev_eval</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_chebyshev_eval $x
# or in a pipeline:
@list |> map cas_chebyshev_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-cholesky-step">
<h3><a class="doc-anchor" href="#doc-cas-cholesky-step">#</a> <code>cas_cholesky_step</code></h3>
<p><code>cas_cholesky_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_cholesky_step $x
# or in a pipeline:
@list |> map cas_cholesky_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-classical-gram-schmidt">
<h3><a class="doc-anchor" href="#doc-cas-classical-gram-schmidt">#</a> <code>cas_classical_gram_schmidt</code></h3>
<p><code>cas_classical_gram_schmidt</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_classical_gram_schmidt $x
# or in a pipeline:
@list |> map cas_classical_gram_schmidt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-companion-matrix-root">
<h3><a class="doc-anchor" href="#doc-cas-companion-matrix-root">#</a> <code>cas_companion_matrix_root</code></h3>
<p><code>cas_companion_matrix_root</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_companion_matrix_root $x
# or in a pipeline:
@list |> map cas_companion_matrix_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-constrained-ls-step">
<h3><a class="doc-anchor" href="#doc-cas-constrained-ls-step">#</a> <code>cas_constrained_ls_step</code></h3>
<p><code>cas_constrained_ls_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_constrained_ls_step $x
# or in a pipeline:
@list |> map cas_constrained_ls_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-continued-fraction-step">
<h3><a class="doc-anchor" href="#doc-cas-continued-fraction-step">#</a> <code>cas_continued_fraction_step</code></h3>
<p><code>cas_continued_fraction_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_continued_fraction_step $x
# or in a pipeline:
@list |> map cas_continued_fraction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-cosamp-step">
<h3><a class="doc-anchor" href="#doc-cas-cosamp-step">#</a> <code>cas_cosamp_step</code></h3>
<p><code>cas_cosamp_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_cosamp_step $x
# or in a pipeline:
@list |> map cas_cosamp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-descartes-rule-count">
<h3><a class="doc-anchor" href="#doc-cas-descartes-rule-count">#</a> <code>cas_descartes_rule_count</code></h3>
<p><code>cas_descartes_rule_count</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_descartes_rule_count $x
# or in a pipeline:
@list |> map cas_descartes_rule_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-drazin-inverse-step">
<h3><a class="doc-anchor" href="#doc-cas-drazin-inverse-step">#</a> <code>cas_drazin_inverse_step</code></h3>
<p><code>cas_drazin_inverse_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_drazin_inverse_step $x
# or in a pipeline:
@list |> map cas_drazin_inverse_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-dykstra-step">
<h3><a class="doc-anchor" href="#doc-cas-dykstra-step">#</a> <code>cas_dykstra_step</code></h3>
<p><code>cas_dykstra_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_dykstra_step $x
# or in a pipeline:
@list |> map cas_dykstra_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-eigenvalue-inverse-iteration">
<h3><a class="doc-anchor" href="#doc-cas-eigenvalue-inverse-iteration">#</a> <code>cas_eigenvalue_inverse_iteration</code></h3>
<p><code>cas_eigenvalue_inverse_iteration</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_eigenvalue_inverse_iteration $x
# or in a pipeline:
@list |> map cas_eigenvalue_inverse_iteration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-elastic-net-step">
<h3><a class="doc-anchor" href="#doc-cas-elastic-net-step">#</a> <code>cas_elastic_net_step</code></h3>
<p><code>cas_elastic_net_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_elastic_net_step $x
# or in a pipeline:
@list |> map cas_elastic_net_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-expand-two-terms">
<h3><a class="doc-anchor" href="#doc-cas-expand-two-terms">#</a> <code>cas_expand_two_terms</code></h3>
<p><code>cas_expand_two_terms</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_expand_two_terms $x
# or in a pipeline:
@list |> map cas_expand_two_terms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-extended-euclid-step">
<h3><a class="doc-anchor" href="#doc-cas-extended-euclid-step">#</a> <code>cas_extended_euclid_step</code></h3>
<p><code>cas_extended_euclid_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_extended_euclid_step $x
# or in a pipeline:
@list |> map cas_extended_euclid_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-factor-quadratic">
<h3><a class="doc-anchor" href="#doc-cas-factor-quadratic">#</a> <code>cas_factor_quadratic</code></h3>
<p><code>cas_factor_quadratic</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_factor_quadratic $x
# or in a pipeline:
@list |> map cas_factor_quadratic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-gcd-polynomial-step">
<h3><a class="doc-anchor" href="#doc-cas-gcd-polynomial-step">#</a> <code>cas_gcd_polynomial_step</code></h3>
<p><code>cas_gcd_polynomial_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_gcd_polynomial_step $x
# or in a pipeline:
@list |> map cas_gcd_polynomial_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-gegenbauer-eval">
<h3><a class="doc-anchor" href="#doc-cas-gegenbauer-eval">#</a> <code>cas_gegenbauer_eval</code></h3>
<p><code>cas_gegenbauer_eval</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_gegenbauer_eval $x
# or in a pipeline:
@list |> map cas_gegenbauer_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-generalized-eigen">
<h3><a class="doc-anchor" href="#doc-cas-generalized-eigen">#</a> <code>cas_generalized_eigen</code></h3>
<p><code>cas_generalized_eigen</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_generalized_eigen $x
# or in a pipeline:
@list |> map cas_generalized_eigen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-givens-rotation-apply">
<h3><a class="doc-anchor" href="#doc-cas-givens-rotation-apply">#</a> <code>cas_givens_rotation_apply</code></h3>
<p><code>cas_givens_rotation_apply</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_givens_rotation_apply $x
# or in a pipeline:
@list |> map cas_givens_rotation_apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-groebner-lt-step">
<h3><a class="doc-anchor" href="#doc-cas-groebner-lt-step">#</a> <code>cas_groebner_lt_step</code></h3>
<p><code>cas_groebner_lt_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_groebner_lt_step $x
# or in a pipeline:
@list |> map cas_groebner_lt_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-hermite-eval">
<h3><a class="doc-anchor" href="#doc-cas-hermite-eval">#</a> <code>cas_hermite_eval</code></h3>
<p><code>cas_hermite_eval</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_hermite_eval $x
# or in a pipeline:
@list |> map cas_hermite_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-hermite-normal-step">
<h3><a class="doc-anchor" href="#doc-cas-hermite-normal-step">#</a> <code>cas_hermite_normal_step</code></h3>
<p><code>cas_hermite_normal_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_hermite_normal_step $x
# or in a pipeline:
@list |> map cas_hermite_normal_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-householder-reflection">
<h3><a class="doc-anchor" href="#doc-cas-householder-reflection">#</a> <code>cas_householder_reflection</code></h3>
<p><code>cas_householder_reflection</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_householder_reflection $x
# or in a pipeline:
@list |> map cas_householder_reflection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-iht-iteration">
<h3><a class="doc-anchor" href="#doc-cas-iht-iteration">#</a> <code>cas_iht_iteration</code></h3>
<p><code>cas_iht_iteration</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_iht_iteration $x
# or in a pipeline:
@list |> map cas_iht_iteration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-indicator-simplex-proj">
<h3><a class="doc-anchor" href="#doc-cas-indicator-simplex-proj">#</a> <code>cas_indicator_simplex_proj</code></h3>
<p><code>cas_indicator_simplex_proj</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_indicator_simplex_proj $x
# or in a pipeline:
@list |> map cas_indicator_simplex_proj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-jacobi-eigen-step">
<h3><a class="doc-anchor" href="#doc-cas-jacobi-eigen-step">#</a> <code>cas_jacobi_eigen_step</code></h3>
<p><code>cas_jacobi_eigen_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_jacobi_eigen_step $x
# or in a pipeline:
@list |> map cas_jacobi_eigen_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-jacobi-eval">
<h3><a class="doc-anchor" href="#doc-cas-jacobi-eval">#</a> <code>cas_jacobi_eval</code></h3>
<p><code>cas_jacobi_eval</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_jacobi_eval $x
# or in a pipeline:
@list |> map cas_jacobi_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-kronecker-product-step">
<h3><a class="doc-anchor" href="#doc-cas-kronecker-product-step">#</a> <code>cas_kronecker_product_step</code></h3>
<p><code>cas_kronecker_product_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_kronecker_product_step $x
# or in a pipeline:
@list |> map cas_kronecker_product_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-lagrange-interpolate">
<h3><a class="doc-anchor" href="#doc-cas-lagrange-interpolate">#</a> <code>cas_lagrange_interpolate</code></h3>
<p><code>cas_lagrange_interpolate</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_lagrange_interpolate $x
# or in a pipeline:
@list |> map cas_lagrange_interpolate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-laguerre-eval">
<h3><a class="doc-anchor" href="#doc-cas-laguerre-eval">#</a> <code>cas_laguerre_eval</code></h3>
<p><code>cas_laguerre_eval</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_laguerre_eval $x
# or in a pipeline:
@list |> map cas_laguerre_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-lanczos-iteration-step">
<h3><a class="doc-anchor" href="#doc-cas-lanczos-iteration-step">#</a> <code>cas_lanczos_iteration_step</code></h3>
<p><code>cas_lanczos_iteration_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_lanczos_iteration_step $x
# or in a pipeline:
@list |> map cas_lanczos_iteration_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-lasso-soft-threshold">
<h3><a class="doc-anchor" href="#doc-cas-lasso-soft-threshold">#</a> <code>cas_lasso_soft_threshold</code></h3>
<p><code>cas_lasso_soft_threshold</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_lasso_soft_threshold $x
# or in a pipeline:
@list |> map cas_lasso_soft_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-ldlt-step">
<h3><a class="doc-anchor" href="#doc-cas-ldlt-step">#</a> <code>cas_ldlt_step</code></h3>
<p><code>cas_ldlt_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_ldlt_step $x
# or in a pipeline:
@list |> map cas_ldlt_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-least-squares-solve">
<h3><a class="doc-anchor" href="#doc-cas-least-squares-solve">#</a> <code>cas_least_squares_solve</code></h3>
<p><code>cas_least_squares_solve</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_least_squares_solve $x
# or in a pipeline:
@list |> map cas_least_squares_solve |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-legendre-eval">
<h3><a class="doc-anchor" href="#doc-cas-legendre-eval">#</a> <code>cas_legendre_eval</code></h3>
<p><code>cas_legendre_eval</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_legendre_eval $x
# or in a pipeline:
@list |> map cas_legendre_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-lyapunov-continuous-step">
<h3><a class="doc-anchor" href="#doc-cas-lyapunov-continuous-step">#</a> <code>cas_lyapunov_continuous_step</code></h3>
<p><code>cas_lyapunov_continuous_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_lyapunov_continuous_step $x
# or in a pipeline:
@list |> map cas_lyapunov_continuous_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-lyapunov-discrete-step">
<h3><a class="doc-anchor" href="#doc-cas-lyapunov-discrete-step">#</a> <code>cas_lyapunov_discrete_step</code></h3>
<p><code>cas_lyapunov_discrete_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_lyapunov_discrete_step $x
# or in a pipeline:
@list |> map cas_lyapunov_discrete_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-macaulay-matrix-step">
<h3><a class="doc-anchor" href="#doc-cas-macaulay-matrix-step">#</a> <code>cas_macaulay_matrix_step</code></h3>
<p><code>cas_macaulay_matrix_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_macaulay_matrix_step $x
# or in a pipeline:
@list |> map cas_macaulay_matrix_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-matrix-exp-pade">
<h3><a class="doc-anchor" href="#doc-cas-matrix-exp-pade">#</a> <code>cas_matrix_exp_pade</code></h3>
<p><code>cas_matrix_exp_pade</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_matrix_exp_pade $x
# or in a pipeline:
@list |> map cas_matrix_exp_pade |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-matrix-function-step">
<h3><a class="doc-anchor" href="#doc-cas-matrix-function-step">#</a> <code>cas_matrix_function_step</code></h3>
<p><code>cas_matrix_function_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_matrix_function_step $x
# or in a pipeline:
@list |> map cas_matrix_function_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-matrix-log-step">
<h3><a class="doc-anchor" href="#doc-cas-matrix-log-step">#</a> <code>cas_matrix_log_step</code></h3>
<p><code>cas_matrix_log_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_matrix_log_step $x
# or in a pipeline:
@list |> map cas_matrix_log_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-matrix-pencil-step">
<h3><a class="doc-anchor" href="#doc-cas-matrix-pencil-step">#</a> <code>cas_matrix_pencil_step</code></h3>
<p><code>cas_matrix_pencil_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_matrix_pencil_step $x
# or in a pipeline:
@list |> map cas_matrix_pencil_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-matrix-sqrt-step">
<h3><a class="doc-anchor" href="#doc-cas-matrix-sqrt-step">#</a> <code>cas_matrix_sqrt_step</code></h3>
<p><code>cas_matrix_sqrt_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_matrix_sqrt_step $x
# or in a pipeline:
@list |> map cas_matrix_sqrt_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-minimal-polynomial">
<h3><a class="doc-anchor" href="#doc-cas-minimal-polynomial">#</a> <code>cas_minimal_polynomial</code></h3>
<p><code>cas_minimal_polynomial</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_minimal_polynomial $x
# or in a pipeline:
@list |> map cas_minimal_polynomial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-modified-cholesky">
<h3><a class="doc-anchor" href="#doc-cas-modified-cholesky">#</a> <code>cas_modified_cholesky</code></h3>
<p><code>cas_modified_cholesky</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_modified_cholesky $x
# or in a pipeline:
@list |> map cas_modified_cholesky |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-modified-gram-schmidt">
<h3><a class="doc-anchor" href="#doc-cas-modified-gram-schmidt">#</a> <code>cas_modified_gram_schmidt</code></h3>
<p><code>cas_modified_gram_schmidt</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_modified_gram_schmidt $x
# or in a pipeline:
@list |> map cas_modified_gram_schmidt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-modular-inverse">
<h3><a class="doc-anchor" href="#doc-cas-modular-inverse">#</a> <code>cas_modular_inverse</code></h3>
<p><code>cas_modular_inverse</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_modular_inverse $x
# or in a pipeline:
@list |> map cas_modular_inverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-moore-penrose-step">
<h3><a class="doc-anchor" href="#doc-cas-moore-penrose-step">#</a> <code>cas_moore_penrose_step</code></h3>
<p><code>cas_moore_penrose_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_moore_penrose_step $x
# or in a pipeline:
@list |> map cas_moore_penrose_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-omp-step">
<h3><a class="doc-anchor" href="#doc-cas-omp-step">#</a> <code>cas_omp_step</code></h3>
<p><code>cas_omp_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_omp_step $x
# or in a pipeline:
@list |> map cas_omp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-partial-fraction-simple">
<h3><a class="doc-anchor" href="#doc-cas-partial-fraction-simple">#</a> <code>cas_partial_fraction_simple</code></h3>
<p><code>cas_partial_fraction_simple</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_partial_fraction_simple $x
# or in a pipeline:
@list |> map cas_partial_fraction_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-pivoted-lu-step">
<h3><a class="doc-anchor" href="#doc-cas-pivoted-lu-step">#</a> <code>cas_pivoted_lu_step</code></h3>
<p><code>cas_pivoted_lu_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_pivoted_lu_step $x
# or in a pipeline:
@list |> map cas_pivoted_lu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-polar-decomposition">
<h3><a class="doc-anchor" href="#doc-cas-polar-decomposition">#</a> <code>cas_polar_decomposition</code></h3>
<p><code>cas_polar_decomposition</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_polar_decomposition $x
# or in a pipeline:
@list |> map cas_polar_decomposition |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-polya-enumeration-step">
<h3><a class="doc-anchor" href="#doc-cas-polya-enumeration-step">#</a> <code>cas_polya_enumeration_step</code></h3>
<p><code>cas_polya_enumeration_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_polya_enumeration_step $x
# or in a pipeline:
@list |> map cas_polya_enumeration_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-polynomial-div-step">
<h3><a class="doc-anchor" href="#doc-cas-polynomial-div-step">#</a> <code>cas_polynomial_div_step</code></h3>
<p><code>cas_polynomial_div_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_polynomial_div_step $x
# or in a pipeline:
@list |> map cas_polynomial_div_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-polynomial-gcd-step">
<h3><a class="doc-anchor" href="#doc-cas-polynomial-gcd-step">#</a> <code>cas_polynomial_gcd_step</code></h3>
<p><code>cas_polynomial_gcd_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_polynomial_gcd_step $x
# or in a pipeline:
@list |> map cas_polynomial_gcd_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-polynomial-roots-kahan">
<h3><a class="doc-anchor" href="#doc-cas-polynomial-roots-kahan">#</a> <code>cas_polynomial_roots_kahan</code></h3>
<p><code>cas_polynomial_roots_kahan</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_polynomial_roots_kahan $x
# or in a pipeline:
@list |> map cas_polynomial_roots_kahan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proj-box">
<h3><a class="doc-anchor" href="#doc-cas-proj-box">#</a> <code>cas_proj_box</code></h3>
<p><code>cas_proj_box</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proj_box $x
# or in a pipeline:
@list |> map cas_proj_box |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proj-exp-cone">
<h3><a class="doc-anchor" href="#doc-cas-proj-exp-cone">#</a> <code>cas_proj_exp_cone</code></h3>
<p><code>cas_proj_exp_cone</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proj_exp_cone $x
# or in a pipeline:
@list |> map cas_proj_exp_cone |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proj-l1-ball">
<h3><a class="doc-anchor" href="#doc-cas-proj-l1-ball">#</a> <code>cas_proj_l1_ball</code></h3>
<p><code>cas_proj_l1_ball</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proj_l1_ball $x
# or in a pipeline:
@list |> map cas_proj_l1_ball |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proj-l2-ball">
<h3><a class="doc-anchor" href="#doc-cas-proj-l2-ball">#</a> <code>cas_proj_l2_ball</code></h3>
<p><code>cas_proj_l2_ball</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proj_l2_ball $x
# or in a pipeline:
@list |> map cas_proj_l2_ball |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proj-psd-cone">
<h3><a class="doc-anchor" href="#doc-cas-proj-psd-cone">#</a> <code>cas_proj_psd_cone</code></h3>
<p><code>cas_proj_psd_cone</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proj_psd_cone $x
# or in a pipeline:
@list |> map cas_proj_psd_cone |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proj-soc-step">
<h3><a class="doc-anchor" href="#doc-cas-proj-soc-step">#</a> <code>cas_proj_soc_step</code></h3>
<p><code>cas_proj_soc_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proj_soc_step $x
# or in a pipeline:
@list |> map cas_proj_soc_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proximal-l1-step">
<h3><a class="doc-anchor" href="#doc-cas-proximal-l1-step">#</a> <code>cas_proximal_l1_step</code></h3>
<p><code>cas_proximal_l1_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proximal_l1_step $x
# or in a pipeline:
@list |> map cas_proximal_l1_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proximal-l2-step">
<h3><a class="doc-anchor" href="#doc-cas-proximal-l2-step">#</a> <code>cas_proximal_l2_step</code></h3>
<p><code>cas_proximal_l2_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proximal_l2_step $x
# or in a pipeline:
@list |> map cas_proximal_l2_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-proximal-l-inf-step">
<h3><a class="doc-anchor" href="#doc-cas-proximal-l-inf-step">#</a> <code>cas_proximal_l_inf_step</code></h3>
<p><code>cas_proximal_l_inf_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_proximal_l_inf_step $x
# or in a pipeline:
@list |> map cas_proximal_l_inf_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-pseudoinverse-step">
<h3><a class="doc-anchor" href="#doc-cas-pseudoinverse-step">#</a> <code>cas_pseudoinverse_step</code></h3>
<p><code>cas_pseudoinverse_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_pseudoinverse_step $x
# or in a pipeline:
@list |> map cas_pseudoinverse_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-qr-iteration-step">
<h3><a class="doc-anchor" href="#doc-cas-qr-iteration-step">#</a> <code>cas_qr_iteration_step</code></h3>
<p><code>cas_qr_iteration_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_qr_iteration_step $x
# or in a pipeline:
@list |> map cas_qr_iteration_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-quasi-triangular">
<h3><a class="doc-anchor" href="#doc-cas-quasi-triangular">#</a> <code>cas_quasi_triangular</code></h3>
<p><code>cas_quasi_triangular</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_quasi_triangular $x
# or in a pipeline:
@list |> map cas_quasi_triangular |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-radical-simplify">
<h3><a class="doc-anchor" href="#doc-cas-radical-simplify">#</a> <code>cas_radical_simplify</code></h3>
<p><code>cas_radical_simplify</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_radical_simplify $x
# or in a pipeline:
@list |> map cas_radical_simplify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-rank-revealing-qr">
<h3><a class="doc-anchor" href="#doc-cas-rank-revealing-qr">#</a> <code>cas_rank_revealing_qr</code></h3>
<p><code>cas_rank_revealing_qr</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_rank_revealing_qr $x
# or in a pipeline:
@list |> map cas_rank_revealing_qr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-regularized-lsq-tikhonov">
<h3><a class="doc-anchor" href="#doc-cas-regularized-lsq-tikhonov">#</a> <code>cas_regularized_lsq_tikhonov</code></h3>
<p><code>cas_regularized_lsq_tikhonov</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_regularized_lsq_tikhonov $x
# or in a pipeline:
@list |> map cas_regularized_lsq_tikhonov |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-resultant-two">
<h3><a class="doc-anchor" href="#doc-cas-resultant-two">#</a> <code>cas_resultant_two</code></h3>
<p><code>cas_resultant_two</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_resultant_two $x
# or in a pipeline:
@list |> map cas_resultant_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-resultant-x-y">
<h3><a class="doc-anchor" href="#doc-cas-resultant-x-y">#</a> <code>cas_resultant_x_y</code></h3>
<p><code>cas_resultant_x_y</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_resultant_x_y $x
# or in a pipeline:
@list |> map cas_resultant_x_y |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-riccati-continuous-step">
<h3><a class="doc-anchor" href="#doc-cas-riccati-continuous-step">#</a> <code>cas_riccati_continuous_step</code></h3>
<p><code>cas_riccati_continuous_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_riccati_continuous_step $x
# or in a pipeline:
@list |> map cas_riccati_continuous_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-riccati-discrete-step">
<h3><a class="doc-anchor" href="#doc-cas-riccati-discrete-step">#</a> <code>cas_riccati_discrete_step</code></h3>
<p><code>cas_riccati_discrete_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_riccati_discrete_step $x
# or in a pipeline:
@list |> map cas_riccati_discrete_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-root-isolate-step">
<h3><a class="doc-anchor" href="#doc-cas-root-isolate-step">#</a> <code>cas_root_isolate_step</code></h3>
<p><code>cas_root_isolate_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_root_isolate_step $x
# or in a pipeline:
@list |> map cas_root_isolate_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-schur-decomposition-step">
<h3><a class="doc-anchor" href="#doc-cas-schur-decomposition-step">#</a> <code>cas_schur_decomposition_step</code></h3>
<p><code>cas_schur_decomposition_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_schur_decomposition_step $x
# or in a pipeline:
@list |> map cas_schur_decomposition_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-simplify-term">
<h3><a class="doc-anchor" href="#doc-cas-simplify-term">#</a> <code>cas_simplify_term</code></h3>
<p><code>cas_simplify_term</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_simplify_term $x
# or in a pipeline:
@list |> map cas_simplify_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-singular-value-step">
<h3><a class="doc-anchor" href="#doc-cas-singular-value-step">#</a> <code>cas_singular_value_step</code></h3>
<p><code>cas_singular_value_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_singular_value_step $x
# or in a pipeline:
@list |> map cas_singular_value_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-smith-normal-step">
<h3><a class="doc-anchor" href="#doc-cas-smith-normal-step">#</a> <code>cas_smith_normal_step</code></h3>
<p><code>cas_smith_normal_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_smith_normal_step $x
# or in a pipeline:
@list |> map cas_smith_normal_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-solve-cubic">
<h3><a class="doc-anchor" href="#doc-cas-solve-cubic">#</a> <code>cas_solve_cubic</code></h3>
<p><code>cas_solve_cubic</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_solve_cubic $x
# or in a pipeline:
@list |> map cas_solve_cubic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-solve-linear">
<h3><a class="doc-anchor" href="#doc-cas-solve-linear">#</a> <code>cas_solve_linear</code></h3>
<p><code>cas_solve_linear</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_solve_linear $x
# or in a pipeline:
@list |> map cas_solve_linear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-solve-polynomial-n">
<h3><a class="doc-anchor" href="#doc-cas-solve-polynomial-n">#</a> <code>cas_solve_polynomial_n</code></h3>
<p><code>cas_solve_polynomial_n</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_solve_polynomial_n $x
# or in a pipeline:
@list |> map cas_solve_polynomial_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-solve-quadratic">
<h3><a class="doc-anchor" href="#doc-cas-solve-quadratic">#</a> <code>cas_solve_quadratic</code></h3>
<p><code>cas_solve_quadratic</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_solve_quadratic $x
# or in a pipeline:
@list |> map cas_solve_quadratic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-solve-quartic">
<h3><a class="doc-anchor" href="#doc-cas-solve-quartic">#</a> <code>cas_solve_quartic</code></h3>
<p><code>cas_solve_quartic</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_solve_quartic $x
# or in a pipeline:
@list |> map cas_solve_quartic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-sturm-sequence-step">
<h3><a class="doc-anchor" href="#doc-cas-sturm-sequence-step">#</a> <code>cas_sturm_sequence_step</code></h3>
<p><code>cas_sturm_sequence_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_sturm_sequence_step $x
# or in a pipeline:
@list |> map cas_sturm_sequence_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-subresultant-two">
<h3><a class="doc-anchor" href="#doc-cas-subresultant-two">#</a> <code>cas_subresultant_two</code></h3>
<p><code>cas_subresultant_two</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_subresultant_two $x
# or in a pipeline:
@list |> map cas_subresultant_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-sylvester-equation-step">
<h3><a class="doc-anchor" href="#doc-cas-sylvester-equation-step">#</a> <code>cas_sylvester_equation_step</code></h3>
<p><code>cas_sylvester_equation_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_sylvester_equation_step $x
# or in a pipeline:
@list |> map cas_sylvester_equation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-taylor-coefficient">
<h3><a class="doc-anchor" href="#doc-cas-taylor-coefficient">#</a> <code>cas_taylor_coefficient</code></h3>
<p><code>cas_taylor_coefficient</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_taylor_coefficient $x
# or in a pipeline:
@list |> map cas_taylor_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-total-least-squares">
<h3><a class="doc-anchor" href="#doc-cas-total-least-squares">#</a> <code>cas_total_least_squares</code></h3>
<p><code>cas_total_least_squares</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_total_least_squares $x
# or in a pipeline:
@list |> map cas_total_least_squares |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-truncated-lsq">
<h3><a class="doc-anchor" href="#doc-cas-truncated-lsq">#</a> <code>cas_truncated_lsq</code></h3>
<p><code>cas_truncated_lsq</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_truncated_lsq $x
# or in a pipeline:
@list |> map cas_truncated_lsq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-truncated-svd-value">
<h3><a class="doc-anchor" href="#doc-cas-truncated-svd-value">#</a> <code>cas_truncated_svd_value</code></h3>
<p><code>cas_truncated_svd_value</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_truncated_svd_value $x
# or in a pipeline:
@list |> map cas_truncated_svd_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-vec-operator-step">
<h3><a class="doc-anchor" href="#doc-cas-vec-operator-step">#</a> <code>cas_vec_operator_step</code></h3>
<p><code>cas_vec_operator_step</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_vec_operator_step $x
# or in a pipeline:
@list |> map cas_vec_operator_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cas-woodbury-identity">
<h3><a class="doc-anchor" href="#doc-cas-woodbury-identity">#</a> <code>cas_woodbury_identity</code></h3>
<p><code>cas_woodbury_identity</code> — batch 44 builtin.</p>
<pre><code class="lang-perl">my $result = cas_woodbury_identity $x
# or in a pipeline:
@list |> map cas_woodbury_identity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-casimir-eigenvalue-su2">
<h3><a class="doc-anchor" href="#doc-casimir-eigenvalue-su2">#</a> <code>casimir_eigenvalue_su2</code></h3>
<p><code>casimir_eigenvalue_su2</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = casimir_eigenvalue_su2 $x
# or in a pipeline:
@list |> map casimir_eigenvalue_su2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-catalan">
<h3><a class="doc-anchor" href="#doc-catalan">#</a> <code>catalan</code></h3>
<p><code>catalan_constant</code> (alias <code>catalan</code>) — Catalan's constant G ≈ 0.9159. Appears in combinatorics and series.</p>
<pre><code class="lang-perl">p catalan # 0.9159655941772190
</code></pre>
</article>
<article class="doc-entry" id="doc-catn">
<h3><a class="doc-anchor" href="#doc-catn">#</a> <code>catn</code></h3>
<p><code>catn</code> — extended stdlib batch 3 builtin. Alias for <code>catalan</code>.</p>
<pre><code class="lang-perl">my $result = catn $x
# or in a pipeline:
@list |> map catn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cauchy-pdf">
<h3><a class="doc-anchor" href="#doc-cauchy-pdf">#</a> <code>cauchy_pdf</code></h3>
<p><code>cauchy_pdf</code> (alias <code>cauchypdf</code>) evaluates the Cauchy distribution PDF at x with location x0 and scale gamma.</p>
<pre><code class="lang-perl">p cauchypdf(0, 0, 1) # peak of standard Cauchy
</code></pre>
</article>
<article class="doc-entry" id="doc-caverphone-2">
<h3><a class="doc-anchor" href="#doc-caverphone-2">#</a> <code>caverphone_2</code></h3>
<p><code>caverphone_2</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = caverphone_2 $x
# or in a pipeline:
@list |> map caverphone_2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cbind">
<h3><a class="doc-anchor" href="#doc-cbind">#</a> <code>cbind</code></h3>
<p><code>cbind</code> — bind matrices by columns (horizontal join). Like R's cbind().</p>
<pre><code class="lang-perl">my $m = cbind([[1],[2]], [[3],[4]]) # [[1,3],[2,4]]
</code></pre>
</article>
<article class="doc-entry" id="doc-cblend">
<h3><a class="doc-anchor" href="#doc-cblend">#</a> <code>cblend</code></h3>
<p><code>cblend</code> — color operations builtin. Alias for <code>color_blend</code>.</p>
<pre><code class="lang-perl">my $result = cblend $x
# or in a pipeline:
@list |> map cblend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cbor-encode-str">
<h3><a class="doc-anchor" href="#doc-cbor-encode-str">#</a> <code>cbor_encode_str</code></h3>
<p><code>cbor_encode_str</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = cbor_encode_str $x
# or in a pipeline:
@list |> map cbor_encode_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cbor-encode-uint">
<h3><a class="doc-anchor" href="#doc-cbor-encode-uint">#</a> <code>cbor_encode_uint</code></h3>
<p><code>cbor_encode_uint</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = cbor_encode_uint $x
# or in a pipeline:
@list |> map cbor_encode_uint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cbrt">
<h3><a class="doc-anchor" href="#doc-cbrt">#</a> <code>cbrt</code></h3>
<p><code>cbrt</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = cbrt $x
# or in a pipeline:
@list |> map cbrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cc-count">
<h3><a class="doc-anchor" href="#doc-cc-count">#</a> <code>cc_count</code></h3>
<p><code>cc_count</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = cc_count $x
# or in a pipeline:
@list |> map cc_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cc-labels">
<h3><a class="doc-anchor" href="#doc-cc-labels">#</a> <code>cc_labels</code></h3>
<p><code>cc_labels</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = cc_labels $x
# or in a pipeline:
@list |> map cc_labels |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ccgraph">
<h3><a class="doc-anchor" href="#doc-ccgraph">#</a> <code>ccgraph</code></h3>
<p><code>ccgraph</code> — extended stdlib builtin. Alias for <code>connected_components_graph</code>.</p>
<pre><code class="lang-perl">my $result = ccgraph $x
# or in a pipeline:
@list |> map ccgraph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ccompl">
<h3><a class="doc-anchor" href="#doc-ccompl">#</a> <code>ccompl</code></h3>
<p><code>ccompl</code> — color operations builtin. Alias for <code>color_complement</code>.</p>
<pre><code class="lang-perl">my $result = ccompl $x
# or in a pipeline:
@list |> map ccompl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ccount">
<h3><a class="doc-anchor" href="#doc-ccount">#</a> <code>ccount</code></h3>
<p><code>ccount</code> — extended stdlib batch 3 builtin. Alias for <code>count_chars</code>.</p>
<pre><code class="lang-perl">my $result = ccount $x
# or in a pipeline:
@list |> map ccount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ccx-gate">
<h3><a class="doc-anchor" href="#doc-ccx-gate">#</a> <code>ccx_gate</code></h3>
<p><code>ccx_gate</code> — batches 14-16 builtin. Alias for <code>toffoli_gate</code>.</p>
<pre><code class="lang-perl">my $result = ccx_gate $x
# or in a pipeline:
@list |> map ccx_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cdarken">
<h3><a class="doc-anchor" href="#doc-cdarken">#</a> <code>cdarken</code></h3>
<p><code>cdarken</code> — color operations builtin. Alias for <code>color_darken</code>.</p>
<pre><code class="lang-perl">my $result = cdarken $x
# or in a pipeline:
@list |> map cdarken |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cdist">
<h3><a class="doc-anchor" href="#doc-cdist">#</a> <code>cdist</code></h3>
<p><code>cdist</code> — color operations builtin. Alias for <code>color_distance</code>.</p>
<pre><code class="lang-perl">my $result = cdist $x
# or in a pipeline:
@list |> map cdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cds-upfront">
<h3><a class="doc-anchor" href="#doc-cds-upfront">#</a> <code>cds_upfront</code></h3>
<p><code>cds_upfront</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = cds_upfront $x
# or in a pipeline:
@list |> map cds_upfront |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cech-zero-cohomology">
<h3><a class="doc-anchor" href="#doc-cech-zero-cohomology">#</a> <code>cech_zero_cohomology</code></h3>
<p><code>cech_zero_cohomology</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = cech_zero_cohomology $x
# or in a pipeline:
@list |> map cech_zero_cohomology |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ceil">
<h3><a class="doc-anchor" href="#doc-ceil">#</a> <code>ceil</code></h3>
<p><code>ceil</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = ceil $x
# or in a pipeline:
@list |> map ceil |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ceil-div">
<h3><a class="doc-anchor" href="#doc-ceil-div">#</a> <code>ceil_div</code></h3>
<p><code>ceil_div</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = ceil_div $x
# or in a pipeline:
@list |> map ceil_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ceil-each">
<h3><a class="doc-anchor" href="#doc-ceil-each">#</a> <code>ceil_each</code></h3>
<p><code>ceil_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = ceil_each $x
# or in a pipeline:
@list |> map ceil_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ceiling">
<h3><a class="doc-anchor" href="#doc-ceiling">#</a> <code>ceiling</code></h3>
<p><code>ceiling</code> — trivial numeric / predicate builtins builtin. Alias for <code>ceil</code>.</p>
<pre><code class="lang-perl">my $result = ceiling $x
# or in a pipeline:
@list |> map ceiling |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-center">
<h3><a class="doc-anchor" href="#doc-center">#</a> <code>center</code></h3>
<p><code>center</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = center $x
# or in a pipeline:
@list |> map center |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-center-text">
<h3><a class="doc-anchor" href="#doc-center-text">#</a> <code>center_text</code></h3>
<p><code>center_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = center_text $x
# or in a pipeline:
@list |> map center_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centered-hexagonal-number">
<h3><a class="doc-anchor" href="#doc-centered-hexagonal-number">#</a> <code>centered_hexagonal_number</code></h3>
<p><code>centered_hexagonal_number</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = centered_hexagonal_number $x
# or in a pipeline:
@list |> map centered_hexagonal_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centered-pentagonal">
<h3><a class="doc-anchor" href="#doc-centered-pentagonal">#</a> <code>centered_pentagonal</code></h3>
<p><code>centered_pentagonal</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = centered_pentagonal $x
# or in a pipeline:
@list |> map centered_pentagonal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centered-square">
<h3><a class="doc-anchor" href="#doc-centered-square">#</a> <code>centered_square</code></h3>
<p><code>centered_square</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = centered_square $x
# or in a pipeline:
@list |> map centered_square |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centered-triangular">
<h3><a class="doc-anchor" href="#doc-centered-triangular">#</a> <code>centered_triangular</code></h3>
<p><code>centered_triangular</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = centered_triangular $x
# or in a pipeline:
@list |> map centered_triangular |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-central-polygonal">
<h3><a class="doc-anchor" href="#doc-central-polygonal">#</a> <code>central_polygonal</code></h3>
<p><code>central_polygonal</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = central_polygonal $x
# or in a pipeline:
@list |> map central_polygonal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centrality-betweenness">
<h3><a class="doc-anchor" href="#doc-centrality-betweenness">#</a> <code>centrality_betweenness</code></h3>
<p><code>centrality_betweenness</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = centrality_betweenness $x
# or in a pipeline:
@list |> map centrality_betweenness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centrality-closeness">
<h3><a class="doc-anchor" href="#doc-centrality-closeness">#</a> <code>centrality_closeness</code></h3>
<p><code>centrality_closeness</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = centrality_closeness $x
# or in a pipeline:
@list |> map centrality_closeness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centrality-degree">
<h3><a class="doc-anchor" href="#doc-centrality-degree">#</a> <code>centrality_degree</code></h3>
<p><code>centrality_degree</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = centrality_degree $x
# or in a pipeline:
@list |> map centrality_degree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centrality-eigenvector">
<h3><a class="doc-anchor" href="#doc-centrality-eigenvector">#</a> <code>centrality_eigenvector</code></h3>
<p><code>centrality_eigenvector</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = centrality_eigenvector $x
# or in a pipeline:
@list |> map centrality_eigenvector |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centrality-katz">
<h3><a class="doc-anchor" href="#doc-centrality-katz">#</a> <code>centrality_katz</code></h3>
<p><code>centrality_katz</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = centrality_katz $x
# or in a pipeline:
@list |> map centrality_katz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centrip">
<h3><a class="doc-anchor" href="#doc-centrip">#</a> <code>centrip</code></h3>
<p><code>centripetal_force($mass, $velocity, $radius)</code> (alias <code>centrip</code>) — F = mv²/r for circular motion.</p>
<pre><code class="lang-perl">p centrip(1000, 20, 50) # 8000 N (car turning)
</code></pre>
</article>
<article class="doc-entry" id="doc-centripetal-accel">
<h3><a class="doc-anchor" href="#doc-centripetal-accel">#</a> <code>centripetal_accel</code></h3>
<p><code>centripetal_accel</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = centripetal_accel $x
# or in a pipeline:
@list |> map centripetal_accel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centroid">
<h3><a class="doc-anchor" href="#doc-centroid">#</a> <code>centroid</code></h3>
<p><code>centroid(@points)</code> — computes the centroid (geometric center) of 2D points. Points as flat list [x1,y1,x2,y2,...]. Returns [$cx, $cy].</p>
<pre><code class="lang-perl">my @triangle = (0,0, 3,0, 0,3)
my $c = centroid(@triangle)
p @$c # (1, 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-centroid-nd">
<h3><a class="doc-anchor" href="#doc-centroid-nd">#</a> <code>centroid_nd</code></h3>
<p><code>centroid_nd</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = centroid_nd $x
# or in a pipeline:
@list |> map centroid_nd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cents-between">
<h3><a class="doc-anchor" href="#doc-cents-between">#</a> <code>cents_between</code></h3>
<p><code>cents_between</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = cents_between $x
# or in a pipeline:
@list |> map cents_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cents-between-freqs">
<h3><a class="doc-anchor" href="#doc-cents-between-freqs">#</a> <code>cents_between_freqs</code></h3>
<p><code>cents_between_freqs</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = cents_between_freqs $x
# or in a pipeline:
@list |> map cents_between_freqs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ces-production">
<h3><a class="doc-anchor" href="#doc-ces-production">#</a> <code>ces_production</code></h3>
<p><code>ces_production</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = ces_production $x
# or in a pipeline:
@list |> map ces_production |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cfl-number">
<h3><a class="doc-anchor" href="#doc-cfl-number">#</a> <code>cfl_number</code></h3>
<p><code>cfl_number</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = cfl_number $x
# or in a pipeline:
@list |> map cfl_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cfr-case-fatality">
<h3><a class="doc-anchor" href="#doc-cfr-case-fatality">#</a> <code>cfr_case_fatality</code></h3>
<p><code>cfr_case_fatality</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = cfr_case_fatality $x
# or in a pipeline:
@list |> map cfr_case_fatality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cg-beta-fr">
<h3><a class="doc-anchor" href="#doc-cg-beta-fr">#</a> <code>cg_beta_fr</code></h3>
<p><code>cg_beta_fr</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = cg_beta_fr $x
# or in a pipeline:
@list |> map cg_beta_fr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cg-beta-pr">
<h3><a class="doc-anchor" href="#doc-cg-beta-pr">#</a> <code>cg_beta_pr</code></h3>
<p><code>cg_beta_pr</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = cg_beta_pr $x
# or in a pipeline:
@list |> map cg_beta_pr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cg-simple">
<h3><a class="doc-anchor" href="#doc-cg-simple">#</a> <code>cg_simple</code></h3>
<p><code>cg_simple</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = cg_simple $x
# or in a pipeline:
@list |> map cg_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cgemm">
<h3><a class="doc-anchor" href="#doc-cgemm">#</a> <code>cgemm</code></h3>
<p><code>cgemm</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = cgemm $x
# or in a pipeline:
@list |> map cgemm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cgray">
<h3><a class="doc-anchor" href="#doc-cgray">#</a> <code>cgray</code></h3>
<p><code>cgray</code> — color operations builtin. Alias for <code>color_grayscale</code>.</p>
<pre><code class="lang-perl">my $result = cgray $x
# or in a pipeline:
@list |> map cgray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chacha20-qround">
<h3><a class="doc-anchor" href="#doc-chacha20-qround">#</a> <code>chacha20_qround</code></h3>
<p><code>chacha20_qround</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = chacha20_qround $x
# or in a pipeline:
@list |> map chacha20_qround |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chain-from">
<h3><a class="doc-anchor" href="#doc-chain-from">#</a> <code>chain_from</code></h3>
<p><code>chain_from</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = chain_from $x
# or in a pipeline:
@list |> map chain_from |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chain-ladder-step">
<h3><a class="doc-anchor" href="#doc-chain-ladder-step">#</a> <code>chain_ladder_step</code></h3>
<p><code>chain_ladder_step</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = chain_ladder_step $x
# or in a pipeline:
@list |> map chain_ladder_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chain-rule-entropy">
<h3><a class="doc-anchor" href="#doc-chain-rule-entropy">#</a> <code>chain_rule_entropy</code></h3>
<p><code>chain_rule_entropy</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = chain_rule_entropy $x
# or in a pipeline:
@list |> map chain_rule_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chandrasekhar-mass">
<h3><a class="doc-anchor" href="#doc-chandrasekhar-mass">#</a> <code>chandrasekhar_mass</code></h3>
<p><code>chandrasekhar_mass</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = chandrasekhar_mass $x
# or in a pipeline:
@list |> map chandrasekhar_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chapman-estimator">
<h3><a class="doc-anchor" href="#doc-chapman-estimator">#</a> <code>chapman_estimator</code></h3>
<p><code>chapman_estimator</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = chapman_estimator $x
# or in a pipeline:
@list |> map chapman_estimator |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-at">
<h3><a class="doc-anchor" href="#doc-char-at">#</a> <code>char_at</code></h3>
<p><code>char_at</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = char_at $x
# or in a pipeline:
@list |> map char_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-count">
<h3><a class="doc-anchor" href="#doc-char-count">#</a> <code>char_count</code></h3>
<p><code>char_count</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = char_count $x
# or in a pipeline:
@list |> map char_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-devices">
<h3><a class="doc-anchor" href="#doc-char-devices">#</a> <code>char_devices</code></h3>
<p><code>char_devices</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = char_devices $x
# or in a pipeline:
@list |> map char_devices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-frequencies">
<h3><a class="doc-anchor" href="#doc-char-frequencies">#</a> <code>char_frequencies</code></h3>
<p><code>char_frequencies</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = char_frequencies $x
# or in a pipeline:
@list |> map char_frequencies |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-length">
<h3><a class="doc-anchor" href="#doc-char-length">#</a> <code>char_length</code></h3>
<p><code>char_length</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = char_length $x
# or in a pipeline:
@list |> map char_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-character-su2">
<h3><a class="doc-anchor" href="#doc-character-su2">#</a> <code>character_su2</code></h3>
<p><code>character_su2</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = character_su2 $x
# or in a pipeline:
@list |> map character_su2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-character-sun">
<h3><a class="doc-anchor" href="#doc-character-sun">#</a> <code>character_sun</code></h3>
<p><code>character_sun</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = character_sun $x
# or in a pipeline:
@list |> map character_sun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-characteristic-function">
<h3><a class="doc-anchor" href="#doc-characteristic-function">#</a> <code>characteristic_function</code></h3>
<p><code>characteristic_function</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = characteristic_function $x
# or in a pipeline:
@list |> map characteristic_function |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-charcodes-to-string">
<h3><a class="doc-anchor" href="#doc-charcodes-to-string">#</a> <code>charcodes_to_string</code></h3>
<p><code>charcodes_to_string</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = charcodes_to_string $input
</code></pre>
</article>
<article class="doc-entry" id="doc-charfreq">
<h3><a class="doc-anchor" href="#doc-charfreq">#</a> <code>charfreq</code></h3>
<p><code>charfreq</code> — string processing (uncategorized batch) builtin. Alias for <code>char_frequencies</code>.</p>
<pre><code class="lang-perl">my $result = charfreq $x
# or in a pipeline:
@list |> map charfreq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-charge-capacity-battery">
<h3><a class="doc-anchor" href="#doc-charge-capacity-battery">#</a> <code>charge_capacity_battery</code></h3>
<p><code>charge_capacity_battery</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = charge_capacity_battery $x
# or in a pipeline:
@list |> map charge_capacity_battery |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-charge-transfer-resistance">
<h3><a class="doc-anchor" href="#doc-charge-transfer-resistance">#</a> <code>charge_transfer_resistance</code></h3>
<p><code>charge_transfer_resistance</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = charge_transfer_resistance $x
# or in a pipeline:
@list |> map charge_transfer_resistance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chars-to-string">
<h3><a class="doc-anchor" href="#doc-chars-to-string">#</a> <code>chars_to_string</code></h3>
<p><code>chars_to_string</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = chars_to_string $input
</code></pre>
</article>
<article class="doc-entry" id="doc-chc-bound-makespan">
<h3><a class="doc-anchor" href="#doc-chc-bound-makespan">#</a> <code>chc_bound_makespan</code></h3>
<p><code>chc_bound_makespan</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = chc_bound_makespan $x
# or in a pipeline:
@list |> map chc_bound_makespan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cheapest-insertion-step">
<h3><a class="doc-anchor" href="#doc-cheapest-insertion-step">#</a> <code>cheapest_insertion_step</code></h3>
<p><code>cheapest_insertion_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = cheapest_insertion_step $x
# or in a pipeline:
@list |> map cheapest_insertion_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cheby1-lp">
<h3><a class="doc-anchor" href="#doc-cheby1-lp">#</a> <code>cheby1_lp</code></h3>
<p><code>cheby1_lp</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = cheby1_lp $x
# or in a pipeline:
@list |> map cheby1_lp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cheby2-lp">
<h3><a class="doc-anchor" href="#doc-cheby2-lp">#</a> <code>cheby2_lp</code></h3>
<p><code>cheby2_lp</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = cheby2_lp $x
# or in a pipeline:
@list |> map cheby2_lp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chebyshev-distance">
<h3><a class="doc-anchor" href="#doc-chebyshev-distance">#</a> <code>chebyshev_distance</code></h3>
<p><code>chebyshev_distance</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = chebyshev_distance $x
# or in a pipeline:
@list |> map chebyshev_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chebyt">
<h3><a class="doc-anchor" href="#doc-chebyt">#</a> <code>chebyt</code></h3>
<p><code>chebyt</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = chebyt $x
# or in a pipeline:
@list |> map chebyt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chebyu">
<h3><a class="doc-anchor" href="#doc-chebyu">#</a> <code>chebyu</code></h3>
<p><code>chebyu</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = chebyu $x
# or in a pipeline:
@list |> map chebyu |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chern-first-2d">
<h3><a class="doc-anchor" href="#doc-chern-first-2d">#</a> <code>chern_first_2d</code></h3>
<p><code>chern_first_2d</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = chern_first_2d $x
# or in a pipeline:
@list |> map chern_first_2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chern-pontryagin-4d-step">
<h3><a class="doc-anchor" href="#doc-chern-pontryagin-4d-step">#</a> <code>chern_pontryagin_4d_step</code></h3>
<p><code>chern_pontryagin_4d_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = chern_pontryagin_4d_step $x
# or in a pipeline:
@list |> map chern_pontryagin_4d_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chern-simons-action">
<h3><a class="doc-anchor" href="#doc-chern-simons-action">#</a> <code>chern_simons_action</code></h3>
<p><code>chern_simons_action</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = chern_simons_action $x
# or in a pipeline:
@list |> map chern_simons_action |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chezy-velocity">
<h3><a class="doc-anchor" href="#doc-chezy-velocity">#</a> <code>chezy_velocity</code></h3>
<p><code>chezy_velocity</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = chezy_velocity $x
# or in a pipeline:
@list |> map chezy_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chfr">
<h3><a class="doc-anchor" href="#doc-chfr">#</a> <code>chfr</code></h3>
<p><code>chfr</code> — python/ruby stdlib builtin. Alias for <code>chain_from</code>.</p>
<pre><code class="lang-perl">my $result = chfr $x
# or in a pipeline:
@list |> map chfr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chi2">
<h3><a class="doc-anchor" href="#doc-chi2">#</a> <code>chi2</code></h3>
<p><code>chi_square_stat(\@observed, \@expected)</code> (alias <code>chi2</code>) — computes the chi-squared test statistic comparing observed vs expected frequencies. Useful for goodness-of-fit tests. Returns the chi-squared value.</p>
<pre><code class="lang-perl">my @obs = (10, 20, 30)
my @exp = (15, 20, 25)
p chi2(\@obs, \@exp) # chi-squared statistic
</code></pre>
</article>
<article class="doc-entry" id="doc-chi2-pdf">
<h3><a class="doc-anchor" href="#doc-chi2-pdf">#</a> <code>chi2_pdf</code></h3>
<p><code>chi2_pdf</code> (alias <code>chi2pdf</code>) evaluates the chi-squared distribution PDF at x with k degrees of freedom.</p>
<pre><code class="lang-perl">p chi2pdf(3.84, 1) # p-value boundary for df=1
</code></pre>
</article>
<article class="doc-entry" id="doc-chicken-game-payoff">
<h3><a class="doc-anchor" href="#doc-chicken-game-payoff">#</a> <code>chicken_game_payoff</code></h3>
<p><code>chicken_game_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = chicken_game_payoff $x
# or in a pipeline:
@list |> map chicken_game_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chinese-lunation-winter">
<h3><a class="doc-anchor" href="#doc-chinese-lunation-winter">#</a> <code>chinese_lunation_winter</code></h3>
<p><code>chinese_lunation_winter</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = chinese_lunation_winter $x
# or in a pipeline:
@list |> map chinese_lunation_winter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chinese-new-year">
<h3><a class="doc-anchor" href="#doc-chinese-new-year">#</a> <code>chinese_new_year</code></h3>
<p><code>chinese_new_year</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = chinese_new_year $x
# or in a pipeline:
@list |> map chinese_new_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chinese-remainder">
<h3><a class="doc-anchor" href="#doc-chinese-remainder">#</a> <code>chinese_remainder</code></h3>
<p><code>chinese_remainder</code> (alias <code>crt</code>) solves a system of simultaneous congruences via the Chinese Remainder Theorem.</p>
<pre><code class="lang-perl">p crt([2,3,2], [3,5,7]) # 23 (x≡2 mod 3, x≡3 mod 5, x≡2 mod 7)
</code></pre>
</article>
<article class="doc-entry" id="doc-chinese-year-zodiac">
<h3><a class="doc-anchor" href="#doc-chinese-year-zodiac">#</a> <code>chinese_year_zodiac</code></h3>
<p><code>chinese_year_zodiac</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = chinese_year_zodiac $x
# or in a pipeline:
@list |> map chinese_year_zodiac |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chinese-zodiac">
<h3><a class="doc-anchor" href="#doc-chinese-zodiac">#</a> <code>chinese_zodiac</code></h3>
<p><code>chinese_zodiac</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = chinese_zodiac $x
# or in a pipeline:
@list |> map chinese_zodiac |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chirp">
<h3><a class="doc-anchor" href="#doc-chirp">#</a> <code>chirp</code></h3>
<p><code>chirp</code> generates a linear chirp signal sweeping from f0 to f1 Hz. Args: n_samples, f0, f1, sample_rate.</p>
<pre><code class="lang-perl">my @sig = @{chirp(1000, 100, 1000, 8000)}
</code></pre>
</article>
<article class="doc-entry" id="doc-chirp-linear">
<h3><a class="doc-anchor" href="#doc-chirp-linear">#</a> <code>chirp_linear</code></h3>
<p><code>chirp_linear</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = chirp_linear $x
# or in a pipeline:
@list |> map chirp_linear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chirp-mass">
<h3><a class="doc-anchor" href="#doc-chirp-mass">#</a> <code>chirp_mass</code></h3>
<p><code>chirp_mass</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = chirp_mass $x
# or in a pipeline:
@list |> map chirp_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chirp-mass-inspiral-step">
<h3><a class="doc-anchor" href="#doc-chirp-mass-inspiral-step">#</a> <code>chirp_mass_inspiral_step</code></h3>
<p><code>chirp_mass_inspiral_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = chirp_mass_inspiral_step $x
# or in a pipeline:
@list |> map chirp_mass_inspiral_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chisquare-metric">
<h3><a class="doc-anchor" href="#doc-chisquare-metric">#</a> <code>chisquare_metric</code></h3>
<p><code>chisquare_metric</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = chisquare_metric $x
# or in a pipeline:
@list |> map chisquare_metric |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chkstr">
<h3><a class="doc-anchor" href="#doc-chkstr">#</a> <code>chkstr</code></h3>
<p><code>chkstr</code> — string processing (uncategorized batch) builtin. Alias for <code>chunk_string</code>.</p>
<pre><code class="lang-perl">my $result = chkstr $x
# or in a pipeline:
@list |> map chkstr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chkw">
<h3><a class="doc-anchor" href="#doc-chkw">#</a> <code>chkw</code></h3>
<p><code>chkw</code> — ruby enumerable extras builtin. Alias for <code>chunk_while</code>.</p>
<pre><code class="lang-perl">my $result = chkw $x
# or in a pipeline:
@list |> map chkw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chlorine-radical-decay">
<h3><a class="doc-anchor" href="#doc-chlorine-radical-decay">#</a> <code>chlorine_radical_decay</code></h3>
<p><code>chlorine_radical_decay</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = chlorine_radical_decay $x
# or in a pipeline:
@list |> map chlorine_radical_decay |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cholesky">
<h3><a class="doc-anchor" href="#doc-cholesky">#</a> <code>cholesky</code></h3>
<p><code>matrix_cholesky</code> (aliases <code>mchol</code>, <code>cholesky</code>) computes the Cholesky decomposition of a symmetric positive-definite matrix. Returns lower-triangular L where M = L·L^T.</p>
<pre><code class="lang-perl">my $L = cholesky([[4,2],[2,3]])
</code></pre>
</article>
<article class="doc-entry" id="doc-chomp-str">
<h3><a class="doc-anchor" href="#doc-chomp-str">#</a> <code>chomp_str</code></h3>
<p><code>chomp_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = chomp_str $x
# or in a pipeline:
@list |> map chomp_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-choose">
<h3><a class="doc-anchor" href="#doc-choose">#</a> <code>choose</code></h3>
<p><code>choose</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = choose $x
# or in a pipeline:
@list |> map choose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chop-str">
<h3><a class="doc-anchor" href="#doc-chop-str">#</a> <code>chop_str</code></h3>
<p><code>chop_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = chop_str $x
# or in a pipeline:
@list |> map chop_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chord-quality-classify">
<h3><a class="doc-anchor" href="#doc-chord-quality-classify">#</a> <code>chord_quality_classify</code></h3>
<p><code>chord_quality_classify</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = chord_quality_classify $x
# or in a pipeline:
@list |> map chord_quality_classify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chord-root-inversion">
<h3><a class="doc-anchor" href="#doc-chord-root-inversion">#</a> <code>chord_root_inversion</code></h3>
<p><code>chord_root_inversion</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = chord_root_inversion $x
# or in a pipeline:
@list |> map chord_root_inversion |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chord-to-freqs">
<h3><a class="doc-anchor" href="#doc-chord-to-freqs">#</a> <code>chord_to_freqs</code></h3>
<p><code>chord_to_freqs</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = chord_to_freqs $input
</code></pre>
</article>
<article class="doc-entry" id="doc-chord-voicing-close">
<h3><a class="doc-anchor" href="#doc-chord-voicing-close">#</a> <code>chord_voicing_close</code></h3>
<p><code>chord_voicing_close</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = chord_voicing_close $x
# or in a pipeline:
@list |> map chord_voicing_close |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chow-test-stat">
<h3><a class="doc-anchor" href="#doc-chow-test-stat">#</a> <code>chow_test_stat</code></h3>
<p><code>chow_test_stat</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = chow_test_stat $x
# or in a pipeline:
@list |> map chow_test_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-christoffel-first-kind-step">
<h3><a class="doc-anchor" href="#doc-christoffel-first-kind-step">#</a> <code>christoffel_first_kind_step</code></h3>
<p><code>christoffel_first_kind_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = christoffel_first_kind_step $x
# or in a pipeline:
@list |> map christoffel_first_kind_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-christoffel-second-kind-step">
<h3><a class="doc-anchor" href="#doc-christoffel-second-kind-step">#</a> <code>christoffel_second_kind_step</code></h3>
<p><code>christoffel_second_kind_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = christoffel_second_kind_step $x
# or in a pipeline:
@list |> map christoffel_second_kind_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-christoffel-symbol-normalize">
<h3><a class="doc-anchor" href="#doc-christoffel-symbol-normalize">#</a> <code>christoffel_symbol_normalize</code></h3>
<p><code>christoffel_symbol_normalize</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = christoffel_symbol_normalize $x
# or in a pipeline:
@list |> map christoffel_symbol_normalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-christoffel-word">
<h3><a class="doc-anchor" href="#doc-christoffel-word">#</a> <code>christoffel_word</code></h3>
<p><code>christoffel_word</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = christoffel_word $x
# or in a pipeline:
@list |> map christoffel_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-christofides-ratio-bound">
<h3><a class="doc-anchor" href="#doc-christofides-ratio-bound">#</a> <code>christofides_ratio_bound</code></h3>
<p><code>christofides_ratio_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = christofides_ratio_bound $x
# or in a pipeline:
@list |> map christofides_ratio_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chroma-feature-step">
<h3><a class="doc-anchor" href="#doc-chroma-feature-step">#</a> <code>chroma_feature_step</code></h3>
<p><code>chroma_feature_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = chroma_feature_step $x
# or in a pipeline:
@list |> map chroma_feature_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chromatic-homology-rank">
<h3><a class="doc-anchor" href="#doc-chromatic-homology-rank">#</a> <code>chromatic_homology_rank</code></h3>
<p><code>chromatic_homology_rank</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = chromatic_homology_rank $x
# or in a pipeline:
@list |> map chromatic_homology_rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chromatic-number-greedy">
<h3><a class="doc-anchor" href="#doc-chromatic-number-greedy">#</a> <code>chromatic_number_greedy</code></h3>
<p><code>chromatic_number_greedy</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = chromatic_number_greedy $x
# or in a pipeline:
@list |> map chromatic_number_greedy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chroot">
<h3><a class="doc-anchor" href="#doc-chroot">#</a> <code>chroot</code></h3>
<p><code>chroot</code> — process / system builtin.</p>
<pre><code class="lang-perl">my $result = chroot $x
# or in a pipeline:
@list |> map chroot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chsh-expectation">
<h3><a class="doc-anchor" href="#doc-chsh-expectation">#</a> <code>chsh_expectation</code></h3>
<p><code>chsh_expectation</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = chsh_expectation $x
# or in a pipeline:
@list |> map chsh_expectation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chull">
<h3><a class="doc-anchor" href="#doc-chull">#</a> <code>chull</code></h3>
<p><code>convex_hull(@points)</code> (alias <code>chull</code>) — computes the convex hull of a set of 2D points. Points given as flat list [x1,y1,x2,y2,...]. Returns the hull vertices in counterclockwise order. Uses Graham scan algorithm.</p>
<pre><code class="lang-perl">my @pts = (0,0, 1,1, 2,0, 1,0.5)
my $hull = chull(@pts)
p @$hull
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk-by">
<h3><a class="doc-anchor" href="#doc-chunk-by">#</a> <code>chunk_by</code></h3>
<p><code>chunk_by</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = chunk_by $x
# or in a pipeline:
@list |> map chunk_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk-n">
<h3><a class="doc-anchor" href="#doc-chunk-n">#</a> <code>chunk_n</code></h3>
<p><code>chunk_n</code> — collection (batch 2) builtin. Alias for <code>group_of_n</code>.</p>
<pre><code class="lang-perl">my $result = chunk_n $x
# or in a pipeline:
@list |> map chunk_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk-string">
<h3><a class="doc-anchor" href="#doc-chunk-string">#</a> <code>chunk_string</code></h3>
<p><code>chunk_string</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = chunk_string $x
# or in a pipeline:
@list |> map chunk_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk-while">
<h3><a class="doc-anchor" href="#doc-chunk-while">#</a> <code>chunk_while</code></h3>
<p><code>chunk_while</code> — ruby enumerable extras builtin.</p>
<pre><code class="lang-perl">my $result = chunk_while $x
# or in a pipeline:
@list |> map chunk_while |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-church-numeral-n">
<h3><a class="doc-anchor" href="#doc-church-numeral-n">#</a> <code>church_numeral_n</code></h3>
<p><code>church_numeral_n</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = church_numeral_n $x
# or in a pipeline:
@list |> map church_numeral_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chvatal-gomory-cut">
<h3><a class="doc-anchor" href="#doc-chvatal-gomory-cut">#</a> <code>chvatal_gomory_cut</code></h3>
<p><code>chvatal_gomory_cut</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = chvatal_gomory_cut $x
# or in a pipeline:
@list |> map chvatal_gomory_cut |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ci">
<h3><a class="doc-anchor" href="#doc-ci">#</a> <code>ci</code></h3>
<p><code>confidence_interval</code> (alias <code>ci</code>) computes a confidence interval for the mean. Default 95%. Returns [lower, upper].</p>
<pre><code class="lang-perl">my ($lo, $hi) = @{ci([10,12,14,11,13])}
p "95%% CI: $lo to $hi"
my ($lo99, $hi99) = @{ci([10,12,14,11,13], 0.99)}
</code></pre>
</article>
<article class="doc-entry" id="doc-cindex">
<h3><a class="doc-anchor" href="#doc-cindex">#</a> <code>cindex</code></h3>
<p><code>cindex STRING, SUBSTRING [, FROM]</code> — codepoint-indexed equivalent of Perl 5's <code>index</code>. Returns the zero-based codepoint position of the first occurrence, or -1 on miss. FROM is also a codepoint position. Pairs with <code>[i]</code> / <code>[a:b]</code> slice operators and <code>len</code> so search positions and slice bounds share one coordinate system.</p>
<p>Use <code>cindex</code> whenever your code mixes string search with <code>[]</code> slicing — Perl 5 <code>index</code> returns byte positions and silently misaligns when fed into <code>[]</code> (which is codepoint-based). <code>index</code> stays byte-indexed because <code>length</code> and <code>substr</code> are, and changing it would break Perl-5 binary-protocol code; <code>cindex</code> is the stryke-extension counterpart.</p>
<pre><code class="lang-perl">my $s = "hello ─ world"
p index $s, "world" # 9 (bytes — `─` is 3 bytes)
p cindex $s, "world" # 7 (codepoints)
my $i = cindex $s, "world"
p $s[$i : len($s) - 1] # "world" — slice bounds line up
</code></pre>
</article>
<article class="doc-entry" id="doc-cinv">
<h3><a class="doc-anchor" href="#doc-cinv">#</a> <code>cinv</code></h3>
<p><code>cinv</code> — extended stdlib batch 3 builtin. Alias for <code>count_inversions</code>.</p>
<pre><code class="lang-perl">my $result = cinv $x
# or in a pipeline:
@list |> map cinv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cinvert">
<h3><a class="doc-anchor" href="#doc-cinvert">#</a> <code>cinvert</code></h3>
<p><code>cinvert</code> — color operations builtin. Alias for <code>color_invert</code>.</p>
<pre><code class="lang-perl">my $result = cinvert $x
# or in a pipeline:
@list |> map cinvert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cir-bond">
<h3><a class="doc-anchor" href="#doc-cir-bond">#</a> <code>cir_bond</code></h3>
<p><code>cir_bond</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = cir_bond $x
# or in a pipeline:
@list |> map cir_bond |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circ3pt">
<h3><a class="doc-anchor" href="#doc-circ3pt">#</a> <code>circ3pt</code></h3>
<p><code>circ3pt</code> — geometry (extended) builtin. Alias for <code>circle_from_three_points</code>.</p>
<pre><code class="lang-perl">my $result = circ3pt $x
# or in a pipeline:
@list |> map circ3pt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circle-3-points">
<h3><a class="doc-anchor" href="#doc-circle-3-points">#</a> <code>circle_3_points</code></h3>
<p><code>circle_3_points</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = circle_3_points $x
# or in a pipeline:
@list |> map circle_3_points |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circle-from-three-points">
<h3><a class="doc-anchor" href="#doc-circle-from-three-points">#</a> <code>circle_from_three_points</code></h3>
<p><code>circle_from_three_points($x1, $y1, $x2, $y2, $x3, $y3)</code> (alias <code>circ3</code>) — finds the unique circle passing through three non-collinear points. Returns [$cx, $cy, $radius] or undef if collinear.</p>
<pre><code class="lang-perl">my $c = circ3(0, 0, 1, 0, 0.5, 0.866)
p "center=($c->[0], $c->[1]) r=$c->[2]"
</code></pre>
</article>
<article class="doc-entry" id="doc-circle-of-fifths-step">
<h3><a class="doc-anchor" href="#doc-circle-of-fifths-step">#</a> <code>circle_of_fifths_step</code></h3>
<p><code>circle_of_fifths_step</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = circle_of_fifths_step $x
# or in a pipeline:
@list |> map circle_of_fifths_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circuit-depth">
<h3><a class="doc-anchor" href="#doc-circuit-depth">#</a> <code>circuit_depth</code></h3>
<p><code>circuit_depth</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = circuit_depth $x
# or in a pipeline:
@list |> map circuit_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circuit-width">
<h3><a class="doc-anchor" href="#doc-circuit-width">#</a> <code>circuit_width</code></h3>
<p><code>circuit_width</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = circuit_width $x
# or in a pipeline:
@list |> map circuit_width |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circum">
<h3><a class="doc-anchor" href="#doc-circum">#</a> <code>circum</code></h3>
<p><code>circum</code> — geometry / physics builtin. Alias for <code>circumference</code>.</p>
<pre><code class="lang-perl">my $result = circum $x
# or in a pipeline:
@list |> map circum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circumference">
<h3><a class="doc-anchor" href="#doc-circumference">#</a> <code>circumference</code></h3>
<p><code>circumference</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = circumference $x
# or in a pipeline:
@list |> map circumference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cityhash64">
<h3><a class="doc-anchor" href="#doc-cityhash64">#</a> <code>cityhash64</code></h3>
<p><code>cityhash64</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = cityhash64 $x
# or in a pipeline:
@list |> map cityhash64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-array">
<h3><a class="doc-anchor" href="#doc-clamp-array">#</a> <code>clamp_array</code></h3>
<p><code>clamp_array</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = clamp_array $x
# or in a pipeline:
@list |> map clamp_array |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-each">
<h3><a class="doc-anchor" href="#doc-clamp-each">#</a> <code>clamp_each</code></h3>
<p><code>clamp_each</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = clamp_each $x
# or in a pipeline:
@list |> map clamp_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-fn">
<h3><a class="doc-anchor" href="#doc-clamp-fn">#</a> <code>clamp_fn</code></h3>
<p><code>clamp_fn</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = clamp_fn $x
# or in a pipeline:
@list |> map clamp_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-int">
<h3><a class="doc-anchor" href="#doc-clamp-int">#</a> <code>clamp_int</code></h3>
<p><code>clamp_int</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = clamp_int $x
# or in a pipeline:
@list |> map clamp_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-list">
<h3><a class="doc-anchor" href="#doc-clamp-list">#</a> <code>clamp_list</code></h3>
<p><code>clamp_list</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = clamp_list $x
# or in a pipeline:
@list |> map clamp_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clarr">
<h3><a class="doc-anchor" href="#doc-clarr">#</a> <code>clarr</code></h3>
<p><code>clarr</code> — matrix operations (uncategorized batch) builtin. Alias for <code>clamp_array</code>.</p>
<pre><code class="lang-perl">my $result = clarr $x
# or in a pipeline:
@list |> map clarr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-class">
<h3><a class="doc-anchor" href="#doc-class">#</a> <code>class</code></h3>
<p><code>class</code> declares a full object-oriented class with typed fields, inheritance, traits, instance methods, and static methods. Classes provide modern OOP semantics with a clean syntax.</p>
<p><strong>Declaration:</strong></p>
<pre><code class="lang-perl">class Animal {
name: Str
age: Int = 0
fn speak { p "Animal: " . $self->name }
}
</code></pre>
<p><strong>Inheritance with <code>extends</code>:</strong></p>
<pre><code class="lang-perl">class Dog extends Animal {
breed: Str = "Mixed"
fn bark { p "Woof! I am " . $self->name }
fn speak { p $self->name . " barks!" } # override
}
</code></pre>
<p><strong>Construction (named or positional):</strong></p>
<pre><code class="lang-perl">my $dog = Dog(name => "Rex", age => 5, breed => "Lab")
my $dog = Dog("Rex", 5, "Lab") # positional
</code></pre>
<p><strong>Field access (getter/setter):</strong></p>
<pre><code class="lang-perl">p $dog->name # getter
$dog->age(6) # setter
</code></pre>
<p><strong>Static methods (<code>fn Self.name</code>):</strong></p>
<pre><code class="lang-perl">class Math {
fn Self.add($a, $b) { $a + $b }
fn Self.pi { 3.14159 }
}
p Math::add(3, 4) # 7
p Math::pi() # 3.14159
</code></pre>
<p><strong>Traits (interfaces):</strong></p>
<pre><code class="lang-perl">trait Printable { fn to_str }
class Item impl Printable {
name: Str
fn to_str { $self->name }
}
</code></pre>
<p><strong>Multiple inheritance:</strong></p>
<pre><code class="lang-perl">class C extends A, B { }
</code></pre>
<p><strong>isa checks:</strong></p>
<pre><code class="lang-perl">p $dog->isa("Dog") # 1
p $dog->isa("Animal") # 1 (parent)
p $dog->isa("Cat") # "" (false)
</code></pre>
<p><strong>Built-in methods:</strong></p>
<pre><code class="lang-perl">my @f = $dog->fields() # (name, age, breed)
my $h = $dog->to_hash() # { name => "Rex", ... }
my $d2 = $dog->with(age => 1) # functional update
my $d3 = $dog->clone() # deep copy
</code></pre>
<p><strong>Visibility (pub/priv):</strong></p>
<pre><code class="lang-perl">class Secret {
pub visible: Int = 1
priv hidden: Int = 42
pub fn get_hidden { $self->hidden } # internal access ok
}
</code></pre>
<p>Note: inherited fields come first in the values array; method lookup walks the inheritance chain.</p>
</article>
<article class="doc-entry" id="doc-class-number-bound">
<h3><a class="doc-anchor" href="#doc-class-number-bound">#</a> <code>class_number_bound</code></h3>
<p><code>class_number_bound</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = class_number_bound $x
# or in a pipeline:
@list |> map class_number_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clausen-cl2">
<h3><a class="doc-anchor" href="#doc-clausen-cl2">#</a> <code>clausen_cl2</code></h3>
<p><code>clausen_cl2</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = clausen_cl2 $x
# or in a pipeline:
@list |> map clausen_cl2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clausius-clapeyron">
<h3><a class="doc-anchor" href="#doc-clausius-clapeyron">#</a> <code>clausius_clapeyron</code></h3>
<p><code>clausius_clapeyron</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = clausius_clapeyron $x
# or in a pipeline:
@list |> map clausius_clapeyron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clausius-clapeyron-full">
<h3><a class="doc-anchor" href="#doc-clausius-clapeyron-full">#</a> <code>clausius_clapeyron_full</code></h3>
<p><code>clausius_clapeyron_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = clausius_clapeyron_full $x
# or in a pipeline:
@list |> map clausius_clapeyron_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clean-price">
<h3><a class="doc-anchor" href="#doc-clean-price">#</a> <code>clean_price</code></h3>
<p><code>clean_price</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = clean_price $x
# or in a pipeline:
@list |> map clean_price |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clighten">
<h3><a class="doc-anchor" href="#doc-clighten">#</a> <code>clighten</code></h3>
<p><code>clighten</code> — color operations builtin. Alias for <code>color_lighten</code>.</p>
<pre><code class="lang-perl">my $result = clighten $x
# or in a pipeline:
@list |> map clighten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clique-count-3">
<h3><a class="doc-anchor" href="#doc-clique-count-3">#</a> <code>clique_count_3</code></h3>
<p><code>clique_count_3</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = clique_count_3 $x
# or in a pipeline:
@list |> map clique_count_3 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clique-number-lower">
<h3><a class="doc-anchor" href="#doc-clique-number-lower">#</a> <code>clique_number_lower</code></h3>
<p><code>clique_number_lower</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = clique_number_lower $x
# or in a pipeline:
@list |> map clique_number_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-closed-pipe-harmonic">
<h3><a class="doc-anchor" href="#doc-closed-pipe-harmonic">#</a> <code>closed_pipe_harmonic</code></h3>
<p><code>closed_pipe_harmonic</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = closed_pipe_harmonic $x
# or in a pipeline:
@list |> map closed_pipe_harmonic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-closest-pt-segment-2d">
<h3><a class="doc-anchor" href="#doc-closest-pt-segment-2d">#</a> <code>closest_pt_segment_2d</code></h3>
<p><code>closest_pt_segment_2d</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = closest_pt_segment_2d $x
# or in a pipeline:
@list |> map closest_pt_segment_2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clpi">
<h3><a class="doc-anchor" href="#doc-clpi">#</a> <code>clpi</code></h3>
<p><code>clpi</code> — extended stdlib builtin. Alias for <code>clamp_int</code>.</p>
<pre><code class="lang-perl">my $result = clpi $x
# or in a pipeline:
@list |> map clpi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cluster-attack-rate">
<h3><a class="doc-anchor" href="#doc-cluster-attack-rate">#</a> <code>cluster_attack_rate</code></h3>
<p><code>cluster_attack_rate</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = cluster_attack_rate $x
# or in a pipeline:
@list |> map cluster_attack_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cluster-slots">
<h3><a class="doc-anchor" href="#doc-cluster-slots">#</a> <code>cluster_slots</code></h3>
<p><code>cluster_slots</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = cluster_slots $x
# or in a pipeline:
@list |> map cluster_slots |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clustering-coefficient">
<h3><a class="doc-anchor" href="#doc-clustering-coefficient">#</a> <code>clustering_coefficient</code></h3>
<p><code>clustering_coefficient</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = clustering_coefficient $x
# or in a pipeline:
@list |> map clustering_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clutch-score">
<h3><a class="doc-anchor" href="#doc-clutch-score">#</a> <code>clutch_score</code></h3>
<p><code>clutch_score</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = clutch_score $x
# or in a pipeline:
@list |> map clutch_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cm-to-inches">
<h3><a class="doc-anchor" href="#doc-cm-to-inches">#</a> <code>cm_to_inches</code></h3>
<p><code>cm_to_inches</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = cm_to_inches $input
</code></pre>
</article>
<article class="doc-entry" id="doc-cmap">
<h3><a class="doc-anchor" href="#doc-cmap">#</a> <code>cmap</code></h3>
<p><code>cmap</code> — additional missing stdlib functions builtin. Alias for <code>concat_map</code>.</p>
<pre><code class="lang-perl">my $result = cmap $x
# or in a pipeline:
@list |> map cmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmb-temperature">
<h3><a class="doc-anchor" href="#doc-cmb-temperature">#</a> <code>cmb_temperature</code></h3>
<p><code>cmb_temperature</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = cmb_temperature $x
# or in a pipeline:
@list |> map cmb_temperature |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmb-temperature-at-z">
<h3><a class="doc-anchor" href="#doc-cmb-temperature-at-z">#</a> <code>cmb_temperature_at_z</code></h3>
<p><code>cmb_temperature_at_z</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = cmb_temperature_at_z $x
# or in a pipeline:
@list |> map cmb_temperature_at_z |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmd-exists">
<h3><a class="doc-anchor" href="#doc-cmd-exists">#</a> <code>cmd_exists</code></h3>
<p><code>cmd_exists</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = cmd_exists $x
# or in a pipeline:
@list |> map cmd_exists |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmp-num">
<h3><a class="doc-anchor" href="#doc-cmp-num">#</a> <code>cmp_num</code></h3>
<p><code>cmp_num</code> — file stat / path builtin. Alias for <code>spaceship</code>.</p>
<pre><code class="lang-perl">my $result = cmp_num $x
# or in a pipeline:
@list |> map cmp_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmp-str">
<h3><a class="doc-anchor" href="#doc-cmp-str">#</a> <code>cmp_str</code></h3>
<p><code>cmp_str</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = cmp_str $x
# or in a pipeline:
@list |> map cmp_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmpr">
<h3><a class="doc-anchor" href="#doc-cmpr">#</a> <code>cmpr</code></h3>
<p><code>cmpr</code> — python/ruby stdlib builtin. Alias for <code>compress</code>.</p>
<pre><code class="lang-perl">my $result = cmpr $x
# or in a pipeline:
@list |> map cmpr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmyk-to-rgb">
<h3><a class="doc-anchor" href="#doc-cmyk-to-rgb">#</a> <code>cmyk_to_rgb</code></h3>
<p><code>cmyk_to_rgb</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = cmyk_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-cn-coefficient">
<h3><a class="doc-anchor" href="#doc-cn-coefficient">#</a> <code>cn_coefficient</code></h3>
<p><code>cn_coefficient</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = cn_coefficient $x
# or in a pipeline:
@list |> map cn_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cn-ode">
<h3><a class="doc-anchor" href="#doc-cn-ode">#</a> <code>cn_ode</code></h3>
<p><code>cn_ode</code> — batch 19 builtin. Alias for <code>crank_nicolson_ode</code>.</p>
<pre><code class="lang-perl">my $result = cn_ode $x
# or in a pipeline:
@list |> map cn_ode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cnf-dpll-branch">
<h3><a class="doc-anchor" href="#doc-cnf-dpll-branch">#</a> <code>cnf_dpll_branch</code></h3>
<p><code>cnf_dpll_branch</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = cnf_dpll_branch $x
# or in a pipeline:
@list |> map cnf_dpll_branch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cnf-pure-literal-elim">
<h3><a class="doc-anchor" href="#doc-cnf-pure-literal-elim">#</a> <code>cnf_pure_literal_elim</code></h3>
<p><code>cnf_pure_literal_elim</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = cnf_pure_literal_elim $x
# or in a pipeline:
@list |> map cnf_pure_literal_elim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cnf-unit-propagate">
<h3><a class="doc-anchor" href="#doc-cnf-unit-propagate">#</a> <code>cnf_unit_propagate</code></h3>
<p><code>cnf_unit_propagate</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = cnf_unit_propagate $x
# or in a pipeline:
@list |> map cnf_unit_propagate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cnt">
<h3><a class="doc-anchor" href="#doc-cnt">#</a> <code>cnt</code></h3>
<p><code>count</code> (aliases <code>len</code>, <code>cnt</code>) returns the number of elements in a list, the <strong>codepoint count</strong> of a string, the number of key-value pairs in a hash, or the cardinality of a set. Universal length-like function that dispatches on the type of its argument. Replaces <code>scalar @array</code> / <code>length $string</code> for stryke code; on strings it pairs with <code>[i]</code> / <code>[a:b]</code> and <code>cindex</code> / <code>crindex</code>, all of which use codepoint positions.</p>
<p>For byte length on a string, use Perl 5's <code>length</code> (kept byte-based for compat with <code>index</code> / <code>rindex</code> / <code>substr</code>). <code>size</code> is NOT a count alias — it returns a file's byte size.</p>
<pre><code class="lang-perl">my @arr = (1, 2, 3, 4, 5)
p cnt @arr # 5
p len "hello" # 5
p len "─" # 1 (codepoint)
p length "─" # 3 (bytes)
my %h = (a => 1, b => 2)
p cnt \%h # 2
rl("file.txt") |> cnt |> p # line count
</code></pre>
</article>
<article class="doc-entry" id="doc-cntw">
<h3><a class="doc-anchor" href="#doc-cntw">#</a> <code>cntw</code></h3>
<p><code>cntw</code> — ruby enumerable extras builtin. Alias for <code>count_while</code>.</p>
<pre><code class="lang-perl">my $result = cntw $x
# or in a pipeline:
@list |> map cntw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-co2-growth-rate-step">
<h3><a class="doc-anchor" href="#doc-co2-growth-rate-step">#</a> <code>co2_growth_rate_step</code></h3>
<p><code>co2_growth_rate_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = co2_growth_rate_step $x
# or in a pipeline:
@list |> map co2_growth_rate_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coalesce">
<h3><a class="doc-anchor" href="#doc-coalesce">#</a> <code>coalesce</code></h3>
<p><code>coalesce</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = coalesce $x
# or in a pipeline:
@list |> map coalesce |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coalescent-expected-time">
<h3><a class="doc-anchor" href="#doc-coalescent-expected-time">#</a> <code>coalescent_expected_time</code></h3>
<p><code>coalescent_expected_time</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = coalescent_expected_time $x
# or in a pipeline:
@list |> map coalescent_expected_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coalescent-tree-length">
<h3><a class="doc-anchor" href="#doc-coalescent-tree-length">#</a> <code>coalescent_tree_length</code></h3>
<p><code>coalescent_tree_length</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = coalescent_tree_length $x
# or in a pipeline:
@list |> map coalescent_tree_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cobb-douglas">
<h3><a class="doc-anchor" href="#doc-cobb-douglas">#</a> <code>cobb_douglas</code></h3>
<p><code>cobb_douglas</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = cobb_douglas $x
# or in a pipeline:
@list |> map cobb_douglas |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-code-point-at">
<h3><a class="doc-anchor" href="#doc-code-point-at">#</a> <code>code_point_at</code></h3>
<p><code>code_point_at</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = code_point_at $x
# or in a pipeline:
@list |> map code_point_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-codifferential-step">
<h3><a class="doc-anchor" href="#doc-codifferential-step">#</a> <code>codifferential_step</code></h3>
<p><code>codifferential_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = codifferential_step $x
# or in a pipeline:
@list |> map codifferential_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-codon-adaptation-index">
<h3><a class="doc-anchor" href="#doc-codon-adaptation-index">#</a> <code>codon_adaptation_index</code></h3>
<p><code>codon_adaptation_index</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = codon_adaptation_index $x
# or in a pipeline:
@list |> map codon_adaptation_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-codon-usage-variance">
<h3><a class="doc-anchor" href="#doc-codon-usage-variance">#</a> <code>codon_usage_variance</code></h3>
<p><code>codon_usage_variance</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = codon_usage_variance $x
# or in a pipeline:
@list |> map codon_usage_variance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coeff-of-variation">
<h3><a class="doc-anchor" href="#doc-coeff-of-variation">#</a> <code>coeff_of_variation</code></h3>
<p><code>coeff_of_variation</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = coeff_of_variation $x
# or in a pipeline:
@list |> map coeff_of_variation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cognitive-hierarchy-step">
<h3><a class="doc-anchor" href="#doc-cognitive-hierarchy-step">#</a> <code>cognitive_hierarchy_step</code></h3>
<p><code>cognitive_hierarchy_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = cognitive_hierarchy_step $x
# or in a pipeline:
@list |> map cognitive_hierarchy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cohen-d">
<h3><a class="doc-anchor" href="#doc-cohen-d">#</a> <code>cohen_d</code></h3>
<p><code>cohen_d</code> (alias <code>cohend</code>) computes Cohen's d effect size between two samples. Small=0.2, medium=0.5, large=0.8.</p>
<pre><code class="lang-perl">p cohend([1,2,3], [4,5,6]) # large effect
</code></pre>
</article>
<article class="doc-entry" id="doc-cohen-kappa">
<h3><a class="doc-anchor" href="#doc-cohen-kappa">#</a> <code>cohen_kappa</code></h3>
<p><code>cohen_kappa</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = cohen_kappa $x
# or in a pipeline:
@list |> map cohen_kappa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coherence-xy">
<h3><a class="doc-anchor" href="#doc-coherence-xy">#</a> <code>coherence_xy</code></h3>
<p><code>coherence_xy</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = coherence_xy $x
# or in a pipeline:
@list |> map coherence_xy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coherent-mean-photons">
<h3><a class="doc-anchor" href="#doc-coherent-mean-photons">#</a> <code>coherent_mean_photons</code></h3>
<p><code>coherent_mean_photons</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = coherent_mean_photons $x
# or in a pipeline:
@list |> map coherent_mean_photons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cohomology-rank">
<h3><a class="doc-anchor" href="#doc-cohomology-rank">#</a> <code>cohomology_rank</code></h3>
<p><code>cohomology_rank</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = cohomology_rank $x
# or in a pipeline:
@list |> map cohomology_rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coif1-coeffs">
<h3><a class="doc-anchor" href="#doc-coif1-coeffs">#</a> <code>coif1_coeffs</code></h3>
<p><code>coif1_coeffs</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = coif1_coeffs $x
# or in a pipeline:
@list |> map coif1_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coiflet-wavelet-step">
<h3><a class="doc-anchor" href="#doc-coiflet-wavelet-step">#</a> <code>coiflet_wavelet_step</code></h3>
<p><code>coiflet_wavelet_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = coiflet_wavelet_step $x
# or in a pipeline:
@list |> map coiflet_wavelet_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coin-flip">
<h3><a class="doc-anchor" href="#doc-coin-flip">#</a> <code>coin_flip</code></h3>
<p><code>coin_flip</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = coin_flip $x
# or in a pipeline:
@list |> map coin_flip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cointegration-eg">
<h3><a class="doc-anchor" href="#doc-cointegration-eg">#</a> <code>cointegration_eg</code></h3>
<p><code>cointegration_eg</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = cointegration_eg $x
# or in a pipeline:
@list |> map cointegration_eg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cointegration-residual">
<h3><a class="doc-anchor" href="#doc-cointegration-residual">#</a> <code>cointegration_residual</code></h3>
<p><code>cointegration_residual</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = cointegration_residual $x
# or in a pipeline:
@list |> map cointegration_residual |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-colmeans">
<h3><a class="doc-anchor" href="#doc-colmeans">#</a> <code>colMeans</code></h3>
<p><code>col_means</code> (alias <code>colMeans</code>) — mean of each column. Like R's colMeans().</p>
<pre><code class="lang-perl">p colMeans([[2,4],[6,8]]) # [4, 6]
</code></pre>
</article>
<article class="doc-entry" id="doc-colsums">
<h3><a class="doc-anchor" href="#doc-colsums">#</a> <code>colSums</code></h3>
<p><code>col_sums</code> (alias <code>colSums</code>) — sum of each column. Like R's colSums().</p>
<pre><code class="lang-perl">p colSums([[1,2],[3,4]]) # [4, 6]
</code></pre>
</article>
<article class="doc-entry" id="doc-cole-cole-eis">
<h3><a class="doc-anchor" href="#doc-cole-cole-eis">#</a> <code>cole_cole_eis</code></h3>
<p><code>cole_cole_eis</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = cole_cole_eis $x
# or in a pipeline:
@list |> map cole_cole_eis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collapse-whitespace">
<h3><a class="doc-anchor" href="#doc-collapse-whitespace">#</a> <code>collapse_whitespace</code></h3>
<p><code>collapse_whitespace</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = collapse_whitespace $x
# or in a pipeline:
@list |> map collapse_whitespace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collatz">
<h3><a class="doc-anchor" href="#doc-collatz">#</a> <code>collatz</code></h3>
<p><code>collatz</code> — math / numeric (uncategorized batch) builtin. Alias for <code>collatz_length</code>.</p>
<pre><code class="lang-perl">my $result = collatz $x
# or in a pipeline:
@list |> map collatz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collatz-length">
<h3><a class="doc-anchor" href="#doc-collatz-length">#</a> <code>collatz_length</code></h3>
<p><code>collatz_length</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = collatz_length $x
# or in a pipeline:
@list |> map collatz_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collatz-sequence">
<h3><a class="doc-anchor" href="#doc-collatz-sequence">#</a> <code>collatz_sequence</code></h3>
<p><code>collatz_sequence</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = collatz_sequence $x
# or in a pipeline:
@list |> map collatz_sequence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collatzseq">
<h3><a class="doc-anchor" href="#doc-collatzseq">#</a> <code>collatzseq</code></h3>
<p><code>collatzseq</code> — math / numeric (uncategorized batch) builtin. Alias for <code>collatz_sequence</code>.</p>
<pre><code class="lang-perl">my $result = collatzseq $x
# or in a pipeline:
@list |> map collatzseq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collusion-payoff-step">
<h3><a class="doc-anchor" href="#doc-collusion-payoff-step">#</a> <code>collusion_payoff_step</code></h3>
<p><code>collusion_payoff_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = collusion_payoff_step $x
# or in a pipeline:
@list |> map collusion_payoff_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collws">
<h3><a class="doc-anchor" href="#doc-collws">#</a> <code>collws</code></h3>
<p><code>collws</code> — string processing (uncategorized batch) builtin. Alias for <code>collapse_whitespace</code>.</p>
<pre><code class="lang-perl">my $result = collws $x
# or in a pipeline:
@list |> map collws |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color256">
<h3><a class="doc-anchor" href="#doc-color256">#</a> <code>color256</code></h3>
<p><code>color256</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = color256 $x
# or in a pipeline:
@list |> map color256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-blend">
<h3><a class="doc-anchor" href="#doc-color-blend">#</a> <code>color_blend</code></h3>
<p><code>color_blend</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_blend $x
# or in a pipeline:
@list |> map color_blend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-blend-alpha">
<h3><a class="doc-anchor" href="#doc-color-blend-alpha">#</a> <code>color_blend_alpha</code></h3>
<p><code>color_blend_alpha</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = color_blend_alpha $x
# or in a pipeline:
@list |> map color_blend_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-blend-t">
<h3><a class="doc-anchor" href="#doc-color-blend-t">#</a> <code>color_blend_t</code></h3>
<p><code>color_blend_t</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = color_blend_t $x
# or in a pipeline:
@list |> map color_blend_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-complement">
<h3><a class="doc-anchor" href="#doc-color-complement">#</a> <code>color_complement</code></h3>
<p><code>color_complement</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_complement $x
# or in a pipeline:
@list |> map color_complement |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-darken">
<h3><a class="doc-anchor" href="#doc-color-darken">#</a> <code>color_darken</code></h3>
<p><code>color_darken</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_darken $x
# or in a pipeline:
@list |> map color_darken |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-distance">
<h3><a class="doc-anchor" href="#doc-color-distance">#</a> <code>color_distance</code></h3>
<p><code>color_distance</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_distance $x
# or in a pipeline:
@list |> map color_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-grayscale">
<h3><a class="doc-anchor" href="#doc-color-grayscale">#</a> <code>color_grayscale</code></h3>
<p><code>color_grayscale</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_grayscale $x
# or in a pipeline:
@list |> map color_grayscale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-invert">
<h3><a class="doc-anchor" href="#doc-color-invert">#</a> <code>color_invert</code></h3>
<p><code>color_invert</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_invert $x
# or in a pipeline:
@list |> map color_invert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-lighten">
<h3><a class="doc-anchor" href="#doc-color-lighten">#</a> <code>color_lighten</code></h3>
<p><code>color_lighten</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_lighten $x
# or in a pipeline:
@list |> map color_lighten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-temperature-kelvin">
<h3><a class="doc-anchor" href="#doc-color-temperature-kelvin">#</a> <code>color_temperature_kelvin</code></h3>
<p><code>color_temperature_kelvin</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = color_temperature_kelvin $x
# or in a pipeline:
@list |> map color_temperature_kelvin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-columbic-capacity-lihalfcell">
<h3><a class="doc-anchor" href="#doc-columbic-capacity-lihalfcell">#</a> <code>columbic_capacity_lihalfcell</code></h3>
<p><code>columbic_capacity_lihalfcell</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = columbic_capacity_lihalfcell $x
# or in a pipeline:
@list |> map columbic_capacity_lihalfcell |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-column-generation-step">
<h3><a class="doc-anchor" href="#doc-column-generation-step">#</a> <code>column_generation_step</code></h3>
<p><code>column_generation_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = column_generation_step $x
# or in a pipeline:
@list |> map column_generation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-comb">
<h3><a class="doc-anchor" href="#doc-comb">#</a> <code>comb</code></h3>
<p><code>combinations($n, $r)</code> (alias <code>comb</code>) — number of ways to choose r items from n. Formula: n!/(r!(n-r)!). Order doesn't matter.</p>
<pre><code class="lang-perl">p comb(5, 3) # 10 (ways to choose 3 items from 5)
p comb(52, 5) # 2598960 (poker hands)
</code></pre>
</article>
<article class="doc-entry" id="doc-combinations-rep">
<h3><a class="doc-anchor" href="#doc-combinations-rep">#</a> <code>combinations_rep</code></h3>
<p><code>combinations_rep</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = combinations_rep $x
# or in a pipeline:
@list |> map combinations_rep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-combinatorial-auction-step">
<h3><a class="doc-anchor" href="#doc-combinatorial-auction-step">#</a> <code>combinatorial_auction_step</code></h3>
<p><code>combinatorial_auction_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = combinatorial_auction_step $x
# or in a pipeline:
@list |> map combinatorial_auction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-combrep">
<h3><a class="doc-anchor" href="#doc-combrep">#</a> <code>combrep</code></h3>
<p><code>combrep</code> — additional missing stdlib functions builtin. Alias for <code>combinations_rep</code>.</p>
<pre><code class="lang-perl">my $result = combrep $x
# or in a pipeline:
@list |> map combrep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-common-kmers">
<h3><a class="doc-anchor" href="#doc-common-kmers">#</a> <code>common_kmers</code></h3>
<p><code>common_kmers</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = common_kmers $x
# or in a pipeline:
@list |> map common_kmers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-common-knowledge-iterations">
<h3><a class="doc-anchor" href="#doc-common-knowledge-iterations">#</a> <code>common_knowledge_iterations</code></h3>
<p><code>common_knowledge_iterations</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = common_knowledge_iterations $x
# or in a pipeline:
@list |> map common_knowledge_iterations |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-common-prefix">
<h3><a class="doc-anchor" href="#doc-common-prefix">#</a> <code>common_prefix</code></h3>
<p><code>common_prefix</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = common_prefix $x
# or in a pipeline:
@list |> map common_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-common-suffix">
<h3><a class="doc-anchor" href="#doc-common-suffix">#</a> <code>common_suffix</code></h3>
<p><code>common_suffix</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = common_suffix $x
# or in a pipeline:
@list |> map common_suffix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-comoving-distance">
<h3><a class="doc-anchor" href="#doc-comoving-distance">#</a> <code>comoving_distance</code></h3>
<p><code>comoving_distance</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = comoving_distance $x
# or in a pipeline:
@list |> map comoving_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-comoving-distance-approx">
<h3><a class="doc-anchor" href="#doc-comoving-distance-approx">#</a> <code>comoving_distance_approx</code></h3>
<p><code>comoving_distance_approx</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = comoving_distance_approx $x
# or in a pipeline:
@list |> map comoving_distance_approx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compare-versions">
<h3><a class="doc-anchor" href="#doc-compare-versions">#</a> <code>compare_versions</code></h3>
<p><code>compare_versions</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = compare_versions $x
# or in a pipeline:
@list |> map compare_versions |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-composition-count">
<h3><a class="doc-anchor" href="#doc-composition-count">#</a> <code>composition_count</code></h3>
<p><code>composition_count</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = composition_count $x
# or in a pipeline:
@list |> map composition_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compound-interest">
<h3><a class="doc-anchor" href="#doc-compound-interest">#</a> <code>compound_interest</code></h3>
<p><code>compound_interest</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = compound_interest $x
# or in a pipeline:
@list |> map compound_interest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compound-interest-periods">
<h3><a class="doc-anchor" href="#doc-compound-interest-periods">#</a> <code>compound_interest_periods</code></h3>
<p><code>compound_interest_periods</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = compound_interest_periods $x
# or in a pipeline:
@list |> map compound_interest_periods |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compress">
<h3><a class="doc-anchor" href="#doc-compress">#</a> <code>compress</code></h3>
<p><code>compress</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = compress $x
# or in a pipeline:
@list |> map compress |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compressibility-z">
<h3><a class="doc-anchor" href="#doc-compressibility-z">#</a> <code>compressibility_z</code></h3>
<p><code>compressibility_z</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = compressibility_z $x
# or in a pipeline:
@list |> map compressibility_z |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compton-wavelength">
<h3><a class="doc-anchor" href="#doc-compton-wavelength">#</a> <code>compton_wavelength</code></h3>
<p><code>compton_wavelength</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = compton_wavelength $x
# or in a pipeline:
@list |> map compton_wavelength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compute-residuals">
<h3><a class="doc-anchor" href="#doc-compute-residuals">#</a> <code>compute_residuals</code></h3>
<p><code>compute_residuals</code> — batch 9 builtin. Alias for <code>residuals_compute</code>.</p>
<pre><code class="lang-perl">my $result = compute_residuals $x
# or in a pipeline:
@list |> map compute_residuals |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-concat-map">
<h3><a class="doc-anchor" href="#doc-concat-map">#</a> <code>concat_map</code></h3>
<p><code>concat_map</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = concat_map $x
# or in a pipeline:
@list |> map concat_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-concentration-dilute">
<h3><a class="doc-anchor" href="#doc-concentration-dilute">#</a> <code>concentration_dilute</code></h3>
<p><code>concentration_dilute</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = concentration_dilute $x
# or in a pipeline:
@list |> map concentration_dilute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-concordance-correlation">
<h3><a class="doc-anchor" href="#doc-concordance-correlation">#</a> <code>concordance_correlation</code></h3>
<p><code>concordance_correlation</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = concordance_correlation $x
# or in a pipeline:
@list |> map concordance_correlation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cond">
<h3><a class="doc-anchor" href="#doc-cond">#</a> <code>cond</code></h3>
<p><code>matrix_cond</code> (aliases <code>mcond</code>, <code>cond</code>) estimates the condition number of a matrix (ratio of largest to smallest singular value). Large values indicate ill-conditioning.</p>
<pre><code class="lang-perl">p cond([[1,0],[0,1]]) # 1 (perfect)
p cond([[1,2],[2,4]]) # Inf (singular)
</code></pre>
</article>
<article class="doc-entry" id="doc-conditional-entropy-step">
<h3><a class="doc-anchor" href="#doc-conditional-entropy-step">#</a> <code>conditional_entropy_step</code></h3>
<p><code>conditional_entropy_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = conditional_entropy_step $x
# or in a pipeline:
@list |> map conditional_entropy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-conditional-gradient-step">
<h3><a class="doc-anchor" href="#doc-conditional-gradient-step">#</a> <code>conditional_gradient_step</code></h3>
<p><code>conditional_gradient_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = conditional_gradient_step $x
# or in a pipeline:
@list |> map conditional_gradient_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-condorcet-winner-check">
<h3><a class="doc-anchor" href="#doc-condorcet-winner-check">#</a> <code>condorcet_winner_check</code></h3>
<p><code>condorcet_winner_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = condorcet_winner_check $x
# or in a pipeline:
@list |> map condorcet_winner_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cone-surface">
<h3><a class="doc-anchor" href="#doc-cone-surface">#</a> <code>cone_surface</code></h3>
<p><code>cone_surface</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = cone_surface $x
# or in a pipeline:
@list |> map cone_surface |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cone-volume">
<h3><a class="doc-anchor" href="#doc-cone-volume">#</a> <code>cone_volume</code></h3>
<p><code>cone_volume</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = cone_volume $x
# or in a pipeline:
@list |> map cone_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-conevol">
<h3><a class="doc-anchor" href="#doc-conevol">#</a> <code>conevol</code></h3>
<p><code>conevol</code> — geometry / physics builtin. Alias for <code>cone_volume</code>.</p>
<pre><code class="lang-perl">my $result = conevol $x
# or in a pipeline:
@list |> map conevol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-confint">
<h3><a class="doc-anchor" href="#doc-confint">#</a> <code>confint</code></h3>
<p><code>confint_lm</code> (alias <code>confint</code>) — confidence intervals for model coefficients. Returns hash with intercept_lower/upper, slope_lower/upper.</p>
<pre><code class="lang-perl">my $ci = confint(lm([1,2,3,4,5], [2,4,5,4,5]))
p $ci->{slope_lower}
</code></pre>
</article>
<article class="doc-entry" id="doc-conformal-compactification-step">
<h3><a class="doc-anchor" href="#doc-conformal-compactification-step">#</a> <code>conformal_compactification_step</code></h3>
<p><code>conformal_compactification_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = conformal_compactification_step $x
# or in a pipeline:
@list |> map conformal_compactification_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-confusion-counts">
<h3><a class="doc-anchor" href="#doc-confusion-counts">#</a> <code>confusion_counts</code></h3>
<p><code>confusion_counts</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = confusion_counts $x
# or in a pipeline:
@list |> map confusion_counts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-conj">
<h3><a class="doc-anchor" href="#doc-conj">#</a> <code>conj</code></h3>
<p><code>conj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = conj $x
# or in a pipeline:
@list |> map conj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-connected-components">
<h3><a class="doc-anchor" href="#doc-connected-components">#</a> <code>connected_components</code></h3>
<p><code>connected_components</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = connected_components $x
# or in a pipeline:
@list |> map connected_components |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-connected-components-graph">
<h3><a class="doc-anchor" href="#doc-connected-components-graph">#</a> <code>connected_components_graph</code></h3>
<p><code>connected_components_graph</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = connected_components_graph $x
# or in a pipeline:
@list |> map connected_components_graph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cons">
<h3><a class="doc-anchor" href="#doc-cons">#</a> <code>cons</code></h3>
<p><code>cons</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = cons $x
# or in a pipeline:
@list |> map cons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-consecutive-eq">
<h3><a class="doc-anchor" href="#doc-consecutive-eq">#</a> <code>consecutive_eq</code></h3>
<p><code>consecutive_eq</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = consecutive_eq $x
# or in a pipeline:
@list |> map consecutive_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-consecutive-pairs">
<h3><a class="doc-anchor" href="#doc-consecutive-pairs">#</a> <code>consecutive_pairs</code></h3>
<p><code>consecutive_pairs</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = consecutive_pairs $x
# or in a pipeline:
@list |> map consecutive_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-const-fn">
<h3><a class="doc-anchor" href="#doc-const-fn">#</a> <code>const_fn</code></h3>
<p><code>const_fn</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = const_fn $x
# or in a pipeline:
@list |> map const_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-constant-case">
<h3><a class="doc-anchor" href="#doc-constant-case">#</a> <code>constant_case</code></h3>
<p><code>constant_case</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = constant_case $x
# or in a pipeline:
@list |> map constant_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-constituency-cyk">
<h3><a class="doc-anchor" href="#doc-constituency-cyk">#</a> <code>constituency_cyk</code></h3>
<p><code>constituency_cyk</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = constituency_cyk $x
# or in a pipeline:
@list |> map constituency_cyk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-consumer-surplus">
<h3><a class="doc-anchor" href="#doc-consumer-surplus">#</a> <code>consumer_surplus</code></h3>
<p><code>consumer_surplus</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = consumer_surplus $x
# or in a pipeline:
@list |> map consumer_surplus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contact-tracing-eff">
<h3><a class="doc-anchor" href="#doc-contact-tracing-eff">#</a> <code>contact_tracing_eff</code></h3>
<p><code>contact_tracing_eff</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = contact_tracing_eff $x
# or in a pipeline:
@list |> map contact_tracing_eff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contains">
<h3><a class="doc-anchor" href="#doc-contains">#</a> <code>contains</code></h3>
<p><code>contains</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = contains $x
# or in a pipeline:
@list |> map contains |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contains-all">
<h3><a class="doc-anchor" href="#doc-contains-all">#</a> <code>contains_all</code></h3>
<p><code>contains_all</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = contains_all $x
# or in a pipeline:
@list |> map contains_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contains-any">
<h3><a class="doc-anchor" href="#doc-contains-any">#</a> <code>contains_any</code></h3>
<p><code>contains_any</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = contains_any $x
# or in a pipeline:
@list |> map contains_any |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contains-elem">
<h3><a class="doc-anchor" href="#doc-contains-elem">#</a> <code>contains_elem</code></h3>
<p><code>contains_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = contains_elem $x
# or in a pipeline:
@list |> map contains_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contcomp">
<h3><a class="doc-anchor" href="#doc-contcomp">#</a> <code>contcomp</code></h3>
<p><code>contcomp</code> — finance (extended) builtin. Alias for <code>continuous_compound</code>.</p>
<pre><code class="lang-perl">my $result = contcomp $x
# or in a pipeline:
@list |> map contcomp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-content-negotiate">
<h3><a class="doc-anchor" href="#doc-content-negotiate">#</a> <code>content_negotiate</code></h3>
<p><code>content_negotiate</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = content_negotiate $x
# or in a pipeline:
@list |> map content_negotiate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-continued-fraction-sqrt">
<h3><a class="doc-anchor" href="#doc-continued-fraction-sqrt">#</a> <code>continued_fraction_sqrt</code></h3>
<p><code>continued_fraction_sqrt</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = continued_fraction_sqrt $x
# or in a pipeline:
@list |> map continued_fraction_sqrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-continuous-compound">
<h3><a class="doc-anchor" href="#doc-continuous-compound">#</a> <code>continuous_compound</code></h3>
<p><code>continuous_compound($principal, $rate, $time)</code> (alias <code>ccomp</code>) — computes future value with continuous compounding: P × e^(rt).</p>
<pre><code class="lang-perl">p ccomp(1000, 0.05, 10) # ~1648.72
</code></pre>
</article>
<article class="doc-entry" id="doc-contrast-ratio">
<h3><a class="doc-anchor" href="#doc-contrast-ratio">#</a> <code>contrast_ratio</code></h3>
<p><code>contrast_ratio</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = contrast_ratio $x
# or in a pipeline:
@list |> map contrast_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contrast-ratio-wcag">
<h3><a class="doc-anchor" href="#doc-contrast-ratio-wcag">#</a> <code>contrast_ratio_wcag</code></h3>
<p><code>contrast_ratio_wcag</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = contrast_ratio_wcag $x
# or in a pipeline:
@list |> map contrast_ratio_wcag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-conv">
<h3><a class="doc-anchor" href="#doc-conv">#</a> <code>conv</code></h3>
<p><code>conv</code> — math / numeric (uncategorized batch) builtin. Alias for <code>convolution</code>.</p>
<pre><code class="lang-perl">my $result = conv $x
# or in a pipeline:
@list |> map conv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-converge">
<h3><a class="doc-anchor" href="#doc-converge">#</a> <code>converge</code></h3>
<p><code>converge</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = converge $x
# or in a pipeline:
@list |> map converge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-convex-hull-chan">
<h3><a class="doc-anchor" href="#doc-convex-hull-chan">#</a> <code>convex_hull_chan</code></h3>
<p><code>convex_hull_chan</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = convex_hull_chan $x
# or in a pipeline:
@list |> map convex_hull_chan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-convex-hull-jarvis">
<h3><a class="doc-anchor" href="#doc-convex-hull-jarvis">#</a> <code>convex_hull_jarvis</code></h3>
<p><code>convex_hull_jarvis</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = convex_hull_jarvis $x
# or in a pipeline:
@list |> map convex_hull_jarvis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-convexity">
<h3><a class="doc-anchor" href="#doc-convexity">#</a> <code>convexity</code></h3>
<p><code>convexity</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = convexity $x
# or in a pipeline:
@list |> map convexity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-convolution">
<h3><a class="doc-anchor" href="#doc-convolution">#</a> <code>convolution</code></h3>
<p><code>convolution</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = convolution $x
# or in a pipeline:
@list |> map convolution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-convolve-2d">
<h3><a class="doc-anchor" href="#doc-convolve-2d">#</a> <code>convolve_2d</code></h3>
<p><code>convolve_2d</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = convolve_2d $x
# or in a pipeline:
@list |> map convolve_2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-convolve-full">
<h3><a class="doc-anchor" href="#doc-convolve-full">#</a> <code>convolve_full</code></h3>
<p><code>convolve_full</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = convolve_full $x
# or in a pipeline:
@list |> map convolve_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-convolve-valid">
<h3><a class="doc-anchor" href="#doc-convolve-valid">#</a> <code>convolve_valid</code></h3>
<p><code>convolve_valid</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = convolve_valid $x
# or in a pipeline:
@list |> map convolve_valid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coombs-runoff-step">
<h3><a class="doc-anchor" href="#doc-coombs-runoff-step">#</a> <code>coombs_runoff_step</code></h3>
<p><code>coombs_runoff_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = coombs_runoff_step $x
# or in a pipeline:
@list |> map coombs_runoff_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cooperative-game-value">
<h3><a class="doc-anchor" href="#doc-cooperative-game-value">#</a> <code>cooperative_game_value</code></h3>
<p><code>cooperative_game_value</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = cooperative_game_value $x
# or in a pipeline:
@list |> map cooperative_game_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coordination-game-payoff">
<h3><a class="doc-anchor" href="#doc-coordination-game-payoff">#</a> <code>coordination_game_payoff</code></h3>
<p><code>coordination_game_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = coordination_game_payoff $x
# or in a pipeline:
@list |> map coordination_game_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-copeland-score-step">
<h3><a class="doc-anchor" href="#doc-copeland-score-step">#</a> <code>copeland_score_step</code></h3>
<p><code>copeland_score_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = copeland_score_step $x
# or in a pipeline:
@list |> map copeland_score_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coppersmith-bound">
<h3><a class="doc-anchor" href="#doc-coppersmith-bound">#</a> <code>coppersmith_bound</code></h3>
<p><code>coppersmith_bound</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = coppersmith_bound $x
# or in a pipeline:
@list |> map coppersmith_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coptic-from-fixed">
<h3><a class="doc-anchor" href="#doc-coptic-from-fixed">#</a> <code>coptic_from_fixed</code></h3>
<p><code>coptic_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = coptic_from_fixed $x
# or in a pipeline:
@list |> map coptic_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-copy-sign">
<h3><a class="doc-anchor" href="#doc-copy-sign">#</a> <code>copy_sign</code></h3>
<p><code>copy_sign</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = copy_sign $x
# or in a pipeline:
@list |> map copy_sign |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-copy-within">
<h3><a class="doc-anchor" href="#doc-copy-within">#</a> <code>copy_within</code></h3>
<p><code>copy_within</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = copy_within $x
# or in a pipeline:
@list |> map copy_within |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-copysign">
<h3><a class="doc-anchor" href="#doc-copysign">#</a> <code>copysign</code></h3>
<p><code>copysign</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = copysign $x
# or in a pipeline:
@list |> map copysign |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coq-tactic-apply">
<h3><a class="doc-anchor" href="#doc-coq-tactic-apply">#</a> <code>coq_tactic_apply</code></h3>
<p><code>coq_tactic_apply</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = coq_tactic_apply $x
# or in a pipeline:
@list |> map coq_tactic_apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coq-unify-term">
<h3><a class="doc-anchor" href="#doc-coq-unify-term">#</a> <code>coq_unify_term</code></h3>
<p><code>coq_unify_term</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = coq_unify_term $x
# or in a pipeline:
@list |> map coq_unify_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cor-mat">
<h3><a class="doc-anchor" href="#doc-cor-mat">#</a> <code>cor_mat</code></h3>
<p><code>cor_matrix</code> (alias <code>cor_mat</code>) — correlation matrix from observations. Each row is an observation vector.</p>
<pre><code class="lang-perl">my $R = cor_mat([[1,2],[3,4],[5,6]]) # 2x2 correlation matrix
</code></pre>
</article>
<article class="doc-entry" id="doc-core-coalition">
<h3><a class="doc-anchor" href="#doc-core-coalition">#</a> <code>core_coalition</code></h3>
<p><code>core_coalition</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = core_coalition $x
# or in a pipeline:
@list |> map core_coalition |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-core-membership-check">
<h3><a class="doc-anchor" href="#doc-core-membership-check">#</a> <code>core_membership_check</code></h3>
<p><code>core_membership_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = core_membership_check $x
# or in a pipeline:
@list |> map core_membership_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coreference-singleton">
<h3><a class="doc-anchor" href="#doc-coreference-singleton">#</a> <code>coreference_singleton</code></h3>
<p><code>coreference_singleton</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = coreference_singleton $x
# or in a pipeline:
@list |> map coreference_singleton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-corner-subpix">
<h3><a class="doc-anchor" href="#doc-corner-subpix">#</a> <code>corner_subpix</code></h3>
<p><code>corner_subpix</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = corner_subpix $x
# or in a pipeline:
@list |> map corner_subpix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-corr">
<h3><a class="doc-anchor" href="#doc-corr">#</a> <code>corr</code></h3>
<p><code>corr</code> — extended stdlib builtin. Alias for <code>correlation</code>.</p>
<pre><code class="lang-perl">my $result = corr $x
# or in a pipeline:
@list |> map corr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-corr-agg">
<h3><a class="doc-anchor" href="#doc-corr-agg">#</a> <code>corr_agg</code></h3>
<p><code>corr_agg</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = corr_agg $x
# or in a pipeline:
@list |> map corr_agg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-correlate-full">
<h3><a class="doc-anchor" href="#doc-correlate-full">#</a> <code>correlate_full</code></h3>
<p><code>correlate_full</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = correlate_full $x
# or in a pipeline:
@list |> map correlate_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-correlated-equilibrium-value">
<h3><a class="doc-anchor" href="#doc-correlated-equilibrium-value">#</a> <code>correlated_equilibrium_value</code></h3>
<p><code>correlated_equilibrium_value</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = correlated_equilibrium_value $x
# or in a pipeline:
@list |> map correlated_equilibrium_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-correlation">
<h3><a class="doc-anchor" href="#doc-correlation">#</a> <code>correlation</code></h3>
<p><code>correlation</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = correlation $x
# or in a pipeline:
@list |> map correlation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-corsi-for">
<h3><a class="doc-anchor" href="#doc-corsi-for">#</a> <code>corsi_for</code></h3>
<p><code>corsi_for</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = corsi_for $x
# or in a pipeline:
@list |> map corsi_for |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosh">
<h3><a class="doc-anchor" href="#doc-cosh">#</a> <code>cosh</code></h3>
<p><code>cosh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = cosh $x
# or in a pipeline:
@list |> map cosh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosh-minus1-over-x2">
<h3><a class="doc-anchor" href="#doc-cosh-minus1-over-x2">#</a> <code>cosh_minus1_over_x2</code></h3>
<p><code>cosh_minus1_over_x2</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = cosh_minus1_over_x2 $x
# or in a pipeline:
@list |> map cosh_minus1_over_x2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosine-integral-ci">
<h3><a class="doc-anchor" href="#doc-cosine-integral-ci">#</a> <code>cosine_integral_ci</code></h3>
<p><code>cosine_integral_ci</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = cosine_integral_ci $x
# or in a pipeline:
@list |> map cosine_integral_ci |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosine-similarity">
<h3><a class="doc-anchor" href="#doc-cosine-similarity">#</a> <code>cosine_similarity</code></h3>
<p><code>cosine_similarity</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = cosine_similarity $x
# or in a pipeline:
@list |> map cosine_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosmic-distance-modulus-si">
<h3><a class="doc-anchor" href="#doc-cosmic-distance-modulus-si">#</a> <code>cosmic_distance_modulus_si</code></h3>
<p><code>cosmic_distance_modulus_si</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = cosmic_distance_modulus_si $x
# or in a pipeline:
@list |> map cosmic_distance_modulus_si |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosmological-constant">
<h3><a class="doc-anchor" href="#doc-cosmological-constant">#</a> <code>cosmological_constant</code></h3>
<p><code>cosmological_constant</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = cosmological_constant $x
# or in a pipeline:
@list |> map cosmological_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosmological-constant-term">
<h3><a class="doc-anchor" href="#doc-cosmological-constant-term">#</a> <code>cosmological_constant_term</code></h3>
<p><code>cosmological_constant_term</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = cosmological_constant_term $x
# or in a pipeline:
@list |> map cosmological_constant_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cot">
<h3><a class="doc-anchor" href="#doc-cot">#</a> <code>cot</code></h3>
<p><code>cot</code> returns the cotangent (1/tan) of an angle in radians.</p>
<pre><code class="lang-perl">p cot(0.7854) # ≈ 1.0 (cot 45°)
</code></pre>
</article>
<article class="doc-entry" id="doc-coulomb">
<h3><a class="doc-anchor" href="#doc-coulomb">#</a> <code>coulomb</code></h3>
<p><code>coulomb_force($q1, $q2, $r)</code> (alias <code>coulomb</code>) — Coulomb's law: F = kq₁q₂/r². Charges in Coulombs, distance in meters.</p>
<pre><code class="lang-perl">p coulomb(1e-6, 1e-6, 0.1) # ~0.9 N (two 1μC charges 10cm apart)
</code></pre>
</article>
<article class="doc-entry" id="doc-coulomb-constant">
<h3><a class="doc-anchor" href="#doc-coulomb-constant">#</a> <code>coulomb_constant</code></h3>
<p><code>coulomb_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = coulomb_constant $x
# or in a pipeline:
@list |> map coulomb_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coulomb-f0">
<h3><a class="doc-anchor" href="#doc-coulomb-f0">#</a> <code>coulomb_f0</code></h3>
<p><code>coulomb_f0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = coulomb_f0 $x
# or in a pipeline:
@list |> map coulomb_f0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coulombic-efficiency-cell">
<h3><a class="doc-anchor" href="#doc-coulombic-efficiency-cell">#</a> <code>coulombic_efficiency_cell</code></h3>
<p><code>coulombic_efficiency_cell</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = coulombic_efficiency_cell $x
# or in a pipeline:
@list |> map coulombic_efficiency_cell |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-by">
<h3><a class="doc-anchor" href="#doc-count-by">#</a> <code>count_by</code></h3>
<p><code>count_by</code> — functional / iterator builtin. Alias for <code>take_while</code>.</p>
<pre><code class="lang-perl">my $result = count_by $x
# or in a pipeline:
@list |> map count_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-bytes">
<h3><a class="doc-anchor" href="#doc-count-bytes">#</a> <code>count_bytes</code></h3>
<p><code>count_bytes</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_bytes $x
# or in a pipeline:
@list |> map count_bytes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-char">
<h3><a class="doc-anchor" href="#doc-count-char">#</a> <code>count_char</code></h3>
<p><code>count_char</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = count_char $x
# or in a pipeline:
@list |> map count_char |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-chars">
<h3><a class="doc-anchor" href="#doc-count-chars">#</a> <code>count_chars</code></h3>
<p><code>count_chars</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_chars $x
# or in a pipeline:
@list |> map count_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-consonants">
<h3><a class="doc-anchor" href="#doc-count-consonants">#</a> <code>count_consonants</code></h3>
<p><code>count_consonants</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = count_consonants $x
# or in a pipeline:
@list |> map count_consonants |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-digits">
<h3><a class="doc-anchor" href="#doc-count-digits">#</a> <code>count_digits</code></h3>
<p><code>count_digits</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_digits $x
# or in a pipeline:
@list |> map count_digits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-elem">
<h3><a class="doc-anchor" href="#doc-count-elem">#</a> <code>count_elem</code></h3>
<p><code>count_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_elem $x
# or in a pipeline:
@list |> map count_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-eq">
<h3><a class="doc-anchor" href="#doc-count-eq">#</a> <code>count_eq</code></h3>
<p><code>count_eq</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = count_eq $x
# or in a pipeline:
@list |> map count_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-inversions">
<h3><a class="doc-anchor" href="#doc-count-inversions">#</a> <code>count_inversions</code></h3>
<p><code>count_inversions</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_inversions $x
# or in a pipeline:
@list |> map count_inversions |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-letters">
<h3><a class="doc-anchor" href="#doc-count-letters">#</a> <code>count_letters</code></h3>
<p><code>count_letters</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_letters $x
# or in a pipeline:
@list |> map count_letters |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-lines">
<h3><a class="doc-anchor" href="#doc-count-lines">#</a> <code>count_lines</code></h3>
<p><code>count_lines</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_lines $x
# or in a pipeline:
@list |> map count_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-lower">
<h3><a class="doc-anchor" href="#doc-count-lower">#</a> <code>count_lower</code></h3>
<p><code>count_lower</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_lower $x
# or in a pipeline:
@list |> map count_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-match">
<h3><a class="doc-anchor" href="#doc-count-match">#</a> <code>count_match</code></h3>
<p><code>count_match</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_match $x
# or in a pipeline:
@list |> map count_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-ne">
<h3><a class="doc-anchor" href="#doc-count-ne">#</a> <code>count_ne</code></h3>
<p><code>count_ne</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = count_ne $x
# or in a pipeline:
@list |> map count_ne |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-punctuation">
<h3><a class="doc-anchor" href="#doc-count-punctuation">#</a> <code>count_punctuation</code></h3>
<p><code>count_punctuation</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_punctuation $x
# or in a pipeline:
@list |> map count_punctuation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-regex-matches">
<h3><a class="doc-anchor" href="#doc-count-regex-matches">#</a> <code>count_regex_matches</code></h3>
<p><code>count_regex_matches</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = count_regex_matches $x
# or in a pipeline:
@list |> map count_regex_matches |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-spaces">
<h3><a class="doc-anchor" href="#doc-count-spaces">#</a> <code>count_spaces</code></h3>
<p><code>count_spaces</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_spaces $x
# or in a pipeline:
@list |> map count_spaces |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-substring">
<h3><a class="doc-anchor" href="#doc-count-substring">#</a> <code>count_substring</code></h3>
<p><code>count_substring</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = count_substring $x
# or in a pipeline:
@list |> map count_substring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-upper">
<h3><a class="doc-anchor" href="#doc-count-upper">#</a> <code>count_upper</code></h3>
<p><code>count_upper</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_upper $x
# or in a pipeline:
@list |> map count_upper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-vowels">
<h3><a class="doc-anchor" href="#doc-count-vowels">#</a> <code>count_vowels</code></h3>
<p><code>count_vowels</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = count_vowels $x
# or in a pipeline:
@list |> map count_vowels |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-while">
<h3><a class="doc-anchor" href="#doc-count-while">#</a> <code>count_while</code></h3>
<p><code>count_while</code> — ruby enumerable extras builtin.</p>
<pre><code class="lang-perl">my $result = count_while $x
# or in a pipeline:
@list |> map count_while |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-words">
<h3><a class="doc-anchor" href="#doc-count-words">#</a> <code>count_words</code></h3>
<p><code>count_words</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_words $x
# or in a pipeline:
@list |> map count_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-counter">
<h3><a class="doc-anchor" href="#doc-counter">#</a> <code>counter</code></h3>
<p><code>counter</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = counter $x
# or in a pipeline:
@list |> map counter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-counter-most-common">
<h3><a class="doc-anchor" href="#doc-counter-most-common">#</a> <code>counter_most_common</code></h3>
<p><code>counter_most_common</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = counter_most_common $x
# or in a pipeline:
@list |> map counter_most_common |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-countif">
<h3><a class="doc-anchor" href="#doc-countif">#</a> <code>countif</code></h3>
<p><code>countif</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = countif $x
# or in a pipeline:
@list |> map countif |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-countifs">
<h3><a class="doc-anchor" href="#doc-countifs">#</a> <code>countifs</code></h3>
<p><code>countifs</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = countifs $x
# or in a pipeline:
@list |> map countifs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coupon-count">
<h3><a class="doc-anchor" href="#doc-coupon-count">#</a> <code>coupon_count</code></h3>
<p><code>coupon_count</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = coupon_count $x
# or in a pipeline:
@list |> map coupon_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-courant-friedrichs-lewy">
<h3><a class="doc-anchor" href="#doc-courant-friedrichs-lewy">#</a> <code>courant_friedrichs_lewy</code></h3>
<p><code>courant_friedrichs_lewy</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = courant_friedrichs_lewy $x
# or in a pipeline:
@list |> map courant_friedrichs_lewy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cournot-eq">
<h3><a class="doc-anchor" href="#doc-cournot-eq">#</a> <code>cournot_eq</code></h3>
<p><code>cournot_eq</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = cournot_eq $x
# or in a pipeline:
@list |> map cournot_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cournot-quantity-step">
<h3><a class="doc-anchor" href="#doc-cournot-quantity-step">#</a> <code>cournot_quantity_step</code></h3>
<p><code>cournot_quantity_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = cournot_quantity_step $x
# or in a pipeline:
@list |> map cournot_quantity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cov">
<h3><a class="doc-anchor" href="#doc-cov">#</a> <code>cov</code></h3>
<p><code>cov</code> — extended stdlib builtin. Alias for <code>covariance</code>.</p>
<pre><code class="lang-perl">my $result = cov $x
# or in a pipeline:
@list |> map cov |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cov2cor">
<h3><a class="doc-anchor" href="#doc-cov2cor">#</a> <code>cov2cor</code></h3>
<p><code>cov2cor</code> — convert covariance matrix to correlation matrix. Like R's cov2cor().</p>
<pre><code class="lang-perl">my $cor = cov2cor(cov_mat($data))
</code></pre>
</article>
<article class="doc-entry" id="doc-cov-mat">
<h3><a class="doc-anchor" href="#doc-cov-mat">#</a> <code>cov_mat</code></h3>
<p><code>cov_matrix</code> (alias <code>cov_mat</code>) — covariance matrix from observations.</p>
<pre><code class="lang-perl">my $S = cov_mat([[1,2],[3,4],[5,6]])
</code></pre>
</article>
<article class="doc-entry" id="doc-covar-pop">
<h3><a class="doc-anchor" href="#doc-covar-pop">#</a> <code>covar_pop</code></h3>
<p><code>covar_pop</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = covar_pop $x
# or in a pipeline:
@list |> map covar_pop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-covar-samp">
<h3><a class="doc-anchor" href="#doc-covar-samp">#</a> <code>covar_samp</code></h3>
<p><code>covar_samp</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = covar_samp $x
# or in a pipeline:
@list |> map covar_samp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-covariance">
<h3><a class="doc-anchor" href="#doc-covariance">#</a> <code>covariance</code></h3>
<p><code>covariance</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = covariance $x
# or in a pipeline:
@list |> map covariance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-covariance-matrix-pts">
<h3><a class="doc-anchor" href="#doc-covariance-matrix-pts">#</a> <code>covariance_matrix_pts</code></h3>
<p><code>covariance_matrix_pts</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = covariance_matrix_pts $x
# or in a pipeline:
@list |> map covariance_matrix_pts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-covariant-derivative-step">
<h3><a class="doc-anchor" href="#doc-covariant-derivative-step">#</a> <code>covariant_derivative_step</code></h3>
<p><code>covariant_derivative_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = covariant_derivative_step $x
# or in a pipeline:
@list |> map covariant_derivative_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cp-monatomic-ideal">
<h3><a class="doc-anchor" href="#doc-cp-monatomic-ideal">#</a> <code>cp_monatomic_ideal</code></h3>
<p><code>cp_monatomic_ideal</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = cp_monatomic_ideal $x
# or in a pipeline:
@list |> map cp_monatomic_ideal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpat">
<h3><a class="doc-anchor" href="#doc-cpat">#</a> <code>cpat</code></h3>
<p><code>cpat</code> — extended stdlib builtin. Alias for <code>code_point_at</code>.</p>
<pre><code class="lang-perl">my $result = cpat $x
# or in a pipeline:
@list |> map cpat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpfx">
<h3><a class="doc-anchor" href="#doc-cpfx">#</a> <code>cpfx</code></h3>
<p><code>cpfx</code> — extended stdlib builtin. Alias for <code>common_prefix</code>.</p>
<pre><code class="lang-perl">my $result = cpfx $x
# or in a pipeline:
@list |> map cpfx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpl-w">
<h3><a class="doc-anchor" href="#doc-cpl-w">#</a> <code>cpl_w</code></h3>
<p><code>cpl_w</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = cpl_w $x
# or in a pipeline:
@list |> map cpl_w |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cprod">
<h3><a class="doc-anchor" href="#doc-cprod">#</a> <code>cprod</code></h3>
<p><code>cprod</code> — python/ruby stdlib builtin. Alias for <code>cartesian_product</code>.</p>
<pre><code class="lang-perl">my $result = cprod $x
# or in a pipeline:
@list |> map cprod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cprod-acc">
<h3><a class="doc-anchor" href="#doc-cprod-acc">#</a> <code>cprod_acc</code></h3>
<p><code>cprod_acc</code> — extended stdlib builtin. Alias for <code>cumprod</code>.</p>
<pre><code class="lang-perl">my $result = cprod_acc $x
# or in a pipeline:
@list |> map cprod_acc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpsgn">
<h3><a class="doc-anchor" href="#doc-cpsgn">#</a> <code>cpsgn</code></h3>
<p><code>cpsgn</code> — extended stdlib builtin. Alias for <code>copy_sign</code>.</p>
<pre><code class="lang-perl">my $result = cpsgn $x
# or in a pipeline:
@list |> map cpsgn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpu-count">
<h3><a class="doc-anchor" href="#doc-cpu-count">#</a> <code>cpu_count</code></h3>
<p><code>cpu_count</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = cpu_count $x
# or in a pipeline:
@list |> map cpu_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpyw">
<h3><a class="doc-anchor" href="#doc-cpyw">#</a> <code>cpyw</code></h3>
<p><code>cpyw</code> — additional missing stdlib functions builtin. Alias for <code>copy_within</code>.</p>
<pre><code class="lang-perl">my $result = cpyw $x
# or in a pipeline:
@list |> map cpyw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cr">
<h3><a class="doc-anchor" href="#doc-cr">#</a> <code>cr</code></h3>
<p><code>cr</code> — data / network builtin. Alias for <code>csv_read</code>.</p>
<pre><code class="lang-perl">my $result = cr $x
# or in a pipeline:
@list |> map cr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cramer-lundberg-step">
<h3><a class="doc-anchor" href="#doc-cramer-lundberg-step">#</a> <code>cramer_lundberg_step</code></h3>
<p><code>cramer_lundberg_step</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = cramer_lundberg_step $x
# or in a pipeline:
@list |> map cramer_lundberg_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cramer-rao-bound">
<h3><a class="doc-anchor" href="#doc-cramer-rao-bound">#</a> <code>cramer_rao_bound</code></h3>
<p><code>cramer_rao_bound</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = cramer_rao_bound $x
# or in a pipeline:
@list |> map cramer_rao_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crank-nicolson-ode">
<h3><a class="doc-anchor" href="#doc-crank-nicolson-ode">#</a> <code>crank_nicolson_ode</code></h3>
<p><code>crank_nicolson_ode</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = crank_nicolson_ode $x
# or in a pipeline:
@list |> map crank_nicolson_ode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crc16-ccitt">
<h3><a class="doc-anchor" href="#doc-crc16-ccitt">#</a> <code>crc16_ccitt</code></h3>
<p><code>crc16_ccitt</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = crc16_ccitt $x
# or in a pipeline:
@list |> map crc16_ccitt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-credibility-buhlmann">
<h3><a class="doc-anchor" href="#doc-credibility-buhlmann">#</a> <code>credibility_buhlmann</code></h3>
<p><code>credibility_buhlmann</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = credibility_buhlmann $x
# or in a pipeline:
@list |> map credibility_buhlmann |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crf-log-likelihood">
<h3><a class="doc-anchor" href="#doc-crf-log-likelihood">#</a> <code>crf_log_likelihood</code></h3>
<p><code>crf_log_likelihood</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = crf_log_likelihood $x
# or in a pipeline:
@list |> map crf_log_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crindex">
<h3><a class="doc-anchor" href="#doc-crindex">#</a> <code>crindex</code></h3>
<p><code>crindex STRING, SUBSTRING [, FROM]</code> — codepoint-indexed equivalent of Perl 5's <code>rindex</code>. Returns the last codepoint position where SUBSTRING occurs (at or before FROM, defaulting to end-of-string), or -1 on miss. Counterpart to <code>cindex</code>; pairs with <code>[]</code> slice operators and <code>len</code>.</p>
<pre><code class="lang-perl">my $path = "foo/bar/─/baz.gz"
p rindex $path, "/" # 13 (bytes)
p crindex $path, "/" # 11 (codepoints)
my $i = crindex $path, "/"
p $path[$i + 1 : len($path) - 1] # "baz.gz"
</code></pre>
</article>
<article class="doc-entry" id="doc-critang">
<h3><a class="doc-anchor" href="#doc-critang">#</a> <code>critang</code></h3>
<p><code>critang</code> — physics formulas builtin. Alias for <code>critical_angle</code>.</p>
<pre><code class="lang-perl">my $result = critang $x
# or in a pipeline:
@list |> map critang |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-critical-angle">
<h3><a class="doc-anchor" href="#doc-critical-angle">#</a> <code>critical_angle</code></h3>
<p><code>critical_angle</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = critical_angle $x
# or in a pipeline:
@list |> map critical_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-critical-density">
<h3><a class="doc-anchor" href="#doc-critical-density">#</a> <code>critical_density</code></h3>
<p><code>critical_density</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = critical_density $x
# or in a pipeline:
@list |> map critical_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-critical-density-si">
<h3><a class="doc-anchor" href="#doc-critical-density-si">#</a> <code>critical_density_si</code></h3>
<p><code>critical_density_si</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = critical_density_si $x
# or in a pipeline:
@list |> map critical_density_si |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cron-next-fire">
<h3><a class="doc-anchor" href="#doc-cron-next-fire">#</a> <code>cron_next_fire</code></h3>
<p><code>cron_next_fire</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = cron_next_fire $x
# or in a pipeline:
@list |> map cron_next_fire |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cross-correlation">
<h3><a class="doc-anchor" href="#doc-cross-correlation">#</a> <code>cross_correlation</code></h3>
<p><code>cross_correlation(\@a, \@b)</code> (alias <code>xcorr</code>) — computes the cross-correlation of two signals. Measures similarity as a function of time-lag. Peak location indicates time delay between signals.</p>
<pre><code class="lang-perl">my $xcor = xcorr(\@signal1, \@signal2)
my $lag = max_index(@$xcor) # find peak lag
</code></pre>
</article>
<article class="doc-entry" id="doc-cross-elasticity">
<h3><a class="doc-anchor" href="#doc-cross-elasticity">#</a> <code>cross_elasticity</code></h3>
<p><code>cross_elasticity</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = cross_elasticity $x
# or in a pipeline:
@list |> map cross_elasticity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cross-entropy">
<h3><a class="doc-anchor" href="#doc-cross-entropy">#</a> <code>cross_entropy</code></h3>
<p><code>cross_entropy</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = cross_entropy $x
# or in a pipeline:
@list |> map cross_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cross-polarization-amp">
<h3><a class="doc-anchor" href="#doc-cross-polarization-amp">#</a> <code>cross_polarization_amp</code></h3>
<p><code>cross_polarization_amp</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = cross_polarization_amp $x
# or in a pipeline:
@list |> map cross_polarization_amp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cross-product">
<h3><a class="doc-anchor" href="#doc-cross-product">#</a> <code>cross_product</code></h3>
<p><code>cross_product</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = cross_product $x
# or in a pipeline:
@list |> map cross_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crossp">
<h3><a class="doc-anchor" href="#doc-crossp">#</a> <code>crossp</code></h3>
<p><code>crossp</code> — extended stdlib builtin. Alias for <code>cross_product</code>.</p>
<pre><code class="lang-perl">my $result = crossp $x
# or in a pipeline:
@list |> map crossp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crossprod">
<h3><a class="doc-anchor" href="#doc-crossprod">#</a> <code>crossprod</code></h3>
<p><code>crossprod</code> — cross product t(M) * M (R's crossprod). Efficiently computes M^T M without explicit transpose.</p>
<pre><code class="lang-perl">my $ata = crossprod([[1,2],[3,4]]) # [[10,14],[14,20]]
</code></pre>
</article>
<article class="doc-entry" id="doc-crr-american-call">
<h3><a class="doc-anchor" href="#doc-crr-american-call">#</a> <code>crr_american_call</code></h3>
<p><code>crr_american_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = crr_american_call $x
# or in a pipeline:
@list |> map crr_american_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crr-american-put">
<h3><a class="doc-anchor" href="#doc-crr-american-put">#</a> <code>crr_american_put</code></h3>
<p><code>crr_american_put</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = crr_american_put $x
# or in a pipeline:
@list |> map crr_american_put |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crustal-density-depth">
<h3><a class="doc-anchor" href="#doc-crustal-density-depth">#</a> <code>crustal_density_depth</code></h3>
<p><code>crustal_density_depth</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = crustal_density_depth $x
# or in a pipeline:
@list |> map crustal_density_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crystal-field-ligand">
<h3><a class="doc-anchor" href="#doc-crystal-field-ligand">#</a> <code>crystal_field_ligand</code></h3>
<p><code>crystal_field_ligand</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = crystal_field_ligand $x
# or in a pipeline:
@list |> map crystal_field_ligand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-csc">
<h3><a class="doc-anchor" href="#doc-csc">#</a> <code>csc</code></h3>
<p><code>csc</code> returns the cosecant (1/sin) of an angle in radians.</p>
<pre><code class="lang-perl">p csc(1.5708) # ≈ 1.0 (csc 90°)
</code></pre>
</article>
<article class="doc-entry" id="doc-csd-xy">
<h3><a class="doc-anchor" href="#doc-csd-xy">#</a> <code>csd_xy</code></h3>
<p><code>csd_xy</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = csd_xy $x
# or in a pipeline:
@list |> map csd_xy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-csfx">
<h3><a class="doc-anchor" href="#doc-csfx">#</a> <code>csfx</code></h3>
<p><code>csfx</code> — extended stdlib builtin. Alias for <code>common_suffix</code>.</p>
<pre><code class="lang-perl">my $result = csfx $x
# or in a pipeline:
@list |> map csfx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-csiszar-phi-div">
<h3><a class="doc-anchor" href="#doc-csiszar-phi-div">#</a> <code>csiszar_phi_div</code></h3>
<p><code>csiszar_phi_div</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = csiszar_phi_div $x
# or in a pipeline:
@list |> map csiszar_phi_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cspline">
<h3><a class="doc-anchor" href="#doc-cspline">#</a> <code>cspline</code></h3>
<p><code>cubic_spline</code> (aliases <code>cspline</code>, <code>spline</code>) performs natural cubic spline interpolation. Takes xs, ys, and a query point x.</p>
<pre><code class="lang-perl">p spline([0,1,2,3], [0,1,0,1], 1.5) # smooth interpolation
</code></pre>
</article>
<article class="doc-entry" id="doc-csum">
<h3><a class="doc-anchor" href="#doc-csum">#</a> <code>csum</code></h3>
<p><code>csum</code> — extended stdlib builtin. Alias for <code>cumsum</code>.</p>
<pre><code class="lang-perl">my $result = csum $x
# or in a pipeline:
@list |> map csum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cswap-gate">
<h3><a class="doc-anchor" href="#doc-cswap-gate">#</a> <code>cswap_gate</code></h3>
<p><code>cswap_gate</code> — batches 14-16 builtin. Alias for <code>fredkin_gate</code>.</p>
<pre><code class="lang-perl">my $result = cswap_gate $x
# or in a pipeline:
@list |> map cswap_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ctime">
<h3><a class="doc-anchor" href="#doc-ctime">#</a> <code>ctime</code></h3>
<p><code>ctime</code> — file stat / path builtin. Alias for <code>file_ctime</code>.</p>
<pre><code class="lang-perl">my $result = ctime $x
# or in a pipeline:
@list |> map ctime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ctxt">
<h3><a class="doc-anchor" href="#doc-ctxt">#</a> <code>ctxt</code></h3>
<p><code>ctxt</code> — extended stdlib builtin. Alias for <code>center_text</code>.</p>
<pre><code class="lang-perl">my $result = ctxt $x
# or in a pipeline:
@list |> map ctxt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cuban-number">
<h3><a class="doc-anchor" href="#doc-cuban-number">#</a> <code>cuban_number</code></h3>
<p><code>cuban_number</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = cuban_number $x
# or in a pipeline:
@list |> map cuban_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cube-fn">
<h3><a class="doc-anchor" href="#doc-cube-fn">#</a> <code>cube_fn</code></h3>
<p><code>cube_fn</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = cube_fn $x
# or in a pipeline:
@list |> map cube_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cube-root">
<h3><a class="doc-anchor" href="#doc-cube-root">#</a> <code>cube_root</code></h3>
<p><code>cube_root</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = cube_root $x
# or in a pipeline:
@list |> map cube_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cubes-seq">
<h3><a class="doc-anchor" href="#doc-cubes-seq">#</a> <code>cubes_seq</code></h3>
<p><code>cubes_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = cubes_seq $x
# or in a pipeline:
@list |> map cubes_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cullen-number">
<h3><a class="doc-anchor" href="#doc-cullen-number">#</a> <code>cullen_number</code></h3>
<p><code>cullen_number</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = cullen_number $x
# or in a pipeline:
@list |> map cullen_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cumipmt">
<h3><a class="doc-anchor" href="#doc-cumipmt">#</a> <code>cumipmt</code></h3>
<p><code>cumipmt</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = cumipmt $x
# or in a pipeline:
@list |> map cumipmt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cummax">
<h3><a class="doc-anchor" href="#doc-cummax">#</a> <code>cummax</code></h3>
<p><code>cummax</code> — cumulative maximum. Each element is the max of all elements up to that position.</p>
<pre><code class="lang-perl">p cummax([3,1,4,1,5,9]) # [3,3,4,4,5,9]
</code></pre>
</article>
<article class="doc-entry" id="doc-cummin">
<h3><a class="doc-anchor" href="#doc-cummin">#</a> <code>cummin</code></h3>
<p><code>cummin</code> — cumulative minimum.</p>
<pre><code class="lang-perl">p cummin([9,5,1,4,3]) # [9,5,1,1,1]
</code></pre>
</article>
<article class="doc-entry" id="doc-cumprinc">
<h3><a class="doc-anchor" href="#doc-cumprinc">#</a> <code>cumprinc</code></h3>
<p><code>cumprinc</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = cumprinc $x
# or in a pipeline:
@list |> map cumprinc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cumprod">
<h3><a class="doc-anchor" href="#doc-cumprod">#</a> <code>cumprod</code></h3>
<p><code>cumprod</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = cumprod $x
# or in a pipeline:
@list |> map cumprod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cumsum">
<h3><a class="doc-anchor" href="#doc-cumsum">#</a> <code>cumsum</code></h3>
<p><code>cumsum</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = cumsum $x
# or in a pipeline:
@list |> map cumsum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cumtrapz">
<h3><a class="doc-anchor" href="#doc-cumtrapz">#</a> <code>cumtrapz</code></h3>
<p><code>cumtrapz</code> cumulative trapezoidal integration. Returns running integral array.</p>
<pre><code class="lang-perl">my @y = (1, 2, 3, 4)
my @F = @{cumtrapz(\@y)} # [0, 1.5, 4.0, 7.5]
</code></pre>
</article>
<article class="doc-entry" id="doc-cups-to-ml">
<h3><a class="doc-anchor" href="#doc-cups-to-ml">#</a> <code>cups_to_ml</code></h3>
<p><code>cups_to_ml</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = cups_to_ml $input
</code></pre>
</article>
<article class="doc-entry" id="doc-current-divider">
<h3><a class="doc-anchor" href="#doc-current-divider">#</a> <code>current_divider</code></h3>
<p><code>current_divider</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = current_divider $x
# or in a pipeline:
@list |> map current_divider |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-curve25519-mul-simple">
<h3><a class="doc-anchor" href="#doc-curve25519-mul-simple">#</a> <code>curve25519_mul_simple</code></h3>
<p><code>curve25519_mul_simple</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = curve25519_mul_simple $x
# or in a pipeline:
@list |> map curve25519_mul_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cusip-check">
<h3><a class="doc-anchor" href="#doc-cusip-check">#</a> <code>cusip_check</code></h3>
<p><code>cusip_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = cusip_check $x
# or in a pipeline:
@list |> map cusip_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cut">
<h3><a class="doc-anchor" href="#doc-cut">#</a> <code>cut</code></h3>
<p><code>cut</code> — bin continuous values into intervals. Returns integer bin indices. Like R's cut().</p>
<pre><code class="lang-perl">p cut([1.5, 3.2, 7.8], [0, 2, 5, 10]) # [1, 2, 3]
</code></pre>
</article>
<article class="doc-entry" id="doc-cutree">
<h3><a class="doc-anchor" href="#doc-cutree">#</a> <code>cutree</code></h3>
<p><code>cutree</code> — cut a dendrogram into k clusters. Takes merge list from hclust and k. Returns cluster assignments. Like R's cutree().</p>
<pre><code class="lang-perl">my @clusters = @{cutree(hclust(dist_mat($data)), 3)}
</code></pre>
</article>
<article class="doc-entry" id="doc-cutting-plane-step">
<h3><a class="doc-anchor" href="#doc-cutting-plane-step">#</a> <code>cutting_plane_step</code></h3>
<p><code>cutting_plane_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = cutting_plane_step $x
# or in a pipeline:
@list |> map cutting_plane_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cv">
<h3><a class="doc-anchor" href="#doc-cv">#</a> <code>cv</code></h3>
<p><code>cv</code> — math / numeric (uncategorized batch) builtin. Alias for <code>coeff_of_variation</code>.</p>
<pre><code class="lang-perl">my $result = cv $x
# or in a pipeline:
@list |> map cv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cv-monatomic-ideal">
<h3><a class="doc-anchor" href="#doc-cv-monatomic-ideal">#</a> <code>cv_monatomic_ideal</code></h3>
<p><code>cv_monatomic_ideal</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = cv_monatomic_ideal $x
# or in a pipeline:
@list |> map cv_monatomic_ideal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cvar-historical">
<h3><a class="doc-anchor" href="#doc-cvar-historical">#</a> <code>cvar_historical</code></h3>
<p><code>cvar_historical</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = cvar_historical $x
# or in a pipeline:
@list |> map cvar_historical |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cw">
<h3><a class="doc-anchor" href="#doc-cw">#</a> <code>cw</code></h3>
<p><code>cw</code> — data / network builtin. Alias for <code>csv_write</code>.</p>
<pre><code class="lang-perl">my $result = cw $x
# or in a pipeline:
@list |> map cw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cwd">
<h3><a class="doc-anchor" href="#doc-cwd">#</a> <code>cwd</code></h3>
<p><code>cwd</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = cwd $x
# or in a pipeline:
@list |> map cwd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cwt-morlet">
<h3><a class="doc-anchor" href="#doc-cwt-morlet">#</a> <code>cwt_morlet</code></h3>
<p><code>cwt_morlet</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = cwt_morlet $x
# or in a pipeline:
@list |> map cwt_morlet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cyan">
<h3><a class="doc-anchor" href="#doc-cyan">#</a> <code>cyan</code></h3>
<p><code>cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = cyan $x
# or in a pipeline:
@list |> map cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cyan-bold">
<h3><a class="doc-anchor" href="#doc-cyan-bold">#</a> <code>cyan_bold</code></h3>
<p><code>cyan_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = cyan_bold $x
# or in a pipeline:
@list |> map cyan_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-banner">
<h3><a class="doc-anchor" href="#doc-cyber-banner">#</a> <code>cyber_banner</code></h3>
<p><code>cyber_banner</code> (alias <code>neon_banner</code>) — large neon block-letter banner with gradient coloring and border. Args: text.</p>
<pre><code class="lang-perl">p cyber_banner("STRYKE")
p cyber_banner("HACK THE PLANET")
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-circuit">
<h3><a class="doc-anchor" href="#doc-cyber-circuit">#</a> <code>cyber_circuit</code></h3>
<p><code>cyber_circuit</code> — circuit board pattern with traces, intersections, and glowing nodes. Args: [width, height, seed].</p>
<pre><code class="lang-perl">p cyber_circuit() # 60x20 default
p cyber_circuit(80, 30, 42) # custom
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-city">
<h3><a class="doc-anchor" href="#doc-cyber-city">#</a> <code>cyber_city</code></h3>
<p><code>cyber_city</code> — procedural neon cityscape with buildings, windows, stars, and antennas. Args: [width, height, seed]. Output: ANSI-colored string for terminal.</p>
<pre><code class="lang-perl">p cyber_city() # 80x24 default
p cyber_city(120, 40, 99) # custom size and seed
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-eye">
<h3><a class="doc-anchor" href="#doc-cyber-eye">#</a> <code>cyber_eye</code></h3>
<p><code>cyber_eye</code> — cyberpunk all-seeing eye motif with layered glow. Args: [size]. Size: "small" (default) or "large".</p>
<pre><code class="lang-perl">p cyber_eye() # small eye
p cyber_eye("large") # large eye
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-glitch">
<h3><a class="doc-anchor" href="#doc-cyber-glitch">#</a> <code>cyber_glitch</code></h3>
<p><code>cyber_glitch</code> (alias <code>glitch_text</code>) — glitch-distort text with ANSI corruption, screen tears, and neon color bleeding. Args: text [, intensity 1-10].</p>
<pre><code class="lang-perl">p cyber_glitch("SYSTEM BREACH", 7)
p cyber_glitch("hello world")
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-grid">
<h3><a class="doc-anchor" href="#doc-cyber-grid">#</a> <code>cyber_grid</code></h3>
<p><code>cyber_grid</code> — retro perspective grid with vanishing point and neon glow (Tron/synthwave style). Args: [width, height].</p>
<pre><code class="lang-perl">p cyber_grid() # 80x24 default
p cyber_grid(120, 30) # wider grid
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-rain">
<h3><a class="doc-anchor" href="#doc-cyber-rain">#</a> <code>cyber_rain</code></h3>
<p><code>cyber_rain</code> (alias <code>matrix_rain</code>) — matrix-style digital rain with Japanese katakana and green phosphor glow. Args: [width, height, seed].</p>
<pre><code class="lang-perl">p cyber_rain() # 80x24 default
p cyber_rain(120, 40, 42) # custom
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-skull">
<h3><a class="doc-anchor" href="#doc-cyber-skull">#</a> <code>cyber_skull</code></h3>
<p><code>cyber_skull</code> — neon skull ASCII art with glitch effects. Args: [size]. Size: "small" (default) or "large".</p>
<pre><code class="lang-perl">p cyber_skull() # small skull
p cyber_skull("large") # large skull
</code></pre>
</article>
<article class="doc-entry" id="doc-cyc">
<h3><a class="doc-anchor" href="#doc-cyc">#</a> <code>cyc</code></h3>
<p><code>cyc</code> — algebraic match builtin. Alias for <code>cycle</code>.</p>
<pre><code class="lang-perl">my $result = cyc $x
# or in a pipeline:
@list |> map cyc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cycle">
<h3><a class="doc-anchor" href="#doc-cycle">#</a> <code>cycle</code></h3>
<p><code>cycle</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = cycle $x
# or in a pipeline:
@list |> map cycle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cycle-n">
<h3><a class="doc-anchor" href="#doc-cycle-n">#</a> <code>cycle_n</code></h3>
<p><code>cycle_n</code> — collection (batch 2) builtin. Alias for <code>repeat_list</code>.</p>
<pre><code class="lang-perl">my $result = cycle_n $x
# or in a pipeline:
@list |> map cycle_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cyclic-homology-step">
<h3><a class="doc-anchor" href="#doc-cyclic-homology-step">#</a> <code>cyclic_homology_step</code></h3>
<p><code>cyclic_homology_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = cyclic_homology_step $x
# or in a pipeline:
@list |> map cyclic_homology_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cylinder-surface">
<h3><a class="doc-anchor" href="#doc-cylinder-surface">#</a> <code>cylinder_surface</code></h3>
<p><code>cylinder_surface</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = cylinder_surface $x
# or in a pipeline:
@list |> map cylinder_surface |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cylinder-volume">
<h3><a class="doc-anchor" href="#doc-cylinder-volume">#</a> <code>cylinder_volume</code></h3>
<p><code>cylinder_volume</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = cylinder_volume $x
# or in a pipeline:
@list |> map cylinder_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cylvol">
<h3><a class="doc-anchor" href="#doc-cylvol">#</a> <code>cylvol</code></h3>
<p><code>cylvol</code> — geometry / physics builtin. Alias for <code>cylinder_volume</code>.</p>
<pre><code class="lang-perl">my $result = cylvol $x
# or in a pipeline:
@list |> map cylvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-d">
<h3><a class="doc-anchor" href="#doc-d">#</a> <code>d</code></h3>
<p><code>d</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = d $x
# or in a pipeline:
@list |> map d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-d2comp">
<h3><a class="doc-anchor" href="#doc-d2comp">#</a> <code>d2comp</code></h3>
<p><code>d2comp</code> — misc / utility builtin. Alias for <code>degrees_to_compass</code>.</p>
<pre><code class="lang-perl">my $result = d2comp $x
# or in a pipeline:
@list |> map d2comp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-d2r">
<h3><a class="doc-anchor" href="#doc-d2r">#</a> <code>d2r</code></h3>
<p><code>d2r</code> — trivial numeric / predicate builtins builtin. Alias for <code>deg_to_rad</code>.</p>
<pre><code class="lang-perl">my $result = d2r $x
# or in a pipeline:
@list |> map d2r |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-power">
<h3><a class="doc-anchor" href="#doc-db-power">#</a> <code>dB_power</code></h3>
<p><code>dB_power</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = dB_power $x
# or in a pipeline:
@list |> map dB_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-voltage">
<h3><a class="doc-anchor" href="#doc-db-voltage">#</a> <code>dB_voltage</code></h3>
<p><code>dB_voltage</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = dB_voltage $x
# or in a pipeline:
@list |> map dB_voltage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dagum-pdf">
<h3><a class="doc-anchor" href="#doc-dagum-pdf">#</a> <code>dagum_pdf</code></h3>
<p><code>dagum_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = dagum_pdf $x
# or in a pipeline:
@list |> map dagum_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-daitch-mokotoff">
<h3><a class="doc-anchor" href="#doc-daitch-mokotoff">#</a> <code>daitch_mokotoff</code></h3>
<p><code>daitch_mokotoff</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = daitch_mokotoff $x
# or in a pipeline:
@list |> map daitch_mokotoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dalys-disability-weight">
<h3><a class="doc-anchor" href="#doc-dalys-disability-weight">#</a> <code>dalys_disability_weight</code></h3>
<p><code>dalys_disability_weight</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = dalys_disability_weight $x
# or in a pipeline:
@list |> map dalys_disability_weight |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-damerau-levenshtein">
<h3><a class="doc-anchor" href="#doc-damerau-levenshtein">#</a> <code>damerau_levenshtein</code></h3>
<p><code>damerau_levenshtein</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = damerau_levenshtein $x
# or in a pipeline:
@list |> map damerau_levenshtein |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dantzig-wolfe-step">
<h3><a class="doc-anchor" href="#doc-dantzig-wolfe-step">#</a> <code>dantzig_wolfe_step</code></h3>
<p><code>dantzig_wolfe_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = dantzig_wolfe_step $x
# or in a pipeline:
@list |> map dantzig_wolfe_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-darboux-frame-step">
<h3><a class="doc-anchor" href="#doc-darboux-frame-step">#</a> <code>darboux_frame_step</code></h3>
<p><code>darboux_frame_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = darboux_frame_step $x
# or in a pipeline:
@list |> map darboux_frame_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dasum">
<h3><a class="doc-anchor" href="#doc-dasum">#</a> <code>dasum</code></h3>
<p><code>dasum</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dasum $x
# or in a pipeline:
@list |> map dasum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-data-processing-inequality">
<h3><a class="doc-anchor" href="#doc-data-processing-inequality">#</a> <code>data_processing_inequality</code></h3>
<p><code>data_processing_inequality</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = data_processing_inequality $x
# or in a pipeline:
@list |> map data_processing_inequality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-date-round-iso">
<h3><a class="doc-anchor" href="#doc-date-round-iso">#</a> <code>date_round_iso</code></h3>
<p><code>date_round_iso</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = date_round_iso $x
# or in a pipeline:
@list |> map date_round_iso |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dawsn">
<h3><a class="doc-anchor" href="#doc-dawsn">#</a> <code>dawsn</code></h3>
<p><code>dawsn</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = dawsn $x
# or in a pipeline:
@list |> map dawsn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dawson-function">
<h3><a class="doc-anchor" href="#doc-dawson-function">#</a> <code>dawson_function</code></h3>
<p><code>dawson_function</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = dawson_function $x
# or in a pipeline:
@list |> map dawson_function |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-daxpy">
<h3><a class="doc-anchor" href="#doc-daxpy">#</a> <code>daxpy</code></h3>
<p><code>daxpy</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = daxpy $x
# or in a pipeline:
@list |> map daxpy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-day-of-week-iso">
<h3><a class="doc-anchor" href="#doc-day-of-week-iso">#</a> <code>day_of_week_iso</code></h3>
<p><code>day_of_week_iso</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = day_of_week_iso $x
# or in a pipeline:
@list |> map day_of_week_iso |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-day-of-week-zeller">
<h3><a class="doc-anchor" href="#doc-day-of-week-zeller">#</a> <code>day_of_week_zeller</code></h3>
<p><code>day_of_week_zeller</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = day_of_week_zeller $x
# or in a pipeline:
@list |> map day_of_week_zeller |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-day-of-year">
<h3><a class="doc-anchor" href="#doc-day-of-year">#</a> <code>day_of_year</code></h3>
<p><code>day_of_year</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = day_of_year $x
# or in a pipeline:
@list |> map day_of_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-days-between">
<h3><a class="doc-anchor" href="#doc-days-between">#</a> <code>days_between</code></h3>
<p><code>days_between</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = days_between $x
# or in a pipeline:
@list |> map days_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-days-in-month">
<h3><a class="doc-anchor" href="#doc-days-in-month">#</a> <code>days_in_month</code></h3>
<p><code>days_in_month</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = days_in_month $x
# or in a pipeline:
@list |> map days_in_month |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-days-in-month-fn">
<h3><a class="doc-anchor" href="#doc-days-in-month-fn">#</a> <code>days_in_month_fn</code></h3>
<p><code>days_in_month_fn</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = days_in_month_fn $x
# or in a pipeline:
@list |> map days_in_month_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-days-in-year">
<h3><a class="doc-anchor" href="#doc-days-in-year">#</a> <code>days_in_year</code></h3>
<p><code>days_in_year</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = days_in_year $x
# or in a pipeline:
@list |> map days_in_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-days-to-hours">
<h3><a class="doc-anchor" href="#doc-days-to-hours">#</a> <code>days_to_hours</code></h3>
<p><code>days_to_hours</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = days_to_hours $input
</code></pre>
</article>
<article class="doc-entry" id="doc-days-to-seconds">
<h3><a class="doc-anchor" href="#doc-days-to-seconds">#</a> <code>days_to_seconds</code></h3>
<p><code>days_to_seconds</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = days_to_seconds $input
</code></pre>
</article>
<article class="doc-entry" id="doc-daysinmo">
<h3><a class="doc-anchor" href="#doc-daysinmo">#</a> <code>daysinmo</code></h3>
<p><code>daysinmo</code> — extended stdlib batch 3 builtin. Alias for <code>days_in_month_fn</code>.</p>
<pre><code class="lang-perl">my $result = daysinmo $x
# or in a pipeline:
@list |> map daysinmo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db">
<h3><a class="doc-anchor" href="#doc-db">#</a> <code>db</code></h3>
<p><code>db</code> — physics formulas builtin. Alias for <code>decibel_ratio</code>.</p>
<pre><code class="lang-perl">my $result = db $x
# or in a pipeline:
@list |> map db |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db4-coeffs">
<h3><a class="doc-anchor" href="#doc-db4-coeffs">#</a> <code>db4_coeffs</code></h3>
<p><code>db4_coeffs</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = db4_coeffs $x
# or in a pipeline:
@list |> map db4_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db4-wavelet-step">
<h3><a class="doc-anchor" href="#doc-db4-wavelet-step">#</a> <code>db4_wavelet_step</code></h3>
<p><code>db4_wavelet_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = db4_wavelet_step $x
# or in a pipeline:
@list |> map db4_wavelet_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db6-coeffs">
<h3><a class="doc-anchor" href="#doc-db6-coeffs">#</a> <code>db6_coeffs</code></h3>
<p><code>db6_coeffs</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = db6_coeffs $x
# or in a pipeline:
@list |> map db6_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-anti-entropy-pull-step">
<h3><a class="doc-anchor" href="#doc-db-anti-entropy-pull-step">#</a> <code>db_anti_entropy_pull_step</code></h3>
<p><code>db_anti_entropy_pull_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_anti_entropy_pull_step $x
# or in a pipeline:
@list |> map db_anti_entropy_pull_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-anti-entropy-step">
<h3><a class="doc-anchor" href="#doc-db-anti-entropy-step">#</a> <code>db_anti_entropy_step</code></h3>
<p><code>db_anti_entropy_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_anti_entropy_step $x
# or in a pipeline:
@list |> map db_anti_entropy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-arc-cache-score">
<h3><a class="doc-anchor" href="#doc-db-arc-cache-score">#</a> <code>db_arc_cache_score</code></h3>
<p><code>db_arc_cache_score</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_arc_cache_score $x
# or in a pipeline:
@list |> map db_arc_cache_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-async-commit-check">
<h3><a class="doc-anchor" href="#doc-db-async-commit-check">#</a> <code>db_async_commit_check</code></h3>
<p><code>db_async_commit_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_async_commit_check $x
# or in a pipeline:
@list |> map db_async_commit_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-avalanche-query-step">
<h3><a class="doc-anchor" href="#doc-db-avalanche-query-step">#</a> <code>db_avalanche_query_step</code></h3>
<p><code>db_avalanche_query_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_avalanche_query_step $x
# or in a pipeline:
@list |> map db_avalanche_query_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-b-tree-merge">
<h3><a class="doc-anchor" href="#doc-db-b-tree-merge">#</a> <code>db_b_tree_merge</code></h3>
<p><code>db_b_tree_merge</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_b_tree_merge $x
# or in a pipeline:
@list |> map db_b_tree_merge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-b-tree-split">
<h3><a class="doc-anchor" href="#doc-db-b-tree-split">#</a> <code>db_b_tree_split</code></h3>
<p><code>db_b_tree_split</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_b_tree_split $x
# or in a pipeline:
@list |> map db_b_tree_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-block-cache-hit-rate">
<h3><a class="doc-anchor" href="#doc-db-block-cache-hit-rate">#</a> <code>db_block_cache_hit_rate</code></h3>
<p><code>db_block_cache_hit_rate</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_block_cache_hit_rate $x
# or in a pipeline:
@list |> map db_block_cache_hit_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-bloom-filter-bit-index">
<h3><a class="doc-anchor" href="#doc-db-bloom-filter-bit-index">#</a> <code>db_bloom_filter_bit_index</code></h3>
<p><code>db_bloom_filter_bit_index</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_bloom_filter_bit_index $x
# or in a pipeline:
@list |> map db_bloom_filter_bit_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-buffer-pool-score">
<h3><a class="doc-anchor" href="#doc-db-buffer-pool-score">#</a> <code>db_buffer_pool_score</code></h3>
<p><code>db_buffer_pool_score</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_buffer_pool_score $x
# or in a pipeline:
@list |> map db_buffer_pool_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-byzantine-quorum-size">
<h3><a class="doc-anchor" href="#doc-db-byzantine-quorum-size">#</a> <code>db_byzantine_quorum_size</code></h3>
<p><code>db_byzantine_quorum_size</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_byzantine_quorum_size $x
# or in a pipeline:
@list |> map db_byzantine_quorum_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-causal-consistency-check">
<h3><a class="doc-anchor" href="#doc-db-causal-consistency-check">#</a> <code>db_causal_consistency_check</code></h3>
<p><code>db_causal_consistency_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_causal_consistency_check $x
# or in a pipeline:
@list |> map db_causal_consistency_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-chao-estimator-step">
<h3><a class="doc-anchor" href="#doc-db-chao-estimator-step">#</a> <code>db_chao_estimator_step</code></h3>
<p><code>db_chao_estimator_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_chao_estimator_step $x
# or in a pipeline:
@list |> map db_chao_estimator_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-chord-finger-index">
<h3><a class="doc-anchor" href="#doc-db-chord-finger-index">#</a> <code>db_chord_finger_index</code></h3>
<p><code>db_chord_finger_index</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_chord_finger_index $x
# or in a pipeline:
@list |> map db_chord_finger_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-chubby-lease-step">
<h3><a class="doc-anchor" href="#doc-db-chubby-lease-step">#</a> <code>db_chubby_lease_step</code></h3>
<p><code>db_chubby_lease_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_chubby_lease_step $x
# or in a pipeline:
@list |> map db_chubby_lease_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-circuit-breaker-step">
<h3><a class="doc-anchor" href="#doc-db-circuit-breaker-step">#</a> <code>db_circuit_breaker_step</code></h3>
<p><code>db_circuit_breaker_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_circuit_breaker_step $x
# or in a pipeline:
@list |> map db_circuit_breaker_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-clock-cache-hand">
<h3><a class="doc-anchor" href="#doc-db-clock-cache-hand">#</a> <code>db_clock_cache_hand</code></h3>
<p><code>db_clock_cache_hand</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_clock_cache_hand $x
# or in a pipeline:
@list |> map db_clock_cache_hand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-clock-skew-estimate">
<h3><a class="doc-anchor" href="#doc-db-clock-skew-estimate">#</a> <code>db_clock_skew_estimate</code></h3>
<p><code>db_clock_skew_estimate</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_clock_skew_estimate $x
# or in a pipeline:
@list |> map db_clock_skew_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-compaction-score">
<h3><a class="doc-anchor" href="#doc-db-compaction-score">#</a> <code>db_compaction_score</code></h3>
<p><code>db_compaction_score</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_compaction_score $x
# or in a pipeline:
@list |> map db_compaction_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-consensus-quorum-size">
<h3><a class="doc-anchor" href="#doc-db-consensus-quorum-size">#</a> <code>db_consensus_quorum_size</code></h3>
<p><code>db_consensus_quorum_size</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_consensus_quorum_size $x
# or in a pipeline:
@list |> map db_consensus_quorum_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-consistent-hash-index">
<h3><a class="doc-anchor" href="#doc-db-consistent-hash-index">#</a> <code>db_consistent_hash_index</code></h3>
<p><code>db_consistent_hash_index</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_consistent_hash_index $x
# or in a pipeline:
@list |> map db_consistent_hash_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-consistent-lookup-id">
<h3><a class="doc-anchor" href="#doc-db-consistent-lookup-id">#</a> <code>db_consistent_lookup_id</code></h3>
<p><code>db_consistent_lookup_id</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_consistent_lookup_id $x
# or in a pipeline:
@list |> map db_consistent_lookup_id |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-count-min-sketch-bin">
<h3><a class="doc-anchor" href="#doc-db-count-min-sketch-bin">#</a> <code>db_count_min_sketch_bin</code></h3>
<p><code>db_count_min_sketch_bin</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_count_min_sketch_bin $x
# or in a pipeline:
@list |> map db_count_min_sketch_bin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-crdt-g-counter-merge">
<h3><a class="doc-anchor" href="#doc-db-crdt-g-counter-merge">#</a> <code>db_crdt_g_counter_merge</code></h3>
<p><code>db_crdt_g_counter_merge</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_crdt_g_counter_merge $x
# or in a pipeline:
@list |> map db_crdt_g_counter_merge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-crdt-lww-register-merge">
<h3><a class="doc-anchor" href="#doc-db-crdt-lww-register-merge">#</a> <code>db_crdt_lww_register_merge</code></h3>
<p><code>db_crdt_lww_register_merge</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_crdt_lww_register_merge $x
# or in a pipeline:
@list |> map db_crdt_lww_register_merge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-crdt-pn-counter-merge">
<h3><a class="doc-anchor" href="#doc-db-crdt-pn-counter-merge">#</a> <code>db_crdt_pn_counter_merge</code></h3>
<p><code>db_crdt_pn_counter_merge</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_crdt_pn_counter_merge $x
# or in a pipeline:
@list |> map db_crdt_pn_counter_merge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-crdt-set-or-merge">
<h3><a class="doc-anchor" href="#doc-db-crdt-set-or-merge">#</a> <code>db_crdt_set_or_merge</code></h3>
<p><code>db_crdt_set_or_merge</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_crdt_set_or_merge $x
# or in a pipeline:
@list |> map db_crdt_set_or_merge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-cuckoo-filter-fingerprint">
<h3><a class="doc-anchor" href="#doc-db-cuckoo-filter-fingerprint">#</a> <code>db_cuckoo_filter_fingerprint</code></h3>
<p><code>db_cuckoo_filter_fingerprint</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_cuckoo_filter_fingerprint $x
# or in a pipeline:
@list |> map db_cuckoo_filter_fingerprint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-dd-sketch-bin">
<h3><a class="doc-anchor" href="#doc-db-dd-sketch-bin">#</a> <code>db_dd_sketch_bin</code></h3>
<p><code>db_dd_sketch_bin</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_dd_sketch_bin $x
# or in a pipeline:
@list |> map db_dd_sketch_bin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-dht-replicate-factor">
<h3><a class="doc-anchor" href="#doc-db-dht-replicate-factor">#</a> <code>db_dht_replicate_factor</code></h3>
<p><code>db_dht_replicate_factor</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_dht_replicate_factor $x
# or in a pipeline:
@list |> map db_dht_replicate_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-distinct-estimate-hll">
<h3><a class="doc-anchor" href="#doc-db-distinct-estimate-hll">#</a> <code>db_distinct_estimate_hll</code></h3>
<p><code>db_distinct_estimate_hll</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_distinct_estimate_hll $x
# or in a pipeline:
@list |> map db_distinct_estimate_hll |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-distinct-estimate-lpc">
<h3><a class="doc-anchor" href="#doc-db-distinct-estimate-lpc">#</a> <code>db_distinct_estimate_lpc</code></h3>
<p><code>db_distinct_estimate_lpc</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_distinct_estimate_lpc $x
# or in a pipeline:
@list |> map db_distinct_estimate_lpc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-eventual-consistency-check">
<h3><a class="doc-anchor" href="#doc-db-eventual-consistency-check">#</a> <code>db_eventual_consistency_check</code></h3>
<p><code>db_eventual_consistency_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_eventual_consistency_check $x
# or in a pipeline:
@list |> map db_eventual_consistency_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-freshness-score">
<h3><a class="doc-anchor" href="#doc-db-freshness-score">#</a> <code>db_freshness_score</code></h3>
<p><code>db_freshness_score</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_freshness_score $x
# or in a pipeline:
@list |> map db_freshness_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-gossip-fanout-step">
<h3><a class="doc-anchor" href="#doc-db-gossip-fanout-step">#</a> <code>db_gossip_fanout_step</code></h3>
<p><code>db_gossip_fanout_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_gossip_fanout_step $x
# or in a pipeline:
@list |> map db_gossip_fanout_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-group-commit-count">
<h3><a class="doc-anchor" href="#doc-db-group-commit-count">#</a> <code>db_group_commit_count</code></h3>
<p><code>db_group_commit_count</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_group_commit_count $x
# or in a pipeline:
@list |> map db_group_commit_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-hash-join-cost">
<h3><a class="doc-anchor" href="#doc-db-hash-join-cost">#</a> <code>db_hash_join_cost</code></h3>
<p><code>db_hash_join_cost</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_hash_join_cost $x
# or in a pipeline:
@list |> map db_hash_join_cost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-hinted-handoff-step">
<h3><a class="doc-anchor" href="#doc-db-hinted-handoff-step">#</a> <code>db_hinted_handoff_step</code></h3>
<p><code>db_hinted_handoff_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_hinted_handoff_step $x
# or in a pipeline:
@list |> map db_hinted_handoff_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-histogram-bucket-index">
<h3><a class="doc-anchor" href="#doc-db-histogram-bucket-index">#</a> <code>db_histogram_bucket_index</code></h3>
<p><code>db_histogram_bucket_index</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_histogram_bucket_index $x
# or in a pipeline:
@list |> map db_histogram_bucket_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-honey-badger-step">
<h3><a class="doc-anchor" href="#doc-db-honey-badger-step">#</a> <code>db_honey_badger_step</code></h3>
<p><code>db_honey_badger_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_honey_badger_step $x
# or in a pipeline:
@list |> map db_honey_badger_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-hybrid-logical-clock">
<h3><a class="doc-anchor" href="#doc-db-hybrid-logical-clock">#</a> <code>db_hybrid_logical_clock</code></h3>
<p><code>db_hybrid_logical_clock</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_hybrid_logical_clock $x
# or in a pipeline:
@list |> map db_hybrid_logical_clock |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-hyperloglog-register-max">
<h3><a class="doc-anchor" href="#doc-db-hyperloglog-register-max">#</a> <code>db_hyperloglog_register_max</code></h3>
<p><code>db_hyperloglog_register_max</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_hyperloglog_register_max $x
# or in a pipeline:
@list |> map db_hyperloglog_register_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-index-scan-cost">
<h3><a class="doc-anchor" href="#doc-db-index-scan-cost">#</a> <code>db_index_scan_cost</code></h3>
<p><code>db_index_scan_cost</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_index_scan_cost $x
# or in a pipeline:
@list |> map db_index_scan_cost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-index-seek-cost">
<h3><a class="doc-anchor" href="#doc-db-index-seek-cost">#</a> <code>db_index_seek_cost</code></h3>
<p><code>db_index_seek_cost</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_index_seek_cost $x
# or in a pipeline:
@list |> map db_index_seek_cost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-jaccard-minhash-estimate">
<h3><a class="doc-anchor" href="#doc-db-jaccard-minhash-estimate">#</a> <code>db_jaccard_minhash_estimate</code></h3>
<p><code>db_jaccard_minhash_estimate</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_jaccard_minhash_estimate $x
# or in a pipeline:
@list |> map db_jaccard_minhash_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-join-selectivity-step">
<h3><a class="doc-anchor" href="#doc-db-join-selectivity-step">#</a> <code>db_join_selectivity_step</code></h3>
<p><code>db_join_selectivity_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_join_selectivity_step $x
# or in a pipeline:
@list |> map db_join_selectivity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-jump-hash-bucket">
<h3><a class="doc-anchor" href="#doc-db-jump-hash-bucket">#</a> <code>db_jump_hash_bucket</code></h3>
<p><code>db_jump_hash_bucket</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_jump_hash_bucket $x
# or in a pipeline:
@list |> map db_jump_hash_bucket |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-kademlia-xor-distance">
<h3><a class="doc-anchor" href="#doc-db-kademlia-xor-distance">#</a> <code>db_kademlia_xor_distance</code></h3>
<p><code>db_kademlia_xor_distance</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_kademlia_xor_distance $x
# or in a pipeline:
@list |> map db_kademlia_xor_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-kll-quantile-step">
<h3><a class="doc-anchor" href="#doc-db-kll-quantile-step">#</a> <code>db_kll_quantile_step</code></h3>
<p><code>db_kll_quantile_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_kll_quantile_step $x
# or in a pipeline:
@list |> map db_kll_quantile_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-lamport-timestamp">
<h3><a class="doc-anchor" href="#doc-db-lamport-timestamp">#</a> <code>db_lamport_timestamp</code></h3>
<p><code>db_lamport_timestamp</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_lamport_timestamp $x
# or in a pipeline:
@list |> map db_lamport_timestamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-leaky-bucket-step">
<h3><a class="doc-anchor" href="#doc-db-leaky-bucket-step">#</a> <code>db_leaky_bucket_step</code></h3>
<p><code>db_leaky_bucket_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_leaky_bucket_step $x
# or in a pipeline:
@list |> map db_leaky_bucket_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-levelled-compaction-step">
<h3><a class="doc-anchor" href="#doc-db-levelled-compaction-step">#</a> <code>db_levelled_compaction_step</code></h3>
<p><code>db_levelled_compaction_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_levelled_compaction_step $x
# or in a pipeline:
@list |> map db_levelled_compaction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-lfu-cache-decay">
<h3><a class="doc-anchor" href="#doc-db-lfu-cache-decay">#</a> <code>db_lfu_cache_decay</code></h3>
<p><code>db_lfu_cache_decay</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_lfu_cache_decay $x
# or in a pipeline:
@list |> map db_lfu_cache_decay |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-linearizability-check">
<h3><a class="doc-anchor" href="#doc-db-linearizability-check">#</a> <code>db_linearizability_check</code></h3>
<p><code>db_linearizability_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_linearizability_check $x
# or in a pipeline:
@list |> map db_linearizability_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-logical-clock-step">
<h3><a class="doc-anchor" href="#doc-db-logical-clock-step">#</a> <code>db_logical_clock_step</code></h3>
<p><code>db_logical_clock_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_logical_clock_step $x
# or in a pipeline:
@list |> map db_logical_clock_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-lru-cache-eviction-age">
<h3><a class="doc-anchor" href="#doc-db-lru-cache-eviction-age">#</a> <code>db_lru_cache_eviction_age</code></h3>
<p><code>db_lru_cache_eviction_age</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_lru_cache_eviction_age $x
# or in a pipeline:
@list |> map db_lru_cache_eviction_age |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-lsm-compaction-step">
<h3><a class="doc-anchor" href="#doc-db-lsm-compaction-step">#</a> <code>db_lsm_compaction_step</code></h3>
<p><code>db_lsm_compaction_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_lsm_compaction_step $x
# or in a pipeline:
@list |> map db_lsm_compaction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-maglev-hash-step">
<h3><a class="doc-anchor" href="#doc-db-maglev-hash-step">#</a> <code>db_maglev_hash_step</code></h3>
<p><code>db_maglev_hash_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_maglev_hash_step $x
# or in a pipeline:
@list |> map db_maglev_hash_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-merge-join-cost">
<h3><a class="doc-anchor" href="#doc-db-merge-join-cost">#</a> <code>db_merge_join_cost</code></h3>
<p><code>db_merge_join_cost</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_merge_join_cost $x
# or in a pipeline:
@list |> map db_merge_join_cost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-merkle-node-hash">
<h3><a class="doc-anchor" href="#doc-db-merkle-node-hash">#</a> <code>db_merkle_node_hash</code></h3>
<p><code>db_merkle_node_hash</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_merkle_node_hash $x
# or in a pipeline:
@list |> map db_merkle_node_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-merkle-path-verify">
<h3><a class="doc-anchor" href="#doc-db-merkle-path-verify">#</a> <code>db_merkle_path_verify</code></h3>
<p><code>db_merkle_path_verify</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_merkle_path_verify $x
# or in a pipeline:
@list |> map db_merkle_path_verify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-min-hash-value">
<h3><a class="doc-anchor" href="#doc-db-min-hash-value">#</a> <code>db_min_hash_value</code></h3>
<p><code>db_min_hash_value</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_min_hash_value $x
# or in a pipeline:
@list |> map db_min_hash_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-nested-loop-cost">
<h3><a class="doc-anchor" href="#doc-db-nested-loop-cost">#</a> <code>db_nested_loop_cost</code></h3>
<p><code>db_nested_loop_cost</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_nested_loop_cost $x
# or in a pipeline:
@list |> map db_nested_loop_cost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-page-cache-eviction-age">
<h3><a class="doc-anchor" href="#doc-db-page-cache-eviction-age">#</a> <code>db_page_cache_eviction_age</code></h3>
<p><code>db_page_cache_eviction_age</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_page_cache_eviction_age $x
# or in a pipeline:
@list |> map db_page_cache_eviction_age |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-partition-failure-check">
<h3><a class="doc-anchor" href="#doc-db-partition-failure-check">#</a> <code>db_partition_failure_check</code></h3>
<p><code>db_partition_failure_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_partition_failure_check $x
# or in a pipeline:
@list |> map db_partition_failure_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-partitions-for-n">
<h3><a class="doc-anchor" href="#doc-db-partitions-for-n">#</a> <code>db_partitions_for_n</code></h3>
<p><code>db_partitions_for_n</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_partitions_for_n $x
# or in a pipeline:
@list |> map db_partitions_for_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-pastry-routing-step">
<h3><a class="doc-anchor" href="#doc-db-pastry-routing-step">#</a> <code>db_pastry_routing_step</code></h3>
<p><code>db_pastry_routing_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_pastry_routing_step $x
# or in a pipeline:
@list |> map db_pastry_routing_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-paxos-propose-id">
<h3><a class="doc-anchor" href="#doc-db-paxos-propose-id">#</a> <code>db_paxos_propose_id</code></h3>
<p><code>db_paxos_propose_id</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_paxos_propose_id $x
# or in a pipeline:
@list |> map db_paxos_propose_id |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-pbft-view-change">
<h3><a class="doc-anchor" href="#doc-db-pbft-view-change">#</a> <code>db_pbft_view_change</code></h3>
<p><code>db_pbft_view_change</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_pbft_view_change $x
# or in a pipeline:
@list |> map db_pbft_view_change |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-power">
<h3><a class="doc-anchor" href="#doc-db-power">#</a> <code>db_power</code></h3>
<p><code>db_power</code> — batch 12 builtin. Alias for <code>dB_power</code>.</p>
<pre><code class="lang-perl">my $result = db_power $x
# or in a pipeline:
@list |> map db_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-quantile-estimate-p99">
<h3><a class="doc-anchor" href="#doc-db-quantile-estimate-p99">#</a> <code>db_quantile_estimate_p99</code></h3>
<p><code>db_quantile_estimate_p99</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_quantile_estimate_p99 $x
# or in a pipeline:
@list |> map db_quantile_estimate_p99 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-query-cardinality">
<h3><a class="doc-anchor" href="#doc-db-query-cardinality">#</a> <code>db_query_cardinality</code></h3>
<p><code>db_query_cardinality</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_query_cardinality $x
# or in a pipeline:
@list |> map db_query_cardinality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-query-plan-cost-step">
<h3><a class="doc-anchor" href="#doc-db-query-plan-cost-step">#</a> <code>db_query_plan_cost_step</code></h3>
<p><code>db_query_plan_cost_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_query_plan_cost_step $x
# or in a pipeline:
@list |> map db_query_plan_cost_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-quorum-intersection-check">
<h3><a class="doc-anchor" href="#doc-db-quorum-intersection-check">#</a> <code>db_quorum_intersection_check</code></h3>
<p><code>db_quorum_intersection_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_quorum_intersection_check $x
# or in a pipeline:
@list |> map db_quorum_intersection_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-quotient-filter-canonical">
<h3><a class="doc-anchor" href="#doc-db-quotient-filter-canonical">#</a> <code>db_quotient_filter_canonical</code></h3>
<p><code>db_quotient_filter_canonical</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_quotient_filter_canonical $x
# or in a pipeline:
@list |> map db_quotient_filter_canonical |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-raft-log-match-check">
<h3><a class="doc-anchor" href="#doc-db-raft-log-match-check">#</a> <code>db_raft_log_match_check</code></h3>
<p><code>db_raft_log_match_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_raft_log_match_check $x
# or in a pipeline:
@list |> map db_raft_log_match_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-raft-term-advance">
<h3><a class="doc-anchor" href="#doc-db-raft-term-advance">#</a> <code>db_raft_term_advance</code></h3>
<p><code>db_raft_term_advance</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_raft_term_advance $x
# or in a pipeline:
@list |> map db_raft_term_advance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-read-amplification">
<h3><a class="doc-anchor" href="#doc-db-read-amplification">#</a> <code>db_read_amplification</code></h3>
<p><code>db_read_amplification</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_read_amplification $x
# or in a pipeline:
@list |> map db_read_amplification |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-read-repair-step">
<h3><a class="doc-anchor" href="#doc-db-read-repair-step">#</a> <code>db_read_repair_step</code></h3>
<p><code>db_read_repair_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_read_repair_step $x
# or in a pipeline:
@list |> map db_read_repair_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-rendezvous-hash-score">
<h3><a class="doc-anchor" href="#doc-db-rendezvous-hash-score">#</a> <code>db_rendezvous_hash_score</code></h3>
<p><code>db_rendezvous_hash_score</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_rendezvous_hash_score $x
# or in a pipeline:
@list |> map db_rendezvous_hash_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-replica-lag-threshold">
<h3><a class="doc-anchor" href="#doc-db-replica-lag-threshold">#</a> <code>db_replica_lag_threshold</code></h3>
<p><code>db_replica_lag_threshold</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_replica_lag_threshold $x
# or in a pipeline:
@list |> map db_replica_lag_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-replication-lag-step">
<h3><a class="doc-anchor" href="#doc-db-replication-lag-step">#</a> <code>db_replication_lag_step</code></h3>
<p><code>db_replication_lag_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_replication_lag_step $x
# or in a pipeline:
@list |> map db_replication_lag_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-reservoir-sample-index">
<h3><a class="doc-anchor" href="#doc-db-reservoir-sample-index">#</a> <code>db_reservoir_sample_index</code></h3>
<p><code>db_reservoir_sample_index</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_reservoir_sample_index $x
# or in a pipeline:
@list |> map db_reservoir_sample_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-seq-scan-cost">
<h3><a class="doc-anchor" href="#doc-db-seq-scan-cost">#</a> <code>db_seq_scan_cost</code></h3>
<p><code>db_seq_scan_cost</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_seq_scan_cost $x
# or in a pipeline:
@list |> map db_seq_scan_cost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-simhash-bit">
<h3><a class="doc-anchor" href="#doc-db-simhash-bit">#</a> <code>db_simhash_bit</code></h3>
<p><code>db_simhash_bit</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_simhash_bit $x
# or in a pipeline:
@list |> map db_simhash_bit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-size-tiered-compaction">
<h3><a class="doc-anchor" href="#doc-db-size-tiered-compaction">#</a> <code>db_size_tiered_compaction</code></h3>
<p><code>db_size_tiered_compaction</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_size_tiered_compaction $x
# or in a pipeline:
@list |> map db_size_tiered_compaction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-skiplist-height-pick">
<h3><a class="doc-anchor" href="#doc-db-skiplist-height-pick">#</a> <code>db_skiplist_height_pick</code></h3>
<p><code>db_skiplist_height_pick</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_skiplist_height_pick $x
# or in a pipeline:
@list |> map db_skiplist_height_pick |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-sort-cost-estimate">
<h3><a class="doc-anchor" href="#doc-db-sort-cost-estimate">#</a> <code>db_sort_cost_estimate</code></h3>
<p><code>db_sort_cost_estimate</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_sort_cost_estimate $x
# or in a pipeline:
@list |> map db_sort_cost_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-space-amplification">
<h3><a class="doc-anchor" href="#doc-db-space-amplification">#</a> <code>db_space_amplification</code></h3>
<p><code>db_space_amplification</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_space_amplification $x
# or in a pipeline:
@list |> map db_space_amplification |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-split-brain-check">
<h3><a class="doc-anchor" href="#doc-db-split-brain-check">#</a> <code>db_split_brain_check</code></h3>
<p><code>db_split_brain_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_split_brain_check $x
# or in a pipeline:
@list |> map db_split_brain_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-strong-consistency-check">
<h3><a class="doc-anchor" href="#doc-db-strong-consistency-check">#</a> <code>db_strong_consistency_check</code></h3>
<p><code>db_strong_consistency_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_strong_consistency_check $x
# or in a pipeline:
@list |> map db_strong_consistency_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-synchronous-commit-check">
<h3><a class="doc-anchor" href="#doc-db-synchronous-commit-check">#</a> <code>db_synchronous_commit_check</code></h3>
<p><code>db_synchronous_commit_check</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_synchronous_commit_check $x
# or in a pipeline:
@list |> map db_synchronous_commit_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-t-digest-centroid">
<h3><a class="doc-anchor" href="#doc-db-t-digest-centroid">#</a> <code>db_t_digest_centroid</code></h3>
<p><code>db_t_digest_centroid</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_t_digest_centroid $x
# or in a pipeline:
@list |> map db_t_digest_centroid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-three-phase-commit-step">
<h3><a class="doc-anchor" href="#doc-db-three-phase-commit-step">#</a> <code>db_three_phase_commit_step</code></h3>
<p><code>db_three_phase_commit_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_three_phase_commit_step $x
# or in a pipeline:
@list |> map db_three_phase_commit_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-throttle-token-step">
<h3><a class="doc-anchor" href="#doc-db-throttle-token-step">#</a> <code>db_throttle_token_step</code></h3>
<p><code>db_throttle_token_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_throttle_token_step $x
# or in a pipeline:
@list |> map db_throttle_token_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-tinylfu-admit-score">
<h3><a class="doc-anchor" href="#doc-db-tinylfu-admit-score">#</a> <code>db_tinylfu_admit_score</code></h3>
<p><code>db_tinylfu_admit_score</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_tinylfu_admit_score $x
# or in a pipeline:
@list |> map db_tinylfu_admit_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-to-amp">
<h3><a class="doc-anchor" href="#doc-db-to-amp">#</a> <code>db_to_amp</code></h3>
<p><code>db_to_amp</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = db_to_amp $input
</code></pre>
</article>
<article class="doc-entry" id="doc-db-token-bucket-step">
<h3><a class="doc-anchor" href="#doc-db-token-bucket-step">#</a> <code>db_token_bucket_step</code></h3>
<p><code>db_token_bucket_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_token_bucket_step $x
# or in a pipeline:
@list |> map db_token_bucket_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-two-phase-commit-step">
<h3><a class="doc-anchor" href="#doc-db-two-phase-commit-step">#</a> <code>db_two_phase_commit_step</code></h3>
<p><code>db_two_phase_commit_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_two_phase_commit_step $x
# or in a pipeline:
@list |> map db_two_phase_commit_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-universal-compaction-step">
<h3><a class="doc-anchor" href="#doc-db-universal-compaction-step">#</a> <code>db_universal_compaction_step</code></h3>
<p><code>db_universal_compaction_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_universal_compaction_step $x
# or in a pipeline:
@list |> map db_universal_compaction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-vector-clock-merge">
<h3><a class="doc-anchor" href="#doc-db-vector-clock-merge">#</a> <code>db_vector_clock_merge</code></h3>
<p><code>db_vector_clock_merge</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_vector_clock_merge $x
# or in a pipeline:
@list |> map db_vector_clock_merge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-voltage">
<h3><a class="doc-anchor" href="#doc-db-voltage">#</a> <code>db_voltage</code></h3>
<p><code>db_voltage</code> — batch 12 builtin. Alias for <code>dB_voltage</code>.</p>
<pre><code class="lang-perl">my $result = db_voltage $x
# or in a pipeline:
@list |> map db_voltage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-w-tinylfu-freq">
<h3><a class="doc-anchor" href="#doc-db-w-tinylfu-freq">#</a> <code>db_w_tinylfu_freq</code></h3>
<p><code>db_w_tinylfu_freq</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_w_tinylfu_freq $x
# or in a pipeline:
@list |> map db_w_tinylfu_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-wal-fsync-cost">
<h3><a class="doc-anchor" href="#doc-db-wal-fsync-cost">#</a> <code>db_wal_fsync_cost</code></h3>
<p><code>db_wal_fsync_cost</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_wal_fsync_cost $x
# or in a pipeline:
@list |> map db_wal_fsync_cost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-write-amplification">
<h3><a class="doc-anchor" href="#doc-db-write-amplification">#</a> <code>db_write_amplification</code></h3>
<p><code>db_write_amplification</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_write_amplification $x
# or in a pipeline:
@list |> map db_write_amplification |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db-zab-epoch-step">
<h3><a class="doc-anchor" href="#doc-db-zab-epoch-step">#</a> <code>db_zab_epoch_step</code></h3>
<p><code>db_zab_epoch_step</code> — batch 48 builtin.</p>
<pre><code class="lang-perl">my $result = db_zab_epoch_step $x
# or in a pipeline:
@list |> map db_zab_epoch_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dbinom">
<h3><a class="doc-anchor" href="#doc-dbinom">#</a> <code>dbinom</code></h3>
<p><code>dbinom</code> — binomial PMF. P(X = k) for Binom(n, p). Args: k, n, p.</p>
<pre><code class="lang-perl">p dbinom(5, 10, 0.5) # P(exactly 5 heads in 10 flips)
</code></pre>
</article>
<article class="doc-entry" id="doc-dbmclose">
<h3><a class="doc-anchor" href="#doc-dbmclose">#</a> <code>dbmclose</code></h3>
<p><code>dbmclose</code> — ipc builtin.</p>
<pre><code class="lang-perl">my $result = dbmclose $x
# or in a pipeline:
@list |> map dbmclose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dbmopen">
<h3><a class="doc-anchor" href="#doc-dbmopen">#</a> <code>dbmopen</code></h3>
<p><code>dbmopen</code> — ipc builtin.</p>
<pre><code class="lang-perl">my $result = dbmopen $x
# or in a pipeline:
@list |> map dbmopen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dbsize">
<h3><a class="doc-anchor" href="#doc-dbsize">#</a> <code>dbsize</code></h3>
<p><code>dbsize</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = dbsize $x
# or in a pipeline:
@list |> map dbsize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dchisq">
<h3><a class="doc-anchor" href="#doc-dchisq">#</a> <code>dchisq</code></h3>
<p><code>dchisq</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = dchisq $x
# or in a pipeline:
@list |> map dchisq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dct">
<h3><a class="doc-anchor" href="#doc-dct">#</a> <code>dct</code></h3>
<p><code>dct</code> computes the Type-II Discrete Cosine Transform of a signal. Used in JPEG, MP3, and speech processing.</p>
<pre><code class="lang-perl">my @coeffs = @{dct([1,2,3,4])}
</code></pre>
</article>
<article class="doc-entry" id="doc-dde-euler-step">
<h3><a class="doc-anchor" href="#doc-dde-euler-step">#</a> <code>dde_euler_step</code></h3>
<p><code>dde_euler_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = dde_euler_step $x
# or in a pipeline:
@list |> map dde_euler_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ddot">
<h3><a class="doc-anchor" href="#doc-ddot">#</a> <code>ddot</code></h3>
<p><code>ddot</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = ddot $x
# or in a pipeline:
@list |> map ddot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ddpg-critic-loss-step">
<h3><a class="doc-anchor" href="#doc-ddpg-critic-loss-step">#</a> <code>ddpg_critic_loss_step</code></h3>
<p><code>ddpg_critic_loss_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = ddpg_critic_loss_step $x
# or in a pipeline:
@list |> map ddpg_critic_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ddrot">
<h3><a class="doc-anchor" href="#doc-ddrot">#</a> <code>ddrot</code></h3>
<p><code>ddrot</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = ddrot $x
# or in a pipeline:
@list |> map ddrot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ddt">
<h3><a class="doc-anchor" href="#doc-ddt">#</a> <code>ddt</code></h3>
<p><code>ddt</code> — extended stdlib builtin. Alias for <code>dedent</code>.</p>
<pre><code class="lang-perl">my $result = ddt $x
# or in a pipeline:
@list |> map ddt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-de-broglie">
<h3><a class="doc-anchor" href="#doc-de-broglie">#</a> <code>de_broglie</code></h3>
<p><code>de_broglie</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = de_broglie $x
# or in a pipeline:
@list |> map de_broglie |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-de-broglie-wavelength">
<h3><a class="doc-anchor" href="#doc-de-broglie-wavelength">#</a> <code>de_broglie_wavelength</code></h3>
<p><code>de_broglie_wavelength($mass, $velocity)</code> (alias <code>debroglie</code>) — quantum wavelength λ = h/(mv). Defaults to electron mass.</p>
<pre><code class="lang-perl">p debroglie(9.109e-31, 1e6) # ~7.3e-10 m (electron at 1 km/s)
</code></pre>
</article>
<article class="doc-entry" id="doc-de-broglie-wavelength-kg">
<h3><a class="doc-anchor" href="#doc-de-broglie-wavelength-kg">#</a> <code>de_broglie_wavelength_kg</code></h3>
<p><code>de_broglie_wavelength_kg</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = de_broglie_wavelength_kg $x
# or in a pipeline:
@list |> map de_broglie_wavelength_kg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-de-rham-zero">
<h3><a class="doc-anchor" href="#doc-de-rham-zero">#</a> <code>de_rham_zero</code></h3>
<p><code>de_rham_zero</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = de_rham_zero $x
# or in a pipeline:
@list |> map de_rham_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-de-sitter-metric-step">
<h3><a class="doc-anchor" href="#doc-de-sitter-metric-step">#</a> <code>de_sitter_metric_step</code></h3>
<p><code>de_sitter_metric_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = de_sitter_metric_step $x
# or in a pipeline:
@list |> map de_sitter_metric_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-de-sitter-radius-step">
<h3><a class="doc-anchor" href="#doc-de-sitter-radius-step">#</a> <code>de_sitter_radius_step</code></h3>
<p><code>de_sitter_radius_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = de_sitter_radius_step $x
# or in a pipeline:
@list |> map de_sitter_radius_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deadweight-loss">
<h3><a class="doc-anchor" href="#doc-deadweight-loss">#</a> <code>deadweight_loss</code></h3>
<p><code>deadweight_loss</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = deadweight_loss $x
# or in a pipeline:
@list |> map deadweight_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deal-n-k">
<h3><a class="doc-anchor" href="#doc-deal-n-k">#</a> <code>deal_n_k</code></h3>
<p><code>deal_n_k</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = deal_n_k $x
# or in a pipeline:
@list |> map deal_n_k |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-debug-object">
<h3><a class="doc-anchor" href="#doc-debug-object">#</a> <code>debug_object</code></h3>
<p><code>debug_object</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = debug_object $x
# or in a pipeline:
@list |> map debug_object |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-debug-val">
<h3><a class="doc-anchor" href="#doc-debug-val">#</a> <code>debug_val</code></h3>
<p><code>debug_val</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = debug_val $x
# or in a pipeline:
@list |> map debug_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-debye-huckel">
<h3><a class="doc-anchor" href="#doc-debye-huckel">#</a> <code>debye_huckel</code></h3>
<p><code>debye_huckel</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = debye_huckel $x
# or in a pipeline:
@list |> map debye_huckel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-debye-huckel-activity">
<h3><a class="doc-anchor" href="#doc-debye-huckel-activity">#</a> <code>debye_huckel_activity</code></h3>
<p><code>debye_huckel_activity</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = debye_huckel_activity $x
# or in a pipeline:
@list |> map debye_huckel_activity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-debye-huckel-screening-factor">
<h3><a class="doc-anchor" href="#doc-debye-huckel-screening-factor">#</a> <code>debye_huckel_screening_factor</code></h3>
<p><code>debye_huckel_screening_factor</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = debye_huckel_screening_factor $x
# or in a pipeline:
@list |> map debye_huckel_screening_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-debye-length-electrolyte">
<h3><a class="doc-anchor" href="#doc-debye-length-electrolyte">#</a> <code>debye_length_electrolyte</code></h3>
<p><code>debye_length_electrolyte</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = debye_length_electrolyte $x
# or in a pipeline:
@list |> map debye_length_electrolyte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dec">
<h3><a class="doc-anchor" href="#doc-dec">#</a> <code>dec</code></h3>
<p><code>dec</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = dec $x
# or in a pipeline:
@list |> map dec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dec-each">
<h3><a class="doc-anchor" href="#doc-dec-each">#</a> <code>dec_each</code></h3>
<p><code>dec_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = dec_each $x
# or in a pipeline:
@list |> map dec_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deceleration-q">
<h3><a class="doc-anchor" href="#doc-deceleration-q">#</a> <code>deceleration_q</code></h3>
<p><code>deceleration_q</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = deceleration_q $x
# or in a pipeline:
@list |> map deceleration_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-decibel-ratio">
<h3><a class="doc-anchor" href="#doc-decibel-ratio">#</a> <code>decibel_ratio</code></h3>
<p><code>decibel_ratio</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = decibel_ratio $x
# or in a pipeline:
@list |> map decibel_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-decimate-step">
<h3><a class="doc-anchor" href="#doc-decimate-step">#</a> <code>decimate_step</code></h3>
<p><code>decimate_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = decimate_step $x
# or in a pipeline:
@list |> map decimate_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-decode-base">
<h3><a class="doc-anchor" href="#doc-decode-base">#</a> <code>decode_base</code></h3>
<p><code>decode_base</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = decode_base $x
# or in a pipeline:
@list |> map decode_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-decoherence-time">
<h3><a class="doc-anchor" href="#doc-decoherence-time">#</a> <code>decoherence_time</code></h3>
<p><code>decoherence_time</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = decoherence_time $x
# or in a pipeline:
@list |> map decoherence_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deconvolve-step">
<h3><a class="doc-anchor" href="#doc-deconvolve-step">#</a> <code>deconvolve_step</code></h3>
<p><code>deconvolve_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = deconvolve_step $x
# or in a pipeline:
@list |> map deconvolve_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-decr">
<h3><a class="doc-anchor" href="#doc-decr">#</a> <code>decr</code></h3>
<p><code>decr</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = decr $x
# or in a pipeline:
@list |> map decr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-decrby">
<h3><a class="doc-anchor" href="#doc-decrby">#</a> <code>decrby</code></h3>
<p><code>decrby</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = decrby $x
# or in a pipeline:
@list |> map decrby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dedent">
<h3><a class="doc-anchor" href="#doc-dedent">#</a> <code>dedent</code></h3>
<p><code>dedent</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dedent $x
# or in a pipeline:
@list |> map dedent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dedent-text">
<h3><a class="doc-anchor" href="#doc-dedent-text">#</a> <code>dedent_text</code></h3>
<p><code>dedent_text</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = dedent_text $x
# or in a pipeline:
@list |> map dedent_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deep-q-target">
<h3><a class="doc-anchor" href="#doc-deep-q-target">#</a> <code>deep_q_target</code></h3>
<p><code>deep_q_target</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = deep_q_target $x
# or in a pipeline:
@list |> map deep_q_target |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-default-to">
<h3><a class="doc-anchor" href="#doc-default-to">#</a> <code>default_to</code></h3>
<p><code>default_to</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = default_to $x
# or in a pipeline:
@list |> map default_to |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-defaultdict">
<h3><a class="doc-anchor" href="#doc-defaultdict">#</a> <code>defaultdict</code></h3>
<p><code>defaultdict</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = defaultdict $x
# or in a pipeline:
@list |> map defaultdict |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deferred-acceptance">
<h3><a class="doc-anchor" href="#doc-deferred-acceptance">#</a> <code>deferred_acceptance</code></h3>
<p><code>deferred_acceptance</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = deferred_acceptance $x
# or in a pipeline:
@list |> map deferred_acceptance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deferred-acceptance-step">
<h3><a class="doc-anchor" href="#doc-deferred-acceptance-step">#</a> <code>deferred_acceptance_step</code></h3>
<p><code>deferred_acceptance_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = deferred_acceptance_step $x
# or in a pipeline:
@list |> map deferred_acceptance_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deficient-numbers">
<h3><a class="doc-anchor" href="#doc-deficient-numbers">#</a> <code>deficient_numbers</code></h3>
<p><code>deficient_numbers</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = deficient_numbers $x
# or in a pipeline:
@list |> map deficient_numbers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-defined-count">
<h3><a class="doc-anchor" href="#doc-defined-count">#</a> <code>defined_count</code></h3>
<p><code>defined_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = defined_count $x
# or in a pipeline:
@list |> map defined_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-definums">
<h3><a class="doc-anchor" href="#doc-definums">#</a> <code>definums</code></h3>
<p><code>definums</code> — number theory / primes builtin. Alias for <code>deficient_numbers</code>.</p>
<pre><code class="lang-perl">my $result = definums $x
# or in a pipeline:
@list |> map definums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deflate-dynamic-huffman">
<h3><a class="doc-anchor" href="#doc-deflate-dynamic-huffman">#</a> <code>deflate_dynamic_huffman</code></h3>
<p><code>deflate_dynamic_huffman</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = deflate_dynamic_huffman $x
# or in a pipeline:
@list |> map deflate_dynamic_huffman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deflate-encode-huffman">
<h3><a class="doc-anchor" href="#doc-deflate-encode-huffman">#</a> <code>deflate_encode_huffman</code></h3>
<p><code>deflate_encode_huffman</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = deflate_encode_huffman $x
# or in a pipeline:
@list |> map deflate_encode_huffman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deflate-huffman-lit">
<h3><a class="doc-anchor" href="#doc-deflate-huffman-lit">#</a> <code>deflate_huffman_lit</code></h3>
<p><code>deflate_huffman_lit</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = deflate_huffman_lit $x
# or in a pipeline:
@list |> map deflate_huffman_lit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deflate-static-block">
<h3><a class="doc-anchor" href="#doc-deflate-static-block">#</a> <code>deflate_static_block</code></h3>
<p><code>deflate_static_block</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = deflate_static_block $x
# or in a pipeline:
@list |> map deflate_static_block |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deg-to-rad">
<h3><a class="doc-anchor" href="#doc-deg-to-rad">#</a> <code>deg_to_rad</code></h3>
<p><code>deg_to_rad</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = deg_to_rad $input
</code></pre>
</article>
<article class="doc-entry" id="doc-degrees">
<h3><a class="doc-anchor" href="#doc-degrees">#</a> <code>degrees</code></h3>
<p><code>degrees</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = degrees $x
# or in a pipeline:
@list |> map degrees |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-degrees-to-compass">
<h3><a class="doc-anchor" href="#doc-degrees-to-compass">#</a> <code>degrees_to_compass</code></h3>
<p><code>degrees_to_compass</code> — misc / utility builtin.</p>
<pre><code class="lang-perl">my $result = degrees_to_compass $input
</code></pre>
</article>
<article class="doc-entry" id="doc-dela">
<h3><a class="doc-anchor" href="#doc-dela">#</a> <code>dela</code></h3>
<p><code>dela</code> — go/general functional utilities builtin. Alias for <code>delete_at</code>.</p>
<pre><code class="lang-perl">my $result = dela $x
# or in a pipeline:
@list |> map dela |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delby">
<h3><a class="doc-anchor" href="#doc-delby">#</a> <code>delby</code></h3>
<p><code>delby</code> — additional missing stdlib functions builtin. Alias for <code>delete_by</code>.</p>
<pre><code class="lang-perl">my $result = delby $x
# or in a pipeline:
@list |> map delby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delete-at">
<h3><a class="doc-anchor" href="#doc-delete-at">#</a> <code>delete_at</code></h3>
<p><code>delete_at</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = delete_at $x
# or in a pipeline:
@list |> map delete_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delete-by">
<h3><a class="doc-anchor" href="#doc-delete-by">#</a> <code>delete_by</code></h3>
<p><code>delete_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = delete_by $x
# or in a pipeline:
@list |> map delete_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delete-first">
<h3><a class="doc-anchor" href="#doc-delete-first">#</a> <code>delete_first</code></h3>
<p><code>delete_first</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = delete_first $x
# or in a pipeline:
@list |> map delete_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delfst">
<h3><a class="doc-anchor" href="#doc-delfst">#</a> <code>delfst</code></h3>
<p><code>delfst</code> — additional missing stdlib functions builtin. Alias for <code>delete_first</code>.</p>
<pre><code class="lang-perl">my $result = delfst $x
# or in a pipeline:
@list |> map delfst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delta-complex-count">
<h3><a class="doc-anchor" href="#doc-delta-complex-count">#</a> <code>delta_complex_count</code></h3>
<p><code>delta_complex_count</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = delta_complex_count $x
# or in a pipeline:
@list |> map delta_complex_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delta-e">
<h3><a class="doc-anchor" href="#doc-delta-e">#</a> <code>delta_e</code></h3>
<p><code>delta_e</code> — batch 9 builtin. Alias for <code>delta_e_76</code>.</p>
<pre><code class="lang-perl">my $result = delta_e $x
# or in a pipeline:
@list |> map delta_e |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delta-e2000">
<h3><a class="doc-anchor" href="#doc-delta-e2000">#</a> <code>delta_e2000</code></h3>
<p><code>delta_e2000</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = delta_e2000 $x
# or in a pipeline:
@list |> map delta_e2000 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delta-e76">
<h3><a class="doc-anchor" href="#doc-delta-e76">#</a> <code>delta_e76</code></h3>
<p><code>delta_e76</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = delta_e76 $x
# or in a pipeline:
@list |> map delta_e76 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delta-e94">
<h3><a class="doc-anchor" href="#doc-delta-e94">#</a> <code>delta_e94</code></h3>
<p><code>delta_e94</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = delta_e94 $x
# or in a pipeline:
@list |> map delta_e94 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delta-e-76">
<h3><a class="doc-anchor" href="#doc-delta-e-76">#</a> <code>delta_e_76</code></h3>
<p><code>delta_e_76</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = delta_e_76 $x
# or in a pipeline:
@list |> map delta_e_76 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delta-e-94">
<h3><a class="doc-anchor" href="#doc-delta-e-94">#</a> <code>delta_e_94</code></h3>
<p><code>delta_e_94</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = delta_e_94 $x
# or in a pipeline:
@list |> map delta_e_94 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-demorse">
<h3><a class="doc-anchor" href="#doc-demorse">#</a> <code>demorse</code></h3>
<p><code>demorse</code> — encoding / phonetics builtin. Alias for <code>morse_decode</code>.</p>
<pre><code class="lang-perl">my $result = demorse $x
# or in a pipeline:
@list |> map demorse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-denavit-hartenberg-h">
<h3><a class="doc-anchor" href="#doc-denavit-hartenberg-h">#</a> <code>denavit_hartenberg_h</code></h3>
<p><code>denavit_hartenberg_h</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = denavit_hartenberg_h $x
# or in a pipeline:
@list |> map denavit_hartenberg_h |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dense-rank">
<h3><a class="doc-anchor" href="#doc-dense-rank">#</a> <code>dense_rank</code></h3>
<p><code>dense_rank</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dense_rank $x
# or in a pipeline:
@list |> map dense_rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-density">
<h3><a class="doc-anchor" href="#doc-density">#</a> <code>density</code></h3>
<p><code>density</code> — kernel density estimation with Gaussian kernel and Silverman bandwidth. Returns [[x_grid], [density_values]]. Like R's density().</p>
<pre><code class="lang-perl">my ($x, $y) = @{density([1,2,2,3,3,3,4,4,5])}
# $x is grid of 512 points, $y is estimated density
</code></pre>
</article>
<article class="doc-entry" id="doc-density-altitude-full">
<h3><a class="doc-anchor" href="#doc-density-altitude-full">#</a> <code>density_altitude_full</code></h3>
<p><code>density_altitude_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = density_altitude_full $x
# or in a pipeline:
@list |> map density_altitude_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-density-altitude-m">
<h3><a class="doc-anchor" href="#doc-density-altitude-m">#</a> <code>density_altitude_m</code></h3>
<p><code>density_altitude_m</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = density_altitude_m $x
# or in a pipeline:
@list |> map density_altitude_m |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-density-matrix-purity-q">
<h3><a class="doc-anchor" href="#doc-density-matrix-purity-q">#</a> <code>density_matrix_purity_q</code></h3>
<p><code>density_matrix_purity_q</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = density_matrix_purity_q $x
# or in a pipeline:
@list |> map density_matrix_purity_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-depdbl">
<h3><a class="doc-anchor" href="#doc-depdbl">#</a> <code>depdbl</code></h3>
<p><code>depdbl</code> — math / numeric (uncategorized batch) builtin. Alias for <code>depreciation_double</code>.</p>
<pre><code class="lang-perl">my $result = depdbl $x
# or in a pipeline:
@list |> map depdbl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dependency-parse-eisner">
<h3><a class="doc-anchor" href="#doc-dependency-parse-eisner">#</a> <code>dependency_parse_eisner</code></h3>
<p><code>dependency_parse_eisner</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = dependency_parse_eisner $x
# or in a pipeline:
@list |> map dependency_parse_eisner |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dephasing-channel">
<h3><a class="doc-anchor" href="#doc-dephasing-channel">#</a> <code>dephasing_channel</code></h3>
<p><code>dephasing_channel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = dephasing_channel $x
# or in a pipeline:
@list |> map dephasing_channel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deplin">
<h3><a class="doc-anchor" href="#doc-deplin">#</a> <code>deplin</code></h3>
<p><code>deplin</code> — math / numeric (uncategorized batch) builtin. Alias for <code>depreciation_linear</code>.</p>
<pre><code class="lang-perl">my $result = deplin $x
# or in a pipeline:
@list |> map deplin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-depolarizing-channel">
<h3><a class="doc-anchor" href="#doc-depolarizing-channel">#</a> <code>depolarizing_channel</code></h3>
<p><code>depolarizing_channel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = depolarizing_channel $x
# or in a pipeline:
@list |> map depolarizing_channel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-depolarizing-density-2x2">
<h3><a class="doc-anchor" href="#doc-depolarizing-density-2x2">#</a> <code>depolarizing_density_2x2</code></h3>
<p><code>depolarizing_density_2x2</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = depolarizing_density_2x2 $x
# or in a pipeline:
@list |> map depolarizing_density_2x2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-depreciation-double">
<h3><a class="doc-anchor" href="#doc-depreciation-double">#</a> <code>depreciation_double</code></h3>
<p><code>depreciation_double</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = depreciation_double $x
# or in a pipeline:
@list |> map depreciation_double |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-depreciation-linear">
<h3><a class="doc-anchor" href="#doc-depreciation-linear">#</a> <code>depreciation_linear</code></h3>
<p><code>depreciation_linear</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = depreciation_linear $x
# or in a pipeline:
@list |> map depreciation_linear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-derangements">
<h3><a class="doc-anchor" href="#doc-derangements">#</a> <code>derangements</code></h3>
<p><code>derangements</code> counts the number of derangements (subfactorial !n) — permutations with no fixed points.</p>
<pre><code class="lang-perl">p derangements(4) # 9
p derangements(5) # 44
</code></pre>
</article>
<article class="doc-entry" id="doc-deroman">
<h3><a class="doc-anchor" href="#doc-deroman">#</a> <code>deroman</code></h3>
<p><code>deroman</code> — roman numerals builtin. Alias for <code>roman_to_int</code>.</p>
<pre><code class="lang-perl">my $result = deroman $x
# or in a pipeline:
@list |> map deroman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-describe">
<h3><a class="doc-anchor" href="#doc-describe">#</a> <code>describe</code></h3>
<p><code>describe(@data)</code> — returns a hashref with comprehensive descriptive statistics: count, mean, std, min, 25%, 50%, 75%, max. Similar to pandas DataFrame.describe().</p>
<pre><code class="lang-perl">my $stats = describe(1:100)
p $stats->{mean} # 50.5
p $stats->{std} # ~29.0
p $stats->{"50%"} # median
</code></pre>
</article>
<article class="doc-entry" id="doc-destination-point">
<h3><a class="doc-anchor" href="#doc-destination-point">#</a> <code>destination_point</code></h3>
<p><code>destination_point</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = destination_point $x
# or in a pipeline:
@list |> map destination_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-det">
<h3><a class="doc-anchor" href="#doc-det">#</a> <code>det</code></h3>
<p><code>matrix_det_general</code> (aliases <code>mdetg</code>, <code>det</code>) computes the determinant of any NxN matrix via LU decomposition.</p>
<pre><code class="lang-perl">p det([[1,2,3],[4,5,6],[7,8,0]]) # 27
</code></pre>
</article>
<article class="doc-entry" id="doc-detect">
<h3><a class="doc-anchor" href="#doc-detect">#</a> <code>detect</code></h3>
<p><code>detect</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = detect $x
# or in a pipeline:
@list |> map detect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deterministic-prime">
<h3><a class="doc-anchor" href="#doc-deterministic-prime">#</a> <code>deterministic_prime</code></h3>
<p><code>deterministic_prime</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = deterministic_prime $x
# or in a pipeline:
@list |> map deterministic_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-detrend-linear">
<h3><a class="doc-anchor" href="#doc-detrend-linear">#</a> <code>detrend_linear</code></h3>
<p><code>detrend_linear</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = detrend_linear $x
# or in a pipeline:
@list |> map detrend_linear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-detrended-fluct-alpha">
<h3><a class="doc-anchor" href="#doc-detrended-fluct-alpha">#</a> <code>detrended_fluct_alpha</code></h3>
<p><code>detrended_fluct_alpha</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = detrended_fluct_alpha $x
# or in a pipeline:
@list |> map detrended_fluct_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dew-point">
<h3><a class="doc-anchor" href="#doc-dew-point">#</a> <code>dew_point</code></h3>
<p><code>dew_point</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = dew_point $x
# or in a pipeline:
@list |> map dew_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dew-point-magnus">
<h3><a class="doc-anchor" href="#doc-dew-point-magnus">#</a> <code>dew_point_magnus</code></h3>
<p><code>dew_point_magnus</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = dew_point_magnus $x
# or in a pipeline:
@list |> map dew_point_magnus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dewpoint-temperature-full">
<h3><a class="doc-anchor" href="#doc-dewpoint-temperature-full">#</a> <code>dewpoint_temperature_full</code></h3>
<p><code>dewpoint_temperature_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = dewpoint_temperature_full $x
# or in a pipeline:
@list |> map dewpoint_temperature_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df">
<h3><a class="doc-anchor" href="#doc-df">#</a> <code>df</code></h3>
<p><code>df</code> — data / network builtin. Alias for <code>dataframe</code>.</p>
<pre><code class="lang-perl">my $result = df $x
# or in a pipeline:
@list |> map df |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-aggregate">
<h3><a class="doc-anchor" href="#doc-df-aggregate">#</a> <code>df_aggregate</code></h3>
<p><code>df_aggregate</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_aggregate $x
# or in a pipeline:
@list |> map df_aggregate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-apply">
<h3><a class="doc-anchor" href="#doc-df-apply">#</a> <code>df_apply</code></h3>
<p><code>df_apply</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_apply $x
# or in a pipeline:
@list |> map df_apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-clip">
<h3><a class="doc-anchor" href="#doc-df-clip">#</a> <code>df_clip</code></h3>
<p><code>df_clip</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_clip $x
# or in a pipeline:
@list |> map df_clip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-concat">
<h3><a class="doc-anchor" href="#doc-df-concat">#</a> <code>df_concat</code></h3>
<p><code>df_concat</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_concat $x
# or in a pipeline:
@list |> map df_concat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-corr">
<h3><a class="doc-anchor" href="#doc-df-corr">#</a> <code>df_corr</code></h3>
<p><code>df_corr</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_corr $x
# or in a pipeline:
@list |> map df_corr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-corrwith">
<h3><a class="doc-anchor" href="#doc-df-corrwith">#</a> <code>df_corrwith</code></h3>
<p><code>df_corrwith</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_corrwith $x
# or in a pipeline:
@list |> map df_corrwith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-cov">
<h3><a class="doc-anchor" href="#doc-df-cov">#</a> <code>df_cov</code></h3>
<p><code>df_cov</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_cov $x
# or in a pipeline:
@list |> map df_cov |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-crosstab">
<h3><a class="doc-anchor" href="#doc-df-crosstab">#</a> <code>df_crosstab</code></h3>
<p><code>df_crosstab</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_crosstab $x
# or in a pipeline:
@list |> map df_crosstab |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-describe">
<h3><a class="doc-anchor" href="#doc-df-describe">#</a> <code>df_describe</code></h3>
<p><code>df_describe</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_describe $x
# or in a pipeline:
@list |> map df_describe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-diff">
<h3><a class="doc-anchor" href="#doc-df-diff">#</a> <code>df_diff</code></h3>
<p><code>df_diff</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_diff $x
# or in a pipeline:
@list |> map df_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-dist">
<h3><a class="doc-anchor" href="#doc-df-dist">#</a> <code>df_dist</code></h3>
<p><code>df_dist</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = df_dist $x
# or in a pipeline:
@list |> map df_dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-drop-duplicates">
<h3><a class="doc-anchor" href="#doc-df-drop-duplicates">#</a> <code>df_drop_duplicates</code></h3>
<p><code>df_drop_duplicates</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_drop_duplicates $x
# or in a pipeline:
@list |> map df_drop_duplicates |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-dropna">
<h3><a class="doc-anchor" href="#doc-df-dropna">#</a> <code>df_dropna</code></h3>
<p><code>df_dropna</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_dropna $x
# or in a pipeline:
@list |> map df_dropna |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-duplicated">
<h3><a class="doc-anchor" href="#doc-df-duplicated">#</a> <code>df_duplicated</code></h3>
<p><code>df_duplicated</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_duplicated $x
# or in a pipeline:
@list |> map df_duplicated |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-eval">
<h3><a class="doc-anchor" href="#doc-df-eval">#</a> <code>df_eval</code></h3>
<p><code>df_eval</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_eval $x
# or in a pipeline:
@list |> map df_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-ewm">
<h3><a class="doc-anchor" href="#doc-df-ewm">#</a> <code>df_ewm</code></h3>
<p><code>df_ewm</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_ewm $x
# or in a pipeline:
@list |> map df_ewm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-expanding">
<h3><a class="doc-anchor" href="#doc-df-expanding">#</a> <code>df_expanding</code></h3>
<p><code>df_expanding</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_expanding $x
# or in a pipeline:
@list |> map df_expanding |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-explode">
<h3><a class="doc-anchor" href="#doc-df-explode">#</a> <code>df_explode</code></h3>
<p><code>df_explode</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_explode $x
# or in a pipeline:
@list |> map df_explode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-fillna">
<h3><a class="doc-anchor" href="#doc-df-fillna">#</a> <code>df_fillna</code></h3>
<p><code>df_fillna</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_fillna $x
# or in a pipeline:
@list |> map df_fillna |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-filter">
<h3><a class="doc-anchor" href="#doc-df-filter">#</a> <code>df_filter</code></h3>
<p><code>df_filter</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_filter $x
# or in a pipeline:
@list |> map df_filter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-get-dummies">
<h3><a class="doc-anchor" href="#doc-df-get-dummies">#</a> <code>df_get_dummies</code></h3>
<p><code>df_get_dummies</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_get_dummies $x
# or in a pipeline:
@list |> map df_get_dummies |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-groupby">
<h3><a class="doc-anchor" href="#doc-df-groupby">#</a> <code>df_groupby</code></h3>
<p><code>df_groupby</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_groupby $x
# or in a pipeline:
@list |> map df_groupby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-idxmax">
<h3><a class="doc-anchor" href="#doc-df-idxmax">#</a> <code>df_idxmax</code></h3>
<p><code>df_idxmax</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_idxmax $x
# or in a pipeline:
@list |> map df_idxmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-idxmin">
<h3><a class="doc-anchor" href="#doc-df-idxmin">#</a> <code>df_idxmin</code></h3>
<p><code>df_idxmin</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_idxmin $x
# or in a pipeline:
@list |> map df_idxmin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-interpolate">
<h3><a class="doc-anchor" href="#doc-df-interpolate">#</a> <code>df_interpolate</code></h3>
<p><code>df_interpolate</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_interpolate $x
# or in a pipeline:
@list |> map df_interpolate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-isnull">
<h3><a class="doc-anchor" href="#doc-df-isnull">#</a> <code>df_isnull</code></h3>
<p><code>df_isnull</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_isnull $x
# or in a pipeline:
@list |> map df_isnull |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-join">
<h3><a class="doc-anchor" href="#doc-df-join">#</a> <code>df_join</code></h3>
<p><code>df_join</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_join $x
# or in a pipeline:
@list |> map df_join |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-kurtosis">
<h3><a class="doc-anchor" href="#doc-df-kurtosis">#</a> <code>df_kurtosis</code></h3>
<p><code>df_kurtosis</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_kurtosis $x
# or in a pipeline:
@list |> map df_kurtosis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-mad">
<h3><a class="doc-anchor" href="#doc-df-mad">#</a> <code>df_mad</code></h3>
<p><code>df_mad</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_mad $x
# or in a pipeline:
@list |> map df_mad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-melt">
<h3><a class="doc-anchor" href="#doc-df-melt">#</a> <code>df_melt</code></h3>
<p><code>df_melt</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_melt $x
# or in a pipeline:
@list |> map df_melt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-merge">
<h3><a class="doc-anchor" href="#doc-df-merge">#</a> <code>df_merge</code></h3>
<p><code>df_merge</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_merge $x
# or in a pipeline:
@list |> map df_merge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-nlargest">
<h3><a class="doc-anchor" href="#doc-df-nlargest">#</a> <code>df_nlargest</code></h3>
<p><code>df_nlargest</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_nlargest $x
# or in a pipeline:
@list |> map df_nlargest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-notnull">
<h3><a class="doc-anchor" href="#doc-df-notnull">#</a> <code>df_notnull</code></h3>
<p><code>df_notnull</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_notnull $x
# or in a pipeline:
@list |> map df_notnull |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-nsmallest">
<h3><a class="doc-anchor" href="#doc-df-nsmallest">#</a> <code>df_nsmallest</code></h3>
<p><code>df_nsmallest</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_nsmallest $x
# or in a pipeline:
@list |> map df_nsmallest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-pct-change">
<h3><a class="doc-anchor" href="#doc-df-pct-change">#</a> <code>df_pct_change</code></h3>
<p><code>df_pct_change</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_pct_change $x
# or in a pipeline:
@list |> map df_pct_change |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-pivot">
<h3><a class="doc-anchor" href="#doc-df-pivot">#</a> <code>df_pivot</code></h3>
<p><code>df_pivot</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_pivot $x
# or in a pipeline:
@list |> map df_pivot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-pivot-table">
<h3><a class="doc-anchor" href="#doc-df-pivot-table">#</a> <code>df_pivot_table</code></h3>
<p><code>df_pivot_table</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_pivot_table $x
# or in a pipeline:
@list |> map df_pivot_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-quantile">
<h3><a class="doc-anchor" href="#doc-df-quantile">#</a> <code>df_quantile</code></h3>
<p><code>df_quantile</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_quantile $x
# or in a pipeline:
@list |> map df_quantile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-query">
<h3><a class="doc-anchor" href="#doc-df-query">#</a> <code>df_query</code></h3>
<p><code>df_query</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_query $x
# or in a pipeline:
@list |> map df_query |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-rank">
<h3><a class="doc-anchor" href="#doc-df-rank">#</a> <code>df_rank</code></h3>
<p><code>df_rank</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_rank $x
# or in a pipeline:
@list |> map df_rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-replace">
<h3><a class="doc-anchor" href="#doc-df-replace">#</a> <code>df_replace</code></h3>
<p><code>df_replace</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_replace $x
# or in a pipeline:
@list |> map df_replace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-resample">
<h3><a class="doc-anchor" href="#doc-df-resample">#</a> <code>df_resample</code></h3>
<p><code>df_resample</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_resample $x
# or in a pipeline:
@list |> map df_resample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-reset-index">
<h3><a class="doc-anchor" href="#doc-df-reset-index">#</a> <code>df_reset_index</code></h3>
<p><code>df_reset_index</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_reset_index $x
# or in a pipeline:
@list |> map df_reset_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-rolling">
<h3><a class="doc-anchor" href="#doc-df-rolling">#</a> <code>df_rolling</code></h3>
<p><code>df_rolling</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_rolling $x
# or in a pipeline:
@list |> map df_rolling |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-round">
<h3><a class="doc-anchor" href="#doc-df-round">#</a> <code>df_round</code></h3>
<p><code>df_round</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_round $x
# or in a pipeline:
@list |> map df_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-sample">
<h3><a class="doc-anchor" href="#doc-df-sample">#</a> <code>df_sample</code></h3>
<p><code>df_sample</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_sample $x
# or in a pipeline:
@list |> map df_sample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-sem">
<h3><a class="doc-anchor" href="#doc-df-sem">#</a> <code>df_sem</code></h3>
<p><code>df_sem</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_sem $x
# or in a pipeline:
@list |> map df_sem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-set-index">
<h3><a class="doc-anchor" href="#doc-df-set-index">#</a> <code>df_set_index</code></h3>
<p><code>df_set_index</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_set_index $x
# or in a pipeline:
@list |> map df_set_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-shift">
<h3><a class="doc-anchor" href="#doc-df-shift">#</a> <code>df_shift</code></h3>
<p><code>df_shift</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_shift $x
# or in a pipeline:
@list |> map df_shift |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-skew">
<h3><a class="doc-anchor" href="#doc-df-skew">#</a> <code>df_skew</code></h3>
<p><code>df_skew</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_skew $x
# or in a pipeline:
@list |> map df_skew |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-sort-values">
<h3><a class="doc-anchor" href="#doc-df-sort-values">#</a> <code>df_sort_values</code></h3>
<p><code>df_sort_values</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_sort_values $x
# or in a pipeline:
@list |> map df_sort_values |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-stack">
<h3><a class="doc-anchor" href="#doc-df-stack">#</a> <code>df_stack</code></h3>
<p><code>df_stack</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_stack $x
# or in a pipeline:
@list |> map df_stack |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-to-datetime">
<h3><a class="doc-anchor" href="#doc-df-to-datetime">#</a> <code>df_to_datetime</code></h3>
<p><code>df_to_datetime</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_to_datetime $input
</code></pre>
</article>
<article class="doc-entry" id="doc-df-to-numeric">
<h3><a class="doc-anchor" href="#doc-df-to-numeric">#</a> <code>df_to_numeric</code></h3>
<p><code>df_to_numeric</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_to_numeric $input
</code></pre>
</article>
<article class="doc-entry" id="doc-df-to-timedelta">
<h3><a class="doc-anchor" href="#doc-df-to-timedelta">#</a> <code>df_to_timedelta</code></h3>
<p><code>df_to_timedelta</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_to_timedelta $input
</code></pre>
</article>
<article class="doc-entry" id="doc-df-transform">
<h3><a class="doc-anchor" href="#doc-df-transform">#</a> <code>df_transform</code></h3>
<p><code>df_transform</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_transform $x
# or in a pipeline:
@list |> map df_transform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-unstack">
<h3><a class="doc-anchor" href="#doc-df-unstack">#</a> <code>df_unstack</code></h3>
<p><code>df_unstack</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_unstack $x
# or in a pipeline:
@list |> map df_unstack |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df-value-counts">
<h3><a class="doc-anchor" href="#doc-df-value-counts">#</a> <code>df_value_counts</code></h3>
<p><code>df_value_counts</code> — batch 76 builtin.</p>
<pre><code class="lang-perl">my $result = df_value_counts $x
# or in a pipeline:
@list |> map df_value_counts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfa-minimize-hopcroft">
<h3><a class="doc-anchor" href="#doc-dfa-minimize-hopcroft">#</a> <code>dfa_minimize_hopcroft</code></h3>
<p><code>dfa_minimize_hopcroft</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = dfa_minimize_hopcroft $x
# or in a pipeline:
@list |> map dfa_minimize_hopcroft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfa-simulate-step">
<h3><a class="doc-anchor" href="#doc-dfa-simulate-step">#</a> <code>dfa_simulate_step</code></h3>
<p><code>dfa_simulate_step</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = dfa_simulate_step $x
# or in a pipeline:
@list |> map dfa_simulate_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfact">
<h3><a class="doc-anchor" href="#doc-dfact">#</a> <code>dfact</code></h3>
<p><code>dfact</code> — math formulas builtin. Alias for <code>double_factorial</code>.</p>
<pre><code class="lang-perl">my $result = dfact $x
# or in a pipeline:
@list |> map dfact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfs">
<h3><a class="doc-anchor" href="#doc-dfs">#</a> <code>dfs</code></h3>
<p><code>dfs</code> — extended stdlib builtin. Alias for <code>dfs_traverse</code>.</p>
<pre><code class="lang-perl">my $result = dfs $x
# or in a pipeline:
@list |> map dfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfs-postorder-done">
<h3><a class="doc-anchor" href="#doc-dfs-postorder-done">#</a> <code>dfs_postorder_done</code></h3>
<p><code>dfs_postorder_done</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = dfs_postorder_done $x
# or in a pipeline:
@list |> map dfs_postorder_done |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfs-preorder">
<h3><a class="doc-anchor" href="#doc-dfs-preorder">#</a> <code>dfs_preorder</code></h3>
<p><code>dfs_preorder</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = dfs_preorder $x
# or in a pipeline:
@list |> map dfs_preorder |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfs-traverse">
<h3><a class="doc-anchor" href="#doc-dfs-traverse">#</a> <code>dfs_traverse</code></h3>
<p><code>dfs_traverse</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dfs_traverse $x
# or in a pipeline:
@list |> map dfs_traverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dft">
<h3><a class="doc-anchor" href="#doc-dft">#</a> <code>dft</code></h3>
<p><code>dft(\@signal)</code> — computes the Discrete Fourier Transform. Returns arrayref of complex numbers as [re, im] pairs. O(n²) reference implementation; for large n, use FFT libraries.</p>
<pre><code class="lang-perl">my @signal = map { sin(2 * 3.14159 * _ / 64) } 0:63
my $spectrum = dft(\@signal)
</code></pre>
</article>
<article class="doc-entry" id="doc-dg-from-k">
<h3><a class="doc-anchor" href="#doc-dg-from-k">#</a> <code>dg_from_k</code></h3>
<p><code>dg_from_k</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = dg_from_k $x
# or in a pipeline:
@list |> map dg_from_k |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgbsv">
<h3><a class="doc-anchor" href="#doc-dgbsv">#</a> <code>dgbsv</code></h3>
<p><code>dgbsv</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgbsv $x
# or in a pipeline:
@list |> map dgbsv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgels">
<h3><a class="doc-anchor" href="#doc-dgels">#</a> <code>dgels</code></h3>
<p><code>dgels</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgels $x
# or in a pipeline:
@list |> map dgels |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgelsd">
<h3><a class="doc-anchor" href="#doc-dgelsd">#</a> <code>dgelsd</code></h3>
<p><code>dgelsd</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgelsd $x
# or in a pipeline:
@list |> map dgelsd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgemm">
<h3><a class="doc-anchor" href="#doc-dgemm">#</a> <code>dgemm</code></h3>
<p><code>dgemm</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgemm $x
# or in a pipeline:
@list |> map dgemm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgemm3m">
<h3><a class="doc-anchor" href="#doc-dgemm3m">#</a> <code>dgemm3m</code></h3>
<p><code>dgemm3m</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgemm3m $x
# or in a pipeline:
@list |> map dgemm3m |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgemv">
<h3><a class="doc-anchor" href="#doc-dgemv">#</a> <code>dgemv</code></h3>
<p><code>dgemv</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgemv $x
# or in a pipeline:
@list |> map dgemv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgeom">
<h3><a class="doc-anchor" href="#doc-dgeom">#</a> <code>dgeom</code></h3>
<p><code>dgeom</code> — geometric PMF P(X=k). Args: k, prob.</p>
<pre><code class="lang-perl">p dgeom(3, 0.5) # P(first success on 4th trial)
</code></pre>
</article>
<article class="doc-entry" id="doc-dgeqrf">
<h3><a class="doc-anchor" href="#doc-dgeqrf">#</a> <code>dgeqrf</code></h3>
<p><code>dgeqrf</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgeqrf $x
# or in a pipeline:
@list |> map dgeqrf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgerqf">
<h3><a class="doc-anchor" href="#doc-dgerqf">#</a> <code>dgerqf</code></h3>
<p><code>dgerqf</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgerqf $x
# or in a pipeline:
@list |> map dgerqf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgesv">
<h3><a class="doc-anchor" href="#doc-dgesv">#</a> <code>dgesv</code></h3>
<p><code>dgesv</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgesv $x
# or in a pipeline:
@list |> map dgesv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgesvd">
<h3><a class="doc-anchor" href="#doc-dgesvd">#</a> <code>dgesvd</code></h3>
<p><code>dgesvd</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgesvd $x
# or in a pipeline:
@list |> map dgesvd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dgetrf">
<h3><a class="doc-anchor" href="#doc-dgetrf">#</a> <code>dgetrf</code></h3>
<p><code>dgetrf</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dgetrf $x
# or in a pipeline:
@list |> map dgetrf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dh-secret">
<h3><a class="doc-anchor" href="#doc-dh-secret">#</a> <code>dh_secret</code></h3>
<p><code>dh_secret</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = dh_secret $x
# or in a pipeline:
@list |> map dh_secret |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dh-shared">
<h3><a class="doc-anchor" href="#doc-dh-shared">#</a> <code>dh_shared</code></h3>
<p><code>dh_shared</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = dh_shared $x
# or in a pipeline:
@list |> map dh_shared |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dhyper">
<h3><a class="doc-anchor" href="#doc-dhyper">#</a> <code>dhyper</code></h3>
<p><code>dhyper</code> — hypergeometric PMF. Args: k, m (white), n (black), nn (draws).</p>
<pre><code class="lang-perl">p dhyper(2, 5, 5, 3) # P(2 white balls in 3 draws from 5W+5B)
</code></pre>
</article>
<article class="doc-entry" id="doc-diag">
<h3><a class="doc-anchor" href="#doc-diag">#</a> <code>diag</code></h3>
<p><code>diag</code> — extended stdlib builtin. Alias for <code>diagonal</code>.</p>
<pre><code class="lang-perl">my $result = diag $x
# or in a pipeline:
@list |> map diag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diagonal">
<h3><a class="doc-anchor" href="#doc-diagonal">#</a> <code>diagonal</code></h3>
<p><code>diagonal</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = diagonal $x
# or in a pipeline:
@list |> map diagonal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diagonal-dominance-q">
<h3><a class="doc-anchor" href="#doc-diagonal-dominance-q">#</a> <code>diagonal_dominance_q</code></h3>
<p><code>diagonal_dominance_q</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = diagonal_dominance_q $x
# or in a pipeline:
@list |> map diagonal_dominance_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diameter-bfs">
<h3><a class="doc-anchor" href="#doc-diameter-bfs">#</a> <code>diameter_bfs</code></h3>
<p><code>diameter_bfs</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = diameter_bfs $x
# or in a pipeline:
@list |> map diameter_bfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diameter-unweighted">
<h3><a class="doc-anchor" href="#doc-diameter-unweighted">#</a> <code>diameter_unweighted</code></h3>
<p><code>diameter_unweighted</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = diameter_unweighted $x
# or in a pipeline:
@list |> map diameter_unweighted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dice-coefficient">
<h3><a class="doc-anchor" href="#doc-dice-coefficient">#</a> <code>dice_coefficient</code></h3>
<p><code>dice_coefficient</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = dice_coefficient $x
# or in a pipeline:
@list |> map dice_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dice-roll">
<h3><a class="doc-anchor" href="#doc-dice-roll">#</a> <code>dice_roll</code></h3>
<p><code>dice_roll</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = dice_roll $x
# or in a pipeline:
@list |> map dice_roll |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dicecoef">
<h3><a class="doc-anchor" href="#doc-dicecoef">#</a> <code>dicecoef</code></h3>
<p><code>dicecoef</code> — extended stdlib batch 3 builtin. Alias for <code>dice_coefficient</code>.</p>
<pre><code class="lang-perl">my $result = dicecoef $x
# or in a pipeline:
@list |> map dicecoef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dickey-fuller-critical">
<h3><a class="doc-anchor" href="#doc-dickey-fuller-critical">#</a> <code>dickey_fuller_critical</code></h3>
<p><code>dickey_fuller_critical</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = dickey_fuller_critical $x
# or in a pipeline:
@list |> map dickey_fuller_critical |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dictator-game-share">
<h3><a class="doc-anchor" href="#doc-dictator-game-share">#</a> <code>dictator_game_share</code></h3>
<p><code>dictator_game_share</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = dictator_game_share $x
# or in a pipeline:
@list |> map dictator_game_share |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-did-estimator">
<h3><a class="doc-anchor" href="#doc-did-estimator">#</a> <code>did_estimator</code></h3>
<p><code>did_estimator</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = did_estimator $x
# or in a pipeline:
@list |> map did_estimator |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-die-if">
<h3><a class="doc-anchor" href="#doc-die-if">#</a> <code>die_if</code></h3>
<p><code>die_if</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = die_if $x
# or in a pipeline:
@list |> map die_if |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-die-unless">
<h3><a class="doc-anchor" href="#doc-die-unless">#</a> <code>die_unless</code></h3>
<p><code>die_unless</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = die_unless $x
# or in a pipeline:
@list |> map die_unless |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diesel-efficiency">
<h3><a class="doc-anchor" href="#doc-diesel-efficiency">#</a> <code>diesel_efficiency</code></h3>
<p><code>diesel_efficiency</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = diesel_efficiency $x
# or in a pipeline:
@list |> map diesel_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff">
<h3><a class="doc-anchor" href="#doc-diff">#</a> <code>diff</code></h3>
<p><code>diff</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = diff $x
# or in a pipeline:
@list |> map diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-array">
<h3><a class="doc-anchor" href="#doc-diff-array">#</a> <code>diff_array</code></h3>
<p><code>numerical_diff</code> (aliases <code>numdiff</code>, <code>diff_array</code>) computes the numerical first derivative via central differences. Returns an array.</p>
<pre><code class="lang-perl">my @y = map { _ ** 2 } 0:10
my @dy = @{numdiff(\@y)} # ≈ [0, 2, 4, 6, ...]
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-coeff-aqueous-estimate">
<h3><a class="doc-anchor" href="#doc-diff-coeff-aqueous-estimate">#</a> <code>diff_coeff_aqueous_estimate</code></h3>
<p><code>diff_coeff_aqueous_estimate</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = diff_coeff_aqueous_estimate $x
# or in a pipeline:
@list |> map diff_coeff_aqueous_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-days">
<h3><a class="doc-anchor" href="#doc-diff-days">#</a> <code>diff_days</code></h3>
<p><code>diff_days</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = diff_days $x
# or in a pipeline:
@list |> map diff_days |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-hours">
<h3><a class="doc-anchor" href="#doc-diff-hours">#</a> <code>diff_hours</code></h3>
<p><code>diff_hours</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = diff_hours $x
# or in a pipeline:
@list |> map diff_hours |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-in-diff">
<h3><a class="doc-anchor" href="#doc-diff-in-diff">#</a> <code>diff_in_diff</code></h3>
<p><code>diff_in_diff</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = diff_in_diff $x
# or in a pipeline:
@list |> map diff_in_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-lag">
<h3><a class="doc-anchor" href="#doc-diff-lag">#</a> <code>diff_lag</code></h3>
<p><code>diff_lag</code> (alias <code>diff_ts</code>) — lagged differences. Args: vec [, lag, differences]. Like R's diff().</p>
<pre><code class="lang-perl">p diff_lag([1,3,6,10]) # [2,3,4] (lag=1)
p diff_lag([1,3,6,10], 2) # [5,7] (lag=2)
p diff_lag([1,3,6,10], 1, 2) # [1,1] (second differences)
</code></pre>
</article>
<article class="doc-entry" id="doc-diffd">
<h3><a class="doc-anchor" href="#doc-diffd">#</a> <code>diffd</code></h3>
<p><code>diffd</code> — extended stdlib builtin. Alias for <code>diff_days</code>.</p>
<pre><code class="lang-perl">my $result = diffd $x
# or in a pipeline:
@list |> map diffd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diffh">
<h3><a class="doc-anchor" href="#doc-diffh">#</a> <code>diffh</code></h3>
<p><code>diffh</code> — extended stdlib builtin. Alias for <code>diff_hours</code>.</p>
<pre><code class="lang-perl">my $result = diffh $x
# or in a pipeline:
@list |> map diffh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diffraction-grating-angle">
<h3><a class="doc-anchor" href="#doc-diffraction-grating-angle">#</a> <code>diffraction_grating_angle</code></h3>
<p><code>diffraction_grating_angle</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = diffraction_grating_angle $x
# or in a pipeline:
@list |> map diffraction_grating_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diffuse-layer-thickness">
<h3><a class="doc-anchor" href="#doc-diffuse-layer-thickness">#</a> <code>diffuse_layer_thickness</code></h3>
<p><code>diffuse_layer_thickness</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = diffuse_layer_thickness $x
# or in a pipeline:
@list |> map diffuse_layer_thickness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diffusion-layer-thickness">
<h3><a class="doc-anchor" href="#doc-diffusion-layer-thickness">#</a> <code>diffusion_layer_thickness</code></h3>
<p><code>diffusion_layer_thickness</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = diffusion_layer_thickness $x
# or in a pipeline:
@list |> map diffusion_layer_thickness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diffusion-stability">
<h3><a class="doc-anchor" href="#doc-diffusion-stability">#</a> <code>diffusion_stability</code></h3>
<p><code>diffusion_stability</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = diffusion_stability $x
# or in a pipeline:
@list |> map diffusion_stability |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dig">
<h3><a class="doc-anchor" href="#doc-dig">#</a> <code>dig</code></h3>
<p><code>dig</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dig $x
# or in a pipeline:
@list |> map dig |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digest-auth-quote">
<h3><a class="doc-anchor" href="#doc-digest-auth-quote">#</a> <code>digest_auth_quote</code></h3>
<p><code>digest_auth_quote</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = digest_auth_quote $x
# or in a pipeline:
@list |> map digest_auth_quote |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digital-call">
<h3><a class="doc-anchor" href="#doc-digital-call">#</a> <code>digital_call</code></h3>
<p><code>digital_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = digital_call $x
# or in a pipeline:
@list |> map digital_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digital-root">
<h3><a class="doc-anchor" href="#doc-digital-root">#</a> <code>digital_root</code></h3>
<p><code>digital_root</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = digital_root $x
# or in a pipeline:
@list |> map digital_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digitize">
<h3><a class="doc-anchor" href="#doc-digitize">#</a> <code>digitize</code></h3>
<p><code>digitize</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = digitize $x
# or in a pipeline:
@list |> map digitize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digits-of">
<h3><a class="doc-anchor" href="#doc-digits-of">#</a> <code>digits_of</code></h3>
<p><code>digits_of</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = digits_of $x
# or in a pipeline:
@list |> map digits_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digroot">
<h3><a class="doc-anchor" href="#doc-digroot">#</a> <code>digroot</code></h3>
<p><code>digroot</code> — extended stdlib batch 3 builtin. Alias for <code>digital_root</code>.</p>
<pre><code class="lang-perl">my $result = digroot $x
# or in a pipeline:
@list |> map digroot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dijkstra">
<h3><a class="doc-anchor" href="#doc-dijkstra">#</a> <code>dijkstra</code></h3>
<p><code>dijkstra</code> (alias <code>shortest_path</code>) computes shortest paths from a source node. Graph is a hash of {node => [[neighbor, weight], ...]}. Returns {node => distance}.</p>
<pre><code class="lang-perl">my $g = {A => [["B",1],["C",4]], B => [["C",2]], C => []}
my $d = dijkstra($g, "A") # {A=>0, B=>1, C=>3}
</code></pre>
</article>
<article class="doc-entry" id="doc-dijkstra-relax">
<h3><a class="doc-anchor" href="#doc-dijkstra-relax">#</a> <code>dijkstra_relax</code></h3>
<p><code>dijkstra_relax</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = dijkstra_relax $x
# or in a pipeline:
@list |> map dijkstra_relax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dilution-v2">
<h3><a class="doc-anchor" href="#doc-dilution-v2">#</a> <code>dilution_v2</code></h3>
<p><code>dilution_v2</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = dilution_v2 $x
# or in a pipeline:
@list |> map dilution_v2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dim">
<h3><a class="doc-anchor" href="#doc-dim">#</a> <code>dim</code></h3>
<p><code>dim</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = dim $x
# or in a pipeline:
@list |> map dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dinic-blocking-flow">
<h3><a class="doc-anchor" href="#doc-dinic-blocking-flow">#</a> <code>dinic_blocking_flow</code></h3>
<p><code>dinic_blocking_flow</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = dinic_blocking_flow $x
# or in a pipeline:
@list |> map dinic_blocking_flow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dinic-step">
<h3><a class="doc-anchor" href="#doc-dinic-step">#</a> <code>dinic_step</code></h3>
<p><code>dinic_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = dinic_step $x
# or in a pipeline:
@list |> map dinic_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diopter">
<h3><a class="doc-anchor" href="#doc-diopter">#</a> <code>diopter</code></h3>
<p><code>diopter</code> — physics formulas builtin. Alias for <code>lens_power</code>.</p>
<pre><code class="lang-perl">my $result = diopter $x
# or in a pipeline:
@list |> map diopter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-direct-age-adjusted">
<h3><a class="doc-anchor" href="#doc-direct-age-adjusted">#</a> <code>direct_age_adjusted</code></h3>
<p><code>direct_age_adjusted</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = direct_age_adjusted $x
# or in a pipeline:
@list |> map direct_age_adjusted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dirs">
<h3><a class="doc-anchor" href="#doc-dirs">#</a> <code>dirs</code></h3>
<p><code>dirs</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = dirs $x
# or in a pipeline:
@list |> map dirs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dirty-price">
<h3><a class="doc-anchor" href="#doc-dirty-price">#</a> <code>dirty_price</code></h3>
<p><code>dirty_price</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = dirty_price $x
# or in a pipeline:
@list |> map dirty_price |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-disc-excel">
<h3><a class="doc-anchor" href="#doc-disc-excel">#</a> <code>disc_excel</code></h3>
<p><code>disc_excel</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = disc_excel $x
# or in a pipeline:
@list |> map disc_excel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-discount">
<h3><a class="doc-anchor" href="#doc-discount">#</a> <code>discount</code></h3>
<p><code>discount</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = discount $x
# or in a pipeline:
@list |> map discount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-discount-amount">
<h3><a class="doc-anchor" href="#doc-discount-amount">#</a> <code>discount_amount</code></h3>
<p><code>discount_amount</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = discount_amount $x
# or in a pipeline:
@list |> map discount_amount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-discount-continuous">
<h3><a class="doc-anchor" href="#doc-discount-continuous">#</a> <code>discount_continuous</code></h3>
<p><code>discount_continuous</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = discount_continuous $x
# or in a pipeline:
@list |> map discount_continuous |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-discount-factor-step">
<h3><a class="doc-anchor" href="#doc-discount-factor-step">#</a> <code>discount_factor_step</code></h3>
<p><code>discount_factor_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = discount_factor_step $x
# or in a pipeline:
@list |> map discount_factor_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-discounted-payback">
<h3><a class="doc-anchor" href="#doc-discounted-payback">#</a> <code>discounted_payback</code></h3>
<p><code>discounted_payback($initial, $rate, @cashflows)</code> — computes payback period using discounted cash flows. Accounts for time value of money.</p>
<pre><code class="lang-perl">p discounted_payback(1000, 0.1, 400, 400, 400, 400)
</code></pre>
</article>
<article class="doc-entry" id="doc-discrete-haar-step">
<h3><a class="doc-anchor" href="#doc-discrete-haar-step">#</a> <code>discrete_haar_step</code></h3>
<p><code>discrete_haar_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = discrete_haar_step $x
# or in a pipeline:
@list |> map discrete_haar_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-disk-avail">
<h3><a class="doc-anchor" href="#doc-disk-avail">#</a> <code>disk_avail</code></h3>
<p><code>disk_avail PATH</code> — available disk space in bytes for non-root users. Uses <code>f_bavail</code> from <code>statvfs</code>, which excludes blocks reserved for the superuser.</p>
<pre><code class="lang-perl">p format_bytes(disk_avail) # 76.3 GiB
gauge(1 - disk_avail / disk_total) |> p # usage gauge
</code></pre>
</article>
<article class="doc-entry" id="doc-disk-free">
<h3><a class="doc-anchor" href="#doc-disk-free">#</a> <code>disk_free</code></h3>
<p><code>disk_free PATH</code> — free disk space in bytes (superuser view). Uses <code>f_bfree</code> from <code>statvfs</code>.</p>
<pre><code class="lang-perl">p format_bytes(disk_free) # 76.3 GiB
p format_bytes(disk_free("/tmp"))
</code></pre>
</article>
<article class="doc-entry" id="doc-disk-total">
<h3><a class="doc-anchor" href="#doc-disk-total">#</a> <code>disk_total</code></h3>
<p><code>disk_total PATH</code> — total disk space in bytes for the filesystem containing PATH (default <code>/</code>). Uses <code>statvfs</code> on unix. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p format_bytes(disk_total) # 1.8 TiB
p format_bytes(disk_total("/home")) # specific mount
</code></pre>
</article>
<article class="doc-entry" id="doc-disk-used">
<h3><a class="doc-anchor" href="#doc-disk-used">#</a> <code>disk_used</code></h3>
<p><code>disk_used PATH</code> — used disk space in bytes (total - free).</p>
<pre><code class="lang-perl">p format_bytes(disk_used) # 1.7 TiB
my $pct = int(disk_used / disk_total * 100)
p "$pct% disk used"
</code></pre>
</article>
<article class="doc-entry" id="doc-dissoc">
<h3><a class="doc-anchor" href="#doc-dissoc">#</a> <code>dissoc</code></h3>
<p><code>dissoc</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = dissoc $x
# or in a pipeline:
@list |> map dissoc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dist">
<h3><a class="doc-anchor" href="#doc-dist">#</a> <code>dist</code></h3>
<p><code>dist</code> — extended stdlib builtin. Alias for <code>distance</code>.</p>
<pre><code class="lang-perl">my $result = dist $x
# or in a pipeline:
@list |> map dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dist-mat">
<h3><a class="doc-anchor" href="#doc-dist-mat">#</a> <code>dist_mat</code></h3>
<p><code>dist_matrix</code> (alias <code>dist_mat</code>) — pairwise distance matrix. Supports 'euclidean' (default), 'manhattan', 'maximum'. Like R's dist().</p>
<pre><code class="lang-perl">my $D = dist_mat([[0,0],[1,0],[0,1]]) # 3x3 distance matrix
my $D2 = dist_mat([[0,0],[1,1]], "manhattan") # Manhattan
</code></pre>
</article>
<article class="doc-entry" id="doc-dist-point-line-2d">
<h3><a class="doc-anchor" href="#doc-dist-point-line-2d">#</a> <code>dist_point_line_2d</code></h3>
<p><code>dist_point_line_2d</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = dist_point_line_2d $x
# or in a pipeline:
@list |> map dist_point_line_2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dist-point-plane-3d">
<h3><a class="doc-anchor" href="#doc-dist-point-plane-3d">#</a> <code>dist_point_plane_3d</code></h3>
<p><code>dist_point_plane_3d</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = dist_point_plane_3d $x
# or in a pipeline:
@list |> map dist_point_plane_3d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-distance">
<h3><a class="doc-anchor" href="#doc-distance">#</a> <code>distance</code></h3>
<p><code>distance</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = distance $x
# or in a pipeline:
@list |> map distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-distb">
<h3><a class="doc-anchor" href="#doc-distb">#</a> <code>distb</code></h3>
<p><code>distb</code> — additional missing stdlib functions builtin. Alias for <code>distinct_by</code>.</p>
<pre><code class="lang-perl">my $result = distb $x
# or in a pipeline:
@list |> map distb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-distinct-by">
<h3><a class="doc-anchor" href="#doc-distinct-by">#</a> <code>distinct_by</code></h3>
<p><code>distinct_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = distinct_by $x
# or in a pipeline:
@list |> map distinct_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-distinct-count">
<h3><a class="doc-anchor" href="#doc-distinct-count">#</a> <code>distinct_count</code></h3>
<p><code>distinct_count</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = distinct_count $x
# or in a pipeline:
@list |> map distinct_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-divergence-omega-step">
<h3><a class="doc-anchor" href="#doc-divergence-omega-step">#</a> <code>divergence_omega_step</code></h3>
<p><code>divergence_omega_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = divergence_omega_step $x
# or in a pipeline:
@list |> map divergence_omega_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-divisible-goods-proportional">
<h3><a class="doc-anchor" href="#doc-divisible-goods-proportional">#</a> <code>divisible_goods_proportional</code></h3>
<p><code>divisible_goods_proportional</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = divisible_goods_proportional $x
# or in a pipeline:
@list |> map divisible_goods_proportional |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-divisors">
<h3><a class="doc-anchor" href="#doc-divisors">#</a> <code>divisors</code></h3>
<p><code>divisors</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = divisors $x
# or in a pipeline:
@list |> map divisors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-divmod">
<h3><a class="doc-anchor" href="#doc-divmod">#</a> <code>divmod</code></h3>
<p><code>divmod</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = divmod $x
# or in a pipeline:
@list |> map divmod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-divs">
<h3><a class="doc-anchor" href="#doc-divs">#</a> <code>divs</code></h3>
<p><code>divs</code> — math / numeric (uncategorized batch) builtin. Alias for <code>divisors</code>.</p>
<pre><code class="lang-perl">my $result = divs $x
# or in a pipeline:
@list |> map divs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-djb2">
<h3><a class="doc-anchor" href="#doc-djb2">#</a> <code>djb2</code></h3>
<p><code>djb2</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = djb2 $x
# or in a pipeline:
@list |> map djb2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-djb2-hash">
<h3><a class="doc-anchor" href="#doc-djb2-hash">#</a> <code>djb2_hash</code></h3>
<p><code>djb2_hash</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = djb2_hash $x
# or in a pipeline:
@list |> map djb2_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dm">
<h3><a class="doc-anchor" href="#doc-dm">#</a> <code>dm</code></h3>
<p><code>dm</code> — python/ruby stdlib builtin. Alias for <code>divmod</code>.</p>
<pre><code class="lang-perl">my $result = dm $x
# or in a pipeline:
@list |> map dm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dmetph">
<h3><a class="doc-anchor" href="#doc-dmetph">#</a> <code>dmetph</code></h3>
<p><code>dmetph</code> — encoding / phonetics builtin. Alias for <code>double_metaphone</code>.</p>
<pre><code class="lang-perl">my $result = dmetph $x
# or in a pipeline:
@list |> map dmetph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dnbinom">
<h3><a class="doc-anchor" href="#doc-dnbinom">#</a> <code>dnbinom</code></h3>
<p><code>dnbinom</code> — negative binomial PMF. Args: k, size, prob.</p>
<pre><code class="lang-perl">p dnbinom(3, 5, 0.5) # P(3 failures before 5 successes)
</code></pre>
</article>
<article class="doc-entry" id="doc-dnds-ratio">
<h3><a class="doc-anchor" href="#doc-dnds-ratio">#</a> <code>dnds_ratio</code></h3>
<p><code>dnds_ratio</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = dnds_ratio $x
# or in a pipeline:
@list |> map dnds_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dnorm">
<h3><a class="doc-anchor" href="#doc-dnorm">#</a> <code>dnorm</code></h3>
<p><code>dnorm</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = dnorm $x
# or in a pipeline:
@list |> map dnorm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dnrm2">
<h3><a class="doc-anchor" href="#doc-dnrm2">#</a> <code>dnrm2</code></h3>
<p><code>dnrm2</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dnrm2 $x
# or in a pipeline:
@list |> map dnrm2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-do-call">
<h3><a class="doc-anchor" href="#doc-do-call">#</a> <code>do_call</code></h3>
<p><code>do_call</code> — call a function with args from a list. Like R's do.call().</p>
<pre><code class="lang-perl">my $result = docall(fn { $_[0] + $_[1] }, [3, 4]) # 7
</code></pre>
</article>
<article class="doc-entry" id="doc-doctor">
<h3><a class="doc-anchor" href="#doc-doctor">#</a> <code>doctor</code></h3>
<p><code>doctor</code> (alias <code>health</code>) — runtime diagnostic report. Prints version + binary path, runtime flags (<code>--compat</code>, <code>--no-interop</code>, <code>bigint</code>, <code>strict_vars</code>, <code>strict_refs</code>), environment overrides (<code>STRYKE_NO_TTY</code>, <code>STRYKE_NO_JIT</code>, <code>RUST_LOG</code>, …), reflection counts (<code>%b</code> primaries, <code>%all</code> spellings, categories, list-builtin extras), concurrency (logical CPUs + rayon pool size), home/cache/config dirs, toolchain availability (<code>rustc</code>/<code>cargo</code>/<code>perl</code>/<code>git</code>/<code>rg</code>), and a battery of sanity checks. Returns the warning count as an integer (0 = healthy).</p>
<pre><code class="lang-perl">doctor # full report
my $w = doctor
exit($w == 0 ? 0 : 1) # CI-friendly health gate
</code></pre>
</article>
<article class="doc-entry" id="doc-dodecahedral-number">
<h3><a class="doc-anchor" href="#doc-dodecahedral-number">#</a> <code>dodecahedral_number</code></h3>
<p><code>dodecahedral_number</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = dodecahedral_number $x
# or in a pipeline:
@list |> map dodecahedral_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dodgson-swap-count">
<h3><a class="doc-anchor" href="#doc-dodgson-swap-count">#</a> <code>dodgson_swap_count</code></h3>
<p><code>dodgson_swap_count</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = dodgson_swap_count $x
# or in a pipeline:
@list |> map dodgson_swap_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dogleg-step">
<h3><a class="doc-anchor" href="#doc-dogleg-step">#</a> <code>dogleg_step</code></h3>
<p><code>dogleg_step</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = dogleg_step $x
# or in a pipeline:
@list |> map dogleg_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dollarde">
<h3><a class="doc-anchor" href="#doc-dollarde">#</a> <code>dollarde</code></h3>
<p><code>dollarde</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = dollarde $x
# or in a pipeline:
@list |> map dollarde |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dollarfr">
<h3><a class="doc-anchor" href="#doc-dollarfr">#</a> <code>dollarfr</code></h3>
<p><code>dollarfr</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = dollarfr $x
# or in a pipeline:
@list |> map dollarfr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dom-tree-idom">
<h3><a class="doc-anchor" href="#doc-dom-tree-idom">#</a> <code>dom_tree_idom</code></h3>
<p><code>dom_tree_idom</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = dom_tree_idom $x
# or in a pipeline:
@list |> map dom_tree_idom |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dominance-frontier">
<h3><a class="doc-anchor" href="#doc-dominance-frontier">#</a> <code>dominance_frontier</code></h3>
<p><code>dominance_frontier</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = dominance_frontier $x
# or in a pipeline:
@list |> map dominance_frontier |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dominating-set-greedy">
<h3><a class="doc-anchor" href="#doc-dominating-set-greedy">#</a> <code>dominating_set_greedy</code></h3>
<p><code>dominating_set_greedy</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = dominating_set_greedy $x
# or in a pipeline:
@list |> map dominating_set_greedy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dominating-set-greedy-step">
<h3><a class="doc-anchor" href="#doc-dominating-set-greedy-step">#</a> <code>dominating_set_greedy_step</code></h3>
<p><code>dominating_set_greedy_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = dominating_set_greedy_step $x
# or in a pipeline:
@list |> map dominating_set_greedy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dominating-set-lp-bound">
<h3><a class="doc-anchor" href="#doc-dominating-set-lp-bound">#</a> <code>dominating_set_lp_bound</code></h3>
<p><code>dominating_set_lp_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = dominating_set_lp_bound $x
# or in a pipeline:
@list |> map dominating_set_lp_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-donaldson-invariant">
<h3><a class="doc-anchor" href="#doc-donaldson-invariant">#</a> <code>donaldson_invariant</code></h3>
<p><code>donaldson_invariant</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = donaldson_invariant $x
# or in a pipeline:
@list |> map donaldson_invariant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-doppler">
<h3><a class="doc-anchor" href="#doc-doppler">#</a> <code>doppler</code></h3>
<p><code>doppler_frequency($source_freq, $source_vel, $observer_vel)</code> (alias <code>doppler</code>) — observed frequency with Doppler effect. Uses speed of sound (343 m/s).</p>
<pre><code class="lang-perl">p doppler(440, -30, 0) # ~482 Hz (ambulance approaching at 30 m/s)
p doppler(440, 30, 0) # ~405 Hz (ambulance receding)
</code></pre>
</article>
<article class="doc-entry" id="doc-doppler-classical">
<h3><a class="doc-anchor" href="#doc-doppler-classical">#</a> <code>doppler_classical</code></h3>
<p><code>doppler_classical</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = doppler_classical $x
# or in a pipeline:
@list |> map doppler_classical |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-doppler-relativistic">
<h3><a class="doc-anchor" href="#doc-doppler-relativistic">#</a> <code>doppler_relativistic</code></h3>
<p><code>doppler_relativistic</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = doppler_relativistic $x
# or in a pipeline:
@list |> map doppler_relativistic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dopri5-combine">
<h3><a class="doc-anchor" href="#doc-dopri5-combine">#</a> <code>dopri5_combine</code></h3>
<p><code>dopri5_combine</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = dopri5_combine $x
# or in a pipeline:
@list |> map dopri5_combine |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dorglq">
<h3><a class="doc-anchor" href="#doc-dorglq">#</a> <code>dorglq</code></h3>
<p><code>dorglq</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dorglq $x
# or in a pipeline:
@list |> map dorglq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dorgqr">
<h3><a class="doc-anchor" href="#doc-dorgqr">#</a> <code>dorgqr</code></h3>
<p><code>dorgqr</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dorgqr $x
# or in a pipeline:
@list |> map dorgqr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dot-case">
<h3><a class="doc-anchor" href="#doc-dot-case">#</a> <code>dot_case</code></h3>
<p><code>dot_case</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = dot_case $x
# or in a pipeline:
@list |> map dot_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dot-product">
<h3><a class="doc-anchor" href="#doc-dot-product">#</a> <code>dot_product</code></h3>
<p><code>dot_product</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dot_product $x
# or in a pipeline:
@list |> map dot_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dotp">
<h3><a class="doc-anchor" href="#doc-dotp">#</a> <code>dotp</code></h3>
<p><code>dotp</code> — extended stdlib builtin. Alias for <code>dot_product</code>.</p>
<pre><code class="lang-perl">my $result = dotp $x
# or in a pipeline:
@list |> map dotp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double">
<h3><a class="doc-anchor" href="#doc-double">#</a> <code>double</code></h3>
<p><code>double</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = double $x
# or in a pipeline:
@list |> map double |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-auction-step">
<h3><a class="doc-anchor" href="#doc-double-auction-step">#</a> <code>double_auction_step</code></h3>
<p><code>double_auction_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = double_auction_step $x
# or in a pipeline:
@list |> map double_auction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-each">
<h3><a class="doc-anchor" href="#doc-double-each">#</a> <code>double_each</code></h3>
<p><code>double_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = double_each $x
# or in a pipeline:
@list |> map double_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-factorial">
<h3><a class="doc-anchor" href="#doc-double-factorial">#</a> <code>double_factorial</code></h3>
<p><code>double_factorial</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = double_factorial $x
# or in a pipeline:
@list |> map double_factorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-layer-capacitance">
<h3><a class="doc-anchor" href="#doc-double-layer-capacitance">#</a> <code>double_layer_capacitance</code></h3>
<p><code>double_layer_capacitance</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = double_layer_capacitance $x
# or in a pipeline:
@list |> map double_layer_capacitance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-metaphone">
<h3><a class="doc-anchor" href="#doc-double-metaphone">#</a> <code>double_metaphone</code></h3>
<p><code>double_metaphone</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = double_metaphone $x
# or in a pipeline:
@list |> map double_metaphone |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-q-learning-step">
<h3><a class="doc-anchor" href="#doc-double-q-learning-step">#</a> <code>double_q_learning_step</code></h3>
<p><code>double_q_learning_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = double_q_learning_step $x
# or in a pipeline:
@list |> map double_q_learning_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-doubling-time-growth">
<h3><a class="doc-anchor" href="#doc-doubling-time-growth">#</a> <code>doubling_time_growth</code></h3>
<p><code>doubling_time_growth</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = doubling_time_growth $x
# or in a pipeline:
@list |> map doubling_time_growth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-downcase-each">
<h3><a class="doc-anchor" href="#doc-downcase-each">#</a> <code>downcase_each</code></h3>
<p><code>downcase_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = downcase_each $x
# or in a pipeline:
@list |> map downcase_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-downsample">
<h3><a class="doc-anchor" href="#doc-downsample">#</a> <code>downsample</code></h3>
<p><code>downsample(\@signal, $factor)</code> (alias <code>decimate</code>) — reduces sample rate by keeping every nth sample. Apply anti-aliasing filter first to avoid aliasing.</p>
<pre><code class="lang-perl">my $decimated = decimate(\@signal, 4) # keep every 4th sample
</code></pre>
</article>
<article class="doc-entry" id="doc-downto">
<h3><a class="doc-anchor" href="#doc-downto">#</a> <code>downto</code></h3>
<p><code>downto</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = downto $x
# or in a pipeline:
@list |> map downto |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-doy">
<h3><a class="doc-anchor" href="#doc-doy">#</a> <code>doy</code></h3>
<p><code>doy</code> — extended stdlib batch 3 builtin. Alias for <code>day_of_year</code>.</p>
<pre><code class="lang-perl">my $result = doy $x
# or in a pipeline:
@list |> map doy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dpayback">
<h3><a class="doc-anchor" href="#doc-dpayback">#</a> <code>dpayback</code></h3>
<p><code>dpayback</code> — finance (extended) builtin. Alias for <code>discounted_payback</code>.</p>
<pre><code class="lang-perl">my $result = dpayback $x
# or in a pipeline:
@list |> map dpayback |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dpbsv">
<h3><a class="doc-anchor" href="#doc-dpbsv">#</a> <code>dpbsv</code></h3>
<p><code>dpbsv</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dpbsv $x
# or in a pipeline:
@list |> map dpbsv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dpll-clause-learning">
<h3><a class="doc-anchor" href="#doc-dpll-clause-learning">#</a> <code>dpll_clause_learning</code></h3>
<p><code>dpll_clause_learning</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = dpll_clause_learning $x
# or in a pipeline:
@list |> map dpll_clause_learning |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dpotrf">
<h3><a class="doc-anchor" href="#doc-dpotrf">#</a> <code>dpotrf</code></h3>
<p><code>dpotrf</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dpotrf $x
# or in a pipeline:
@list |> map dpotrf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dpss-window">
<h3><a class="doc-anchor" href="#doc-dpss-window">#</a> <code>dpss_window</code></h3>
<p><code>dpss_window</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = dpss_window $x
# or in a pipeline:
@list |> map dpss_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dr">
<h3><a class="doc-anchor" href="#doc-dr">#</a> <code>dr</code></h3>
<p><code>dr</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = dr $x
# or in a pipeline:
@list |> map dr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drag-force">
<h3><a class="doc-anchor" href="#doc-drag-force">#</a> <code>drag_force</code></h3>
<p><code>drag_force</code> (alias <code>fdrag</code>) computes aerodynamic drag: F = 0.5·Cd·ρ·A·v². Args: drag_coeff, air_density, area, velocity.</p>
<pre><code class="lang-perl">p fdrag(0.47, 1.225, 0.01, 30) # drag on a ball at 30 m/s
</code></pre>
</article>
<article class="doc-entry" id="doc-drag-force-quadratic">
<h3><a class="doc-anchor" href="#doc-drag-force-quadratic">#</a> <code>drag_force_quadratic</code></h3>
<p><code>drag_force_quadratic</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = drag_force_quadratic $x
# or in a pipeline:
@list |> map drag_force_quadratic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drnk">
<h3><a class="doc-anchor" href="#doc-drnk">#</a> <code>drnk</code></h3>
<p><code>drnk</code> — extended stdlib builtin. Alias for <code>dense_rank</code>.</p>
<pre><code class="lang-perl">my $result = drnk $x
# or in a pipeline:
@list |> map drnk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-at">
<h3><a class="doc-anchor" href="#doc-drop-at">#</a> <code>drop_at</code></h3>
<p><code>drop_at</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = drop_at $x
# or in a pipeline:
@list |> map drop_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-every">
<h3><a class="doc-anchor" href="#doc-drop-every">#</a> <code>drop_every</code></h3>
<p><code>drop_every</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = drop_every $x
# or in a pipeline:
@list |> map drop_every |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-last">
<h3><a class="doc-anchor" href="#doc-drop-last">#</a> <code>drop_last</code></h3>
<p><code>drop_last</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = drop_last $x
# or in a pipeline:
@list |> map drop_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-n">
<h3><a class="doc-anchor" href="#doc-drop-n">#</a> <code>drop_n</code></h3>
<p><code>drop_n</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = drop_n $x
# or in a pipeline:
@list |> map drop_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drot">
<h3><a class="doc-anchor" href="#doc-drot">#</a> <code>drot</code></h3>
<p><code>drot</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = drot $x
# or in a pipeline:
@list |> map drot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drotg">
<h3><a class="doc-anchor" href="#doc-drotg">#</a> <code>drotg</code></h3>
<p><code>drotg</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = drotg $x
# or in a pipeline:
@list |> map drotg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dsamp">
<h3><a class="doc-anchor" href="#doc-dsamp">#</a> <code>dsamp</code></h3>
<p><code>dsamp</code> — dsp / signal (extended) builtin. Alias for <code>downsample</code>.</p>
<pre><code class="lang-perl">my $result = dsamp $x
# or in a pipeline:
@list |> map dsamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dscal">
<h3><a class="doc-anchor" href="#doc-dscal">#</a> <code>dscal</code></h3>
<p><code>dscal</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dscal $x
# or in a pipeline:
@list |> map dscal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dsyevd">
<h3><a class="doc-anchor" href="#doc-dsyevd">#</a> <code>dsyevd</code></h3>
<p><code>dsyevd</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dsyevd $x
# or in a pipeline:
@list |> map dsyevd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dsyrk">
<h3><a class="doc-anchor" href="#doc-dsyrk">#</a> <code>dsyrk</code></h3>
<p><code>dsyrk</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dsyrk $x
# or in a pipeline:
@list |> map dsyrk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dt">
<h3><a class="doc-anchor" href="#doc-dt">#</a> <code>dt</code></h3>
<p><code>dt</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = dt $x
# or in a pipeline:
@list |> map dt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dtbsv">
<h3><a class="doc-anchor" href="#doc-dtbsv">#</a> <code>dtbsv</code></h3>
<p><code>dtbsv</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dtbsv $x
# or in a pipeline:
@list |> map dtbsv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dte">
<h3><a class="doc-anchor" href="#doc-dte">#</a> <code>dte</code></h3>
<p><code>dte</code> — date / time builtin. Alias for <code>datetime_from_epoch</code>.</p>
<pre><code class="lang-perl">my $result = dte $x
# or in a pipeline:
@list |> map dte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dtf">
<h3><a class="doc-anchor" href="#doc-dtf">#</a> <code>dtf</code></h3>
<p><code>dtf</code> — date / time builtin. Alias for <code>datetime_strftime</code>.</p>
<pre><code class="lang-perl">my $result = dtf $x
# or in a pipeline:
@list |> map dtf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dtrsm">
<h3><a class="doc-anchor" href="#doc-dtrsm">#</a> <code>dtrsm</code></h3>
<p><code>dtrsm</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dtrsm $x
# or in a pipeline:
@list |> map dtrsm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dtrsv">
<h3><a class="doc-anchor" href="#doc-dtrsv">#</a> <code>dtrsv</code></h3>
<p><code>dtrsv</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = dtrsv $x
# or in a pipeline:
@list |> map dtrsv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dump">
<h3><a class="doc-anchor" href="#doc-dump">#</a> <code>dump</code></h3>
<p><code>dump</code> — process / system builtin.</p>
<pre><code class="lang-perl">my $result = dump $x
# or in a pipeline:
@list |> map dump |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dunif">
<h3><a class="doc-anchor" href="#doc-dunif">#</a> <code>dunif</code></h3>
<p><code>dunif</code> — uniform PDF. Args: x, a, b.</p>
<pre><code class="lang-perl">p dunif(0.5, 0, 1) # 1.0
</code></pre>
</article>
<article class="doc-entry" id="doc-duped">
<h3><a class="doc-anchor" href="#doc-duped">#</a> <code>duped</code></h3>
<p><code>duplicated</code> — boolean array: 1 if element appeared earlier in the vector, 0 otherwise. Like R's duplicated().</p>
<pre><code class="lang-perl">p duplicated([1,2,3,2,1]) # [0,0,0,1,1]
</code></pre>
</article>
<article class="doc-entry" id="doc-duplicate-count">
<h3><a class="doc-anchor" href="#doc-duplicate-count">#</a> <code>duplicate_count</code></h3>
<p><code>duplicate_count</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = duplicate_count $x
# or in a pipeline:
@list |> map duplicate_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-durand-kerner">
<h3><a class="doc-anchor" href="#doc-durand-kerner">#</a> <code>durand_kerner</code></h3>
<p><code>durand_kerner</code> — batch 10 builtin. Alias for <code>polynomial_roots_dk</code>.</p>
<pre><code class="lang-perl">my $result = durand_kerner $x
# or in a pipeline:
@list |> map durand_kerner |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-duration-macaulay">
<h3><a class="doc-anchor" href="#doc-duration-macaulay">#</a> <code>duration_macaulay</code></h3>
<p><code>duration_macaulay</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = duration_macaulay $x
# or in a pipeline:
@list |> map duration_macaulay |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-durbin-watson-d">
<h3><a class="doc-anchor" href="#doc-durbin-watson-d">#</a> <code>durbin_watson_d</code></h3>
<p><code>durbin_watson_d</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = durbin_watson_d $x
# or in a pipeline:
@list |> map durbin_watson_d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dutch-auction">
<h3><a class="doc-anchor" href="#doc-dutch-auction">#</a> <code>dutch_auction</code></h3>
<p><code>dutch_auction</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = dutch_auction $x
# or in a pipeline:
@list |> map dutch_auction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dutch-auction-step">
<h3><a class="doc-anchor" href="#doc-dutch-auction-step">#</a> <code>dutch_auction_step</code></h3>
<p><code>dutch_auction_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = dutch_auction_step $x
# or in a pipeline:
@list |> map dutch_auction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dynamics-db-level">
<h3><a class="doc-anchor" href="#doc-dynamics-db-level">#</a> <code>dynamics_db_level</code></h3>
<p><code>dynamics_db_level</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = dynamics_db_level $x
# or in a pipeline:
@list |> map dynamics_db_level |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-each-cons">
<h3><a class="doc-anchor" href="#doc-each-cons">#</a> <code>each_cons</code></h3>
<p><code>each_cons</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = each_cons $x
# or in a pipeline:
@list |> map each_cons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-each-slice">
<h3><a class="doc-anchor" href="#doc-each-slice">#</a> <code>each_slice</code></h3>
<p><code>each_slice</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = each_slice $x
# or in a pipeline:
@list |> map each_slice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-each-with-index">
<h3><a class="doc-anchor" href="#doc-each-with-index">#</a> <code>each_with_index</code></h3>
<p><code>each_with_index</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = each_with_index $x
# or in a pipeline:
@list |> map each_with_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-each-with-object">
<h3><a class="doc-anchor" href="#doc-each-with-object">#</a> <code>each_with_object</code></h3>
<p><code>each_with_object</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = each_with_object $x
# or in a pipeline:
@list |> map each_with_object |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eadie-hofstee-y">
<h3><a class="doc-anchor" href="#doc-eadie-hofstee-y">#</a> <code>eadie_hofstee_y</code></h3>
<p><code>eadie_hofstee_y</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = eadie_hofstee_y $x
# or in a pipeline:
@list |> map eadie_hofstee_y |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ean13-check">
<h3><a class="doc-anchor" href="#doc-ean13-check">#</a> <code>ean13_check</code></h3>
<p><code>ean13_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = ean13_check $x
# or in a pipeline:
@list |> map ean13_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-earley-complete">
<h3><a class="doc-anchor" href="#doc-earley-complete">#</a> <code>earley_complete</code></h3>
<p><code>earley_complete</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = earley_complete $x
# or in a pipeline:
@list |> map earley_complete |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-earley-predict">
<h3><a class="doc-anchor" href="#doc-earley-predict">#</a> <code>earley_predict</code></h3>
<p><code>earley_predict</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = earley_predict $x
# or in a pipeline:
@list |> map earley_predict |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-earley-scan">
<h3><a class="doc-anchor" href="#doc-earley-scan">#</a> <code>earley_scan</code></h3>
<p><code>earley_scan</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = earley_scan $x
# or in a pipeline:
@list |> map earley_scan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-earth-mass">
<h3><a class="doc-anchor" href="#doc-earth-mass">#</a> <code>earth_mass</code></h3>
<p><code>earth_mass</code> (alias <code>mearth</code>) — M⊕ ≈ 5.972×10²⁴ kg. Mass of Earth.</p>
<pre><code class="lang-perl">p mearth # 5.972167867e24 kg
</code></pre>
</article>
<article class="doc-entry" id="doc-earth-radius">
<h3><a class="doc-anchor" href="#doc-earth-radius">#</a> <code>earth_radius</code></h3>
<p><code>earth_radius</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = earth_radius $x
# or in a pipeline:
@list |> map earth_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-easter-gregorian-year">
<h3><a class="doc-anchor" href="#doc-easter-gregorian-year">#</a> <code>easter_gregorian_year</code></h3>
<p><code>easter_gregorian_year</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = easter_gregorian_year $x
# or in a pipeline:
@list |> map easter_gregorian_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-easter-julian-year">
<h3><a class="doc-anchor" href="#doc-easter-julian-year">#</a> <code>easter_julian_year</code></h3>
<p><code>easter_julian_year</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = easter_julian_year $x
# or in a pipeline:
@list |> map easter_julian_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-easter-orthodox-year">
<h3><a class="doc-anchor" href="#doc-easter-orthodox-year">#</a> <code>easter_orthodox_year</code></h3>
<p><code>easter_orthodox_year</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = easter_orthodox_year $x
# or in a pipeline:
@list |> map easter_orthodox_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-easter-orthodox-year-2">
<h3><a class="doc-anchor" href="#doc-easter-orthodox-year-2">#</a> <code>easter_orthodox_year_2</code></h3>
<p><code>easter_orthodox_year_2</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = easter_orthodox_year_2 $x
# or in a pipeline:
@list |> map easter_orthodox_year_2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-easter-sunday">
<h3><a class="doc-anchor" href="#doc-easter-sunday">#</a> <code>easter_sunday</code></h3>
<p><code>easter_sunday</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = easter_sunday $x
# or in a pipeline:
@list |> map easter_sunday |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-easter-western">
<h3><a class="doc-anchor" href="#doc-easter-western">#</a> <code>easter_western</code></h3>
<p><code>easter_western</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = easter_western $x
# or in a pipeline:
@list |> map easter_western |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ecc-point-double">
<h3><a class="doc-anchor" href="#doc-ecc-point-double">#</a> <code>ecc_point_double</code></h3>
<p><code>ecc_point_double</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = ecc_point_double $x
# or in a pipeline:
@list |> map ecc_point_double |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdf">
<h3><a class="doc-anchor" href="#doc-ecdf">#</a> <code>ecdf</code></h3>
<p><code>ecdf</code> — empirical CDF: proportion of data ≤ x. Like R's ecdf().</p>
<pre><code class="lang-perl">p ecdf([1,2,3,4,5], 3) # 0.6 (3 of 5 values ≤ 3)
</code></pre>
</article>
<article class="doc-entry" id="doc-echarge">
<h3><a class="doc-anchor" href="#doc-echarge">#</a> <code>echarge</code></h3>
<p><code>echarge</code> — constants builtin. Alias for <code>elementary_charge</code>.</p>
<pre><code class="lang-perl">my $result = echarge $x
# or in a pipeline:
@list |> map echarge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eclipse-magnitude">
<h3><a class="doc-anchor" href="#doc-eclipse-magnitude">#</a> <code>eclipse_magnitude</code></h3>
<p><code>eclipse_magnitude</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = eclipse_magnitude $x
# or in a pipeline:
@list |> map eclipse_magnitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ecliptic-obliquity">
<h3><a class="doc-anchor" href="#doc-ecliptic-obliquity">#</a> <code>ecliptic_obliquity</code></h3>
<p><code>ecliptic_obliquity</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = ecliptic_obliquity $x
# or in a pipeline:
@list |> map ecliptic_obliquity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ecliptic-to-equatorial">
<h3><a class="doc-anchor" href="#doc-ecliptic-to-equatorial">#</a> <code>ecliptic_to_equatorial</code></h3>
<p><code>ecliptic_to_equatorial</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = ecliptic_to_equatorial $input
</code></pre>
</article>
<article class="doc-entry" id="doc-econs">
<h3><a class="doc-anchor" href="#doc-econs">#</a> <code>econs</code></h3>
<p><code>econs</code> — python/ruby stdlib builtin. Alias for <code>each_cons</code>.</p>
<pre><code class="lang-perl">my $result = econs $x
# or in a pipeline:
@list |> map econs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eddington-luminosity">
<h3><a class="doc-anchor" href="#doc-eddington-luminosity">#</a> <code>eddington_luminosity</code></h3>
<p><code>eddington_luminosity</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = eddington_luminosity $x
# or in a pipeline:
@list |> map eddington_luminosity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-edge-coloring-vizing-step">
<h3><a class="doc-anchor" href="#doc-edge-coloring-vizing-step">#</a> <code>edge_coloring_vizing_step</code></h3>
<p><code>edge_coloring_vizing_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = edge_coloring_vizing_step $x
# or in a pipeline:
@list |> map edge_coloring_vizing_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-edge-connectivity">
<h3><a class="doc-anchor" href="#doc-edge-connectivity">#</a> <code>edge_connectivity</code></h3>
<p><code>edge_connectivity</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = edge_connectivity $x
# or in a pipeline:
@list |> map edge_connectivity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-edge-detect-kernel">
<h3><a class="doc-anchor" href="#doc-edge-detect-kernel">#</a> <code>edge_detect_kernel</code></h3>
<p><code>edge_detect_kernel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = edge_detect_kernel $x
# or in a pipeline:
@list |> map edge_detect_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-edgeworth-box-alloc">
<h3><a class="doc-anchor" href="#doc-edgeworth-box-alloc">#</a> <code>edgeworth_box_alloc</code></h3>
<p><code>edgeworth_box_alloc</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = edgeworth_box_alloc $x
# or in a pipeline:
@list |> map edgeworth_box_alloc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-edmonds-karp-bfs">
<h3><a class="doc-anchor" href="#doc-edmonds-karp-bfs">#</a> <code>edmonds_karp_bfs</code></h3>
<p><code>edmonds_karp_bfs</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = edmonds_karp_bfs $x
# or in a pipeline:
@list |> map edmonds_karp_bfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-edmonds-karp-step">
<h3><a class="doc-anchor" href="#doc-edmonds-karp-step">#</a> <code>edmonds_karp_step</code></h3>
<p><code>edmonds_karp_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = edmonds_karp_step $x
# or in a pipeline:
@list |> map edmonds_karp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-effect">
<h3><a class="doc-anchor" href="#doc-effect">#</a> <code>effect</code></h3>
<p><code>effect</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = effect $x
# or in a pipeline:
@list |> map effect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-effective-pop-size">
<h3><a class="doc-anchor" href="#doc-effective-pop-size">#</a> <code>effective_pop_size</code></h3>
<p><code>effective_pop_size</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = effective_pop_size $x
# or in a pipeline:
@list |> map effective_pop_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-efficiency-ratio">
<h3><a class="doc-anchor" href="#doc-efficiency-ratio">#</a> <code>efficiency_ratio</code></h3>
<p><code>efficiency_ratio</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = efficiency_ratio $x
# or in a pipeline:
@list |> map efficiency_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-efield">
<h3><a class="doc-anchor" href="#doc-efield">#</a> <code>efield</code></h3>
<p><code>efield</code> — physics formulas builtin. Alias for <code>electric_field</code>.</p>
<pre><code class="lang-perl">my $result = efield $x
# or in a pipeline:
@list |> map efield |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-efield-point">
<h3><a class="doc-anchor" href="#doc-efield-point">#</a> <code>efield_point</code></h3>
<p><code>efield_point</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = efield_point $x
# or in a pipeline:
@list |> map efield_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-egalitarian-solution">
<h3><a class="doc-anchor" href="#doc-egalitarian-solution">#</a> <code>egalitarian_solution</code></h3>
<p><code>egalitarian_solution</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = egalitarian_solution $x
# or in a pipeline:
@list |> map egalitarian_solution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-egalitarian-split">
<h3><a class="doc-anchor" href="#doc-egalitarian-split">#</a> <code>egalitarian_split</code></h3>
<p><code>egalitarian_split</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = egalitarian_split $x
# or in a pipeline:
@list |> map egalitarian_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-egarch-step">
<h3><a class="doc-anchor" href="#doc-egarch-step">#</a> <code>egarch_step</code></h3>
<p><code>egarch_step</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = egarch_step $x
# or in a pipeline:
@list |> map egarch_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eig">
<h3><a class="doc-anchor" href="#doc-eig">#</a> <code>eig</code></h3>
<p><code>matrix_eigenvalues</code> (aliases <code>meig</code>, <code>eig</code>) computes eigenvalues of a square matrix via QR iteration. Returns an array of eigenvalues.</p>
<pre><code class="lang-perl">my @eigs = @{eig([[2,1],[1,2]])} # [3, 1]
</code></pre>
</article>
<article class="doc-entry" id="doc-einstein-dilaton-step">
<h3><a class="doc-anchor" href="#doc-einstein-dilaton-step">#</a> <code>einstein_dilaton_step</code></h3>
<p><code>einstein_dilaton_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = einstein_dilaton_step $x
# or in a pipeline:
@list |> map einstein_dilaton_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-einstein-ring-radius">
<h3><a class="doc-anchor" href="#doc-einstein-ring-radius">#</a> <code>einstein_ring_radius</code></h3>
<p><code>einstein_ring_radius</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = einstein_ring_radius $x
# or in a pipeline:
@list |> map einstein_ring_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-einstein-tensor-step">
<h3><a class="doc-anchor" href="#doc-einstein-tensor-step">#</a> <code>einstein_tensor_step</code></h3>
<p><code>einstein_tensor_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = einstein_tensor_step $x
# or in a pipeline:
@list |> map einstein_tensor_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-either">
<h3><a class="doc-anchor" href="#doc-either">#</a> <code>either</code></h3>
<p><code>either</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = either $x
# or in a pipeline:
@list |> map either |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ekf-jacobian-step">
<h3><a class="doc-anchor" href="#doc-ekf-jacobian-step">#</a> <code>ekf_jacobian_step</code></h3>
<p><code>ekf_jacobian_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = ekf_jacobian_step $x
# or in a pipeline:
@list |> map ekf_jacobian_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ekman-layer-depth">
<h3><a class="doc-anchor" href="#doc-ekman-layer-depth">#</a> <code>ekman_layer_depth</code></h3>
<p><code>ekman_layer_depth</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = ekman_layer_depth $x
# or in a pipeline:
@list |> map ekman_layer_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ekman-pumping-step">
<h3><a class="doc-anchor" href="#doc-ekman-pumping-step">#</a> <code>ekman_pumping_step</code></h3>
<p><code>ekman_pumping_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = ekman_pumping_step $x
# or in a pipeline:
@list |> map ekman_pumping_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electric-field">
<h3><a class="doc-anchor" href="#doc-electric-field">#</a> <code>electric_field</code></h3>
<p><code>electric_field</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = electric_field $x
# or in a pipeline:
@list |> map electric_field |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electrochem-impedance-z">
<h3><a class="doc-anchor" href="#doc-electrochem-impedance-z">#</a> <code>electrochem_impedance_z</code></h3>
<p><code>electrochem_impedance_z</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = electrochem_impedance_z $x
# or in a pipeline:
@list |> map electrochem_impedance_z |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electrochemiluminescence-yield">
<h3><a class="doc-anchor" href="#doc-electrochemiluminescence-yield">#</a> <code>electrochemiluminescence_yield</code></h3>
<p><code>electrochemiluminescence_yield</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = electrochemiluminescence_yield $x
# or in a pipeline:
@list |> map electrochemiluminescence_yield |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electrocrystallization-step">
<h3><a class="doc-anchor" href="#doc-electrocrystallization-step">#</a> <code>electrocrystallization_step</code></h3>
<p><code>electrocrystallization_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = electrocrystallization_step $x
# or in a pipeline:
@list |> map electrocrystallization_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electrode-potential-step">
<h3><a class="doc-anchor" href="#doc-electrode-potential-step">#</a> <code>electrode_potential_step</code></h3>
<p><code>electrode_potential_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = electrode_potential_step $x
# or in a pipeline:
@list |> map electrode_potential_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electrolysis-mass">
<h3><a class="doc-anchor" href="#doc-electrolysis-mass">#</a> <code>electrolysis_mass</code></h3>
<p><code>electrolysis_mass</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = electrolysis_mass $x
# or in a pipeline:
@list |> map electrolysis_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electrolyte-decomposition-temp">
<h3><a class="doc-anchor" href="#doc-electrolyte-decomposition-temp">#</a> <code>electrolyte_decomposition_temp</code></h3>
<p><code>electrolyte_decomposition_temp</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = electrolyte_decomposition_temp $x
# or in a pipeline:
@list |> map electrolyte_decomposition_temp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electrolyzer-voltage">
<h3><a class="doc-anchor" href="#doc-electrolyzer-voltage">#</a> <code>electrolyzer_voltage</code></h3>
<p><code>electrolyzer_voltage</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = electrolyzer_voltage $x
# or in a pipeline:
@list |> map electrolyzer_voltage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electron-mass">
<h3><a class="doc-anchor" href="#doc-electron-mass">#</a> <code>electron_mass</code></h3>
<p><code>electron_mass</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = electron_mass $x
# or in a pipeline:
@list |> map electron_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electroosmotic-velocity">
<h3><a class="doc-anchor" href="#doc-electroosmotic-velocity">#</a> <code>electroosmotic_velocity</code></h3>
<p><code>electroosmotic_velocity</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = electroosmotic_velocity $x
# or in a pipeline:
@list |> map electroosmotic_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elem-at">
<h3><a class="doc-anchor" href="#doc-elem-at">#</a> <code>elem_at</code></h3>
<p><code>elem_at</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = elem_at $x
# or in a pipeline:
@list |> map elem_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elem-index">
<h3><a class="doc-anchor" href="#doc-elem-index">#</a> <code>elem_index</code></h3>
<p><code>elem_index</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = elem_index $x
# or in a pipeline:
@list |> map elem_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elem-indices">
<h3><a class="doc-anchor" href="#doc-elem-indices">#</a> <code>elem_indices</code></h3>
<p><code>elem_indices</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = elem_indices $x
# or in a pipeline:
@list |> map elem_indices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elem-of">
<h3><a class="doc-anchor" href="#doc-elem-of">#</a> <code>elem_of</code></h3>
<p><code>elem_of</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = elem_of $x
# or in a pipeline:
@list |> map elem_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elementary-charge">
<h3><a class="doc-anchor" href="#doc-elementary-charge">#</a> <code>elementary_charge</code></h3>
<p><code>elementary_charge</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = elementary_charge $x
# or in a pipeline:
@list |> map elementary_charge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elgamal-encrypt">
<h3><a class="doc-anchor" href="#doc-elgamal-encrypt">#</a> <code>elgamal_encrypt</code></h3>
<p><code>elgamal_encrypt</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = elgamal_encrypt $x
# or in a pipeline:
@list |> map elgamal_encrypt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elias-delta-code">
<h3><a class="doc-anchor" href="#doc-elias-delta-code">#</a> <code>elias_delta_code</code></h3>
<p><code>elias_delta_code</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = elias_delta_code $x
# or in a pipeline:
@list |> map elias_delta_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elias-gamma-code">
<h3><a class="doc-anchor" href="#doc-elias-gamma-code">#</a> <code>elias_gamma_code</code></h3>
<p><code>elias_gamma_code</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = elias_gamma_code $x
# or in a pipeline:
@list |> map elias_gamma_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elidx">
<h3><a class="doc-anchor" href="#doc-elidx">#</a> <code>elidx</code></h3>
<p><code>elidx</code> — additional missing stdlib functions builtin. Alias for <code>elem_index</code>.</p>
<pre><code class="lang-perl">my $result = elidx $x
# or in a pipeline:
@list |> map elidx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elidxs">
<h3><a class="doc-anchor" href="#doc-elidxs">#</a> <code>elidxs</code></h3>
<p><code>elidxs</code> — additional missing stdlib functions builtin. Alias for <code>elem_indices</code>.</p>
<pre><code class="lang-perl">my $result = elidxs $x
# or in a pipeline:
@list |> map elidxs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellip-lp">
<h3><a class="doc-anchor" href="#doc-ellip-lp">#</a> <code>ellip_lp</code></h3>
<p><code>ellip_lp</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = ellip_lp $x
# or in a pipeline:
@list |> map ellip_lp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipe">
<h3><a class="doc-anchor" href="#doc-ellipe">#</a> <code>ellipe</code></h3>
<p><code>ellipe</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = ellipe $x
# or in a pipeline:
@list |> map ellipe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipk">
<h3><a class="doc-anchor" href="#doc-ellipk">#</a> <code>ellipk</code></h3>
<p><code>ellipk</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = ellipk $x
# or in a pipeline:
@list |> map ellipk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipperim">
<h3><a class="doc-anchor" href="#doc-ellipperim">#</a> <code>ellipperim</code></h3>
<p><code>ellipperim</code> — geometry (extended) builtin. Alias for <code>ellipse_perimeter</code>.</p>
<pre><code class="lang-perl">my $result = ellipperim $x
# or in a pipeline:
@list |> map ellipperim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipse-perimeter">
<h3><a class="doc-anchor" href="#doc-ellipse-perimeter">#</a> <code>ellipse_perimeter</code></h3>
<p><code>ellipse_perimeter($a, $b)</code> (alias <code>ellper</code>) — approximates the perimeter of an ellipse with semi-axes a and b. Uses Ramanujan's approximation.</p>
<pre><code class="lang-perl">p ellper(5, 3) # ~25.5
p ellper(10, 10) # ~62.8 (circle)
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipsis">
<h3><a class="doc-anchor" href="#doc-ellipsis">#</a> <code>ellipsis</code></h3>
<p><code>ellipsis</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = ellipsis $x
# or in a pipeline:
@list |> map ellipsis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipsoid-surface-approx">
<h3><a class="doc-anchor" href="#doc-ellipsoid-surface-approx">#</a> <code>ellipsoid_surface_approx</code></h3>
<p><code>ellipsoid_surface_approx</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = ellipsoid_surface_approx $x
# or in a pipeline:
@list |> map ellipsoid_surface_approx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipsoid-volume">
<h3><a class="doc-anchor" href="#doc-ellipsoid-volume">#</a> <code>ellipsoid_volume</code></h3>
<p><code>ellipsoid_volume</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = ellipsoid_volume $x
# or in a pipeline:
@list |> map ellipsoid_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elo-expected">
<h3><a class="doc-anchor" href="#doc-elo-expected">#</a> <code>elo_expected</code></h3>
<p><code>elo_expected</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = elo_expected $x
# or in a pipeline:
@list |> map elo_expected |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elo-update">
<h3><a class="doc-anchor" href="#doc-elo-update">#</a> <code>elo_update</code></h3>
<p><code>elo_update</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = elo_update $x
# or in a pipeline:
@list |> map elo_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elof">
<h3><a class="doc-anchor" href="#doc-elof">#</a> <code>elof</code></h3>
<p><code>elof</code> — haskell list functions builtin. Alias for <code>elem_of</code>.</p>
<pre><code class="lang-perl">my $result = elof $x
# or in a pipeline:
@list |> map elof |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elu">
<h3><a class="doc-anchor" href="#doc-elu">#</a> <code>elu</code></h3>
<p><code>elu</code> applies the Exponential Linear Unit: x if x≥0, alpha*(e^x - 1) otherwise.</p>
<pre><code class="lang-perl">p elu(1) # 1
p elu(-1) # -0.632
</code></pre>
</article>
<article class="doc-entry" id="doc-em-frequency">
<h3><a class="doc-anchor" href="#doc-em-frequency">#</a> <code>em_frequency</code></h3>
<p><code>em_frequency</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = em_frequency $x
# or in a pipeline:
@list |> map em_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-em-intensity">
<h3><a class="doc-anchor" href="#doc-em-intensity">#</a> <code>em_intensity</code></h3>
<p><code>em_intensity</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = em_intensity $x
# or in a pipeline:
@list |> map em_intensity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-em-step">
<h3><a class="doc-anchor" href="#doc-em-step">#</a> <code>em_step</code></h3>
<p><code>em_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = em_step $x
# or in a pipeline:
@list |> map em_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-em-wavelength">
<h3><a class="doc-anchor" href="#doc-em-wavelength">#</a> <code>em_wavelength</code></h3>
<p><code>em_wavelength</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = em_wavelength $x
# or in a pipeline:
@list |> map em_wavelength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-email-domain">
<h3><a class="doc-anchor" href="#doc-email-domain">#</a> <code>email_domain</code></h3>
<p><code>email_domain</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = email_domain $x
# or in a pipeline:
@list |> map email_domain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-email-local">
<h3><a class="doc-anchor" href="#doc-email-local">#</a> <code>email_local</code></h3>
<p><code>email_local</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = email_local $x
# or in a pipeline:
@list |> map email_local |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-emass">
<h3><a class="doc-anchor" href="#doc-emass">#</a> <code>emass</code></h3>
<p><code>emass</code> — constants builtin. Alias for <code>electron_mass</code>.</p>
<pre><code class="lang-perl">my $result = emass $x
# or in a pipeline:
@list |> map emass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-emavg">
<h3><a class="doc-anchor" href="#doc-emavg">#</a> <code>emavg</code></h3>
<p><code>emavg</code> — math / numeric (uncategorized batch) builtin. Alias for <code>exponential_moving_average</code>.</p>
<pre><code class="lang-perl">my $result = emavg $x
# or in a pipeline:
@list |> map emavg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-embed-ts">
<h3><a class="doc-anchor" href="#doc-embed-ts">#</a> <code>embed_ts</code></h3>
<p><code>embed_ts</code> — time-delay embedding. Converts a time series into a matrix of lagged values. Like R's embed().</p>
<pre><code class="lang-perl">p embed_ts([1,2,3,4,5], 3) # [[3,2,1],[4,3,2],[5,4,3]]
</code></pre>
</article>
<article class="doc-entry" id="doc-emboss-kernel">
<h3><a class="doc-anchor" href="#doc-emboss-kernel">#</a> <code>emboss_kernel</code></h3>
<p><code>emboss_kernel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = emboss_kernel $x
# or in a pipeline:
@list |> map emboss_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-emf-from-half-cells">
<h3><a class="doc-anchor" href="#doc-emf-from-half-cells">#</a> <code>emf_from_half_cells</code></h3>
<p><code>emf_from_half_cells</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = emf_from_half_cells $x
# or in a pipeline:
@list |> map emf_from_half_cells |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-emissivity-grey-body">
<h3><a class="doc-anchor" href="#doc-emissivity-grey-body">#</a> <code>emissivity_grey_body</code></h3>
<p><code>emissivity_grey_body</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = emissivity_grey_body $x
# or in a pipeline:
@list |> map emissivity_grey_body |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-emitted-long-wave">
<h3><a class="doc-anchor" href="#doc-emitted-long-wave">#</a> <code>emitted_long_wave</code></h3>
<p><code>emitted_long_wave</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = emitted_long_wave $x
# or in a pipeline:
@list |> map emitted_long_wave |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-emojinum">
<h3><a class="doc-anchor" href="#doc-emojinum">#</a> <code>emojinum</code></h3>
<p><code>emojinum</code> — encoding / phonetics builtin. Alias for <code>to_emoji_num</code>.</p>
<pre><code class="lang-perl">my $result = emojinum $x
# or in a pipeline:
@list |> map emojinum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-empc">
<h3><a class="doc-anchor" href="#doc-empc">#</a> <code>empc</code></h3>
<p><code>empc</code> — algebraic match builtin. Alias for <code>empty_clj</code>.</p>
<pre><code class="lang-perl">my $result = empc $x
# or in a pipeline:
@list |> map empc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-empty-clj">
<h3><a class="doc-anchor" href="#doc-empty-clj">#</a> <code>empty_clj</code></h3>
<p><code>empty_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = empty_clj $x
# or in a pipeline:
@list |> map empty_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-empty-count">
<h3><a class="doc-anchor" href="#doc-empty-count">#</a> <code>empty_count</code></h3>
<p><code>empty_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = empty_count $x
# or in a pipeline:
@list |> map empty_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-encode-base">
<h3><a class="doc-anchor" href="#doc-encode-base">#</a> <code>encode_base</code></h3>
<p><code>encode_base</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = encode_base $x
# or in a pipeline:
@list |> map encode_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-encode-pair">
<h3><a class="doc-anchor" href="#doc-encode-pair">#</a> <code>encode_pair</code></h3>
<p><code>encode_pair</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = encode_pair $x
# or in a pipeline:
@list |> map encode_pair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-encode-succ">
<h3><a class="doc-anchor" href="#doc-encode-succ">#</a> <code>encode_succ</code></h3>
<p><code>encode_succ</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = encode_succ $x
# or in a pipeline:
@list |> map encode_succ |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-end-of-day">
<h3><a class="doc-anchor" href="#doc-end-of-day">#</a> <code>end_of_day</code></h3>
<p><code>end_of_day</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = end_of_day $x
# or in a pipeline:
@list |> map end_of_day |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endgrent">
<h3><a class="doc-anchor" href="#doc-endgrent">#</a> <code>endgrent</code></h3>
<p><code>endgrent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endgrent $x
# or in a pipeline:
@list |> map endgrent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endhostent">
<h3><a class="doc-anchor" href="#doc-endhostent">#</a> <code>endhostent</code></h3>
<p><code>endhostent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endhostent $x
# or in a pipeline:
@list |> map endhostent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endianness">
<h3><a class="doc-anchor" href="#doc-endianness">#</a> <code>endianness</code></h3>
<p><code>endianness</code> — byte order of the platform: <code>"little"</code> or <code>"big"</code>. Compile-time constant.</p>
<pre><code class="lang-perl">p endianness # little
</code></pre>
</article>
<article class="doc-entry" id="doc-endnetent">
<h3><a class="doc-anchor" href="#doc-endnetent">#</a> <code>endnetent</code></h3>
<p><code>endnetent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endnetent $x
# or in a pipeline:
@list |> map endnetent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endowment-combined-a">
<h3><a class="doc-anchor" href="#doc-endowment-combined-a">#</a> <code>endowment_combined_a</code></h3>
<p><code>endowment_combined_a</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = endowment_combined_a $x
# or in a pipeline:
@list |> map endowment_combined_a |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endowment-pure-e">
<h3><a class="doc-anchor" href="#doc-endowment-pure-e">#</a> <code>endowment_pure_e</code></h3>
<p><code>endowment_pure_e</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = endowment_pure_e $x
# or in a pipeline:
@list |> map endowment_pure_e |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endprotoent">
<h3><a class="doc-anchor" href="#doc-endprotoent">#</a> <code>endprotoent</code></h3>
<p><code>endprotoent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endprotoent $x
# or in a pipeline:
@list |> map endprotoent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endpwent">
<h3><a class="doc-anchor" href="#doc-endpwent">#</a> <code>endpwent</code></h3>
<p><code>endpwent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endpwent $x
# or in a pipeline:
@list |> map endpwent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ends-with">
<h3><a class="doc-anchor" href="#doc-ends-with">#</a> <code>ends_with</code></h3>
<p><code>ends_with</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = ends_with $x
# or in a pipeline:
@list |> map ends_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ends-with-any">
<h3><a class="doc-anchor" href="#doc-ends-with-any">#</a> <code>ends_with_any</code></h3>
<p><code>ends_with_any</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = ends_with_any $x
# or in a pipeline:
@list |> map ends_with_any |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endservent">
<h3><a class="doc-anchor" href="#doc-endservent">#</a> <code>endservent</code></h3>
<p><code>endservent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endservent $x
# or in a pipeline:
@list |> map endservent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-energy">
<h3><a class="doc-anchor" href="#doc-energy">#</a> <code>energy</code></h3>
<p><code>energy(\@signal)</code> — computes the total energy of a signal as the sum of squared samples. Useful for audio analysis and feature extraction.</p>
<pre><code class="lang-perl">p energy(\@signal) # total signal energy
</code></pre>
</article>
<article class="doc-entry" id="doc-energy-density-battery">
<h3><a class="doc-anchor" href="#doc-energy-density-battery">#</a> <code>energy_density_battery</code></h3>
<p><code>energy_density_battery</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = energy_density_battery $x
# or in a pipeline:
@list |> map energy_density_battery |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-energy-efficiency-cell">
<h3><a class="doc-anchor" href="#doc-energy-efficiency-cell">#</a> <code>energy_efficiency_cell</code></h3>
<p><code>energy_efficiency_cell</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = energy_efficiency_cell $x
# or in a pipeline:
@list |> map energy_efficiency_cell |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-engel-curve">
<h3><a class="doc-anchor" href="#doc-engel-curve">#</a> <code>engel_curve</code></h3>
<p><code>engel_curve</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = engel_curve $x
# or in a pipeline:
@list |> map engel_curve |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-engle-granger-step">
<h3><a class="doc-anchor" href="#doc-engle-granger-step">#</a> <code>engle_granger_step</code></h3>
<p><code>engle_granger_step</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = engle_granger_step $x
# or in a pipeline:
@list |> map engle_granger_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-english-auction">
<h3><a class="doc-anchor" href="#doc-english-auction">#</a> <code>english_auction</code></h3>
<p><code>english_auction</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = english_auction $x
# or in a pipeline:
@list |> map english_auction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-english-auction-step">
<h3><a class="doc-anchor" href="#doc-english-auction-step">#</a> <code>english_auction_step</code></h3>
<p><code>english_auction_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = english_auction_step $x
# or in a pipeline:
@list |> map english_auction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-english-chi2">
<h3><a class="doc-anchor" href="#doc-english-chi2">#</a> <code>english_chi2</code></h3>
<p><code>english_chi2</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = english_chi2 $x
# or in a pipeline:
@list |> map english_chi2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-english-likeness">
<h3><a class="doc-anchor" href="#doc-english-likeness">#</a> <code>english_likeness</code></h3>
<p><code>english_likeness</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = english_likeness $x
# or in a pipeline:
@list |> map english_likeness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-enso-index-step">
<h3><a class="doc-anchor" href="#doc-enso-index-step">#</a> <code>enso_index_step</code></h3>
<p><code>enso_index_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = enso_index_step $x
# or in a pipeline:
@list |> map enso_index_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ensure-prefix">
<h3><a class="doc-anchor" href="#doc-ensure-prefix">#</a> <code>ensure_prefix</code></h3>
<p><code>ensure_prefix</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = ensure_prefix $x
# or in a pipeline:
@list |> map ensure_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ensure-suffix">
<h3><a class="doc-anchor" href="#doc-ensure-suffix">#</a> <code>ensure_suffix</code></h3>
<p><code>ensure_suffix</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = ensure_suffix $x
# or in a pipeline:
@list |> map ensure_suffix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-entanglement-entropy">
<h3><a class="doc-anchor" href="#doc-entanglement-entropy">#</a> <code>entanglement_entropy</code></h3>
<p><code>entanglement_entropy</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = entanglement_entropy $x
# or in a pipeline:
@list |> map entanglement_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-enthalpy-reaction">
<h3><a class="doc-anchor" href="#doc-enthalpy-reaction">#</a> <code>enthalpy_reaction</code></h3>
<p><code>enthalpy_reaction</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = enthalpy_reaction $x
# or in a pipeline:
@list |> map enthalpy_reaction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-entropy">
<h3><a class="doc-anchor" href="#doc-entropy">#</a> <code>entropy</code></h3>
<p><code>entropy</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = entropy $x
# or in a pipeline:
@list |> map entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-entropy-bits">
<h3><a class="doc-anchor" href="#doc-entropy-bits">#</a> <code>entropy_bits</code></h3>
<p><code>entropy_bits</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = entropy_bits $x
# or in a pipeline:
@list |> map entropy_bits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env">
<h3><a class="doc-anchor" href="#doc-env">#</a> <code>env</code></h3>
<p><code>env</code> — dsp / signal (extended) builtin. Alias for <code>envelope</code>.</p>
<pre><code class="lang-perl">my $result = env $x
# or in a pipeline:
@list |> map env |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-get">
<h3><a class="doc-anchor" href="#doc-env-get">#</a> <code>env_get</code></h3>
<p><code>env_get</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = env_get $x
# or in a pipeline:
@list |> map env_get |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-has">
<h3><a class="doc-anchor" href="#doc-env-has">#</a> <code>env_has</code></h3>
<p><code>env_has</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = env_has $x
# or in a pipeline:
@list |> map env_has |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-keys">
<h3><a class="doc-anchor" href="#doc-env-keys">#</a> <code>env_keys</code></h3>
<p><code>env_keys</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = env_keys $x
# or in a pipeline:
@list |> map env_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-pairs">
<h3><a class="doc-anchor" href="#doc-env-pairs">#</a> <code>env_pairs</code></h3>
<p><code>env_pairs</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = env_pairs $x
# or in a pipeline:
@list |> map env_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-remove">
<h3><a class="doc-anchor" href="#doc-env-remove">#</a> <code>env_remove</code></h3>
<p><code>env_remove</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = env_remove $x
# or in a pipeline:
@list |> map env_remove |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-set">
<h3><a class="doc-anchor" href="#doc-env-set">#</a> <code>env_set</code></h3>
<p><code>env_set</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = env_set $x
# or in a pipeline:
@list |> map env_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-envelope">
<h3><a class="doc-anchor" href="#doc-envelope">#</a> <code>envelope</code></h3>
<p><code>envelope(\@signal)</code> (alias <code>hilbert_env</code>) — computes the amplitude envelope using Hilbert transform magnitude. Useful for amplitude modulation analysis.</p>
<pre><code class="lang-perl">my $env = envelope(\@signal)
# $env traces the amplitude of oscillations
</code></pre>
</article>
<article class="doc-entry" id="doc-envelope-amplitude">
<h3><a class="doc-anchor" href="#doc-envelope-amplitude">#</a> <code>envelope_amplitude</code></h3>
<p><code>envelope_amplitude</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = envelope_amplitude $x
# or in a pipeline:
@list |> map envelope_amplitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eod">
<h3><a class="doc-anchor" href="#doc-eod">#</a> <code>eod</code></h3>
<p><code>eod</code> — extended stdlib builtin. Alias for <code>end_of_day</code>.</p>
<pre><code class="lang-perl">my $result = eod $x
# or in a pipeline:
@list |> map eod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eof-from-concurrence">
<h3><a class="doc-anchor" href="#doc-eof-from-concurrence">#</a> <code>eof_from_concurrence</code></h3>
<p><code>eof_from_concurrence</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = eof_from_concurrence $x
# or in a pipeline:
@list |> map eof_from_concurrence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epa-per-play">
<h3><a class="doc-anchor" href="#doc-epa-per-play">#</a> <code>epa_per_play</code></h3>
<p><code>epa_per_play</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = epa_per_play $x
# or in a pipeline:
@list |> map epa_per_play |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epoch">
<h3><a class="doc-anchor" href="#doc-epoch">#</a> <code>epoch</code></h3>
<p><code>epoch</code> — now / timestamp builtin. Alias for <code>unix_epoch</code>.</p>
<pre><code class="lang-perl">my $result = epoch $x
# or in a pipeline:
@list |> map epoch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epoch-ms">
<h3><a class="doc-anchor" href="#doc-epoch-ms">#</a> <code>epoch_ms</code></h3>
<p><code>epoch_ms</code> — now / timestamp builtin. Alias for <code>unix_epoch_ms</code>.</p>
<pre><code class="lang-perl">my $result = epoch_ms $x
# or in a pipeline:
@list |> map epoch_ms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epotential-point">
<h3><a class="doc-anchor" href="#doc-epotential-point">#</a> <code>epotential_point</code></h3>
<p><code>epotential_point</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = epotential_point $x
# or in a pipeline:
@list |> map epotential_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eps">
<h3><a class="doc-anchor" href="#doc-eps">#</a> <code>eps</code></h3>
<p><code>eps</code> — math / numeric (uncategorized batch) builtin. Alias for <code>epsilon</code>.</p>
<pre><code class="lang-perl">my $result = eps $x
# or in a pipeline:
@list |> map eps |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epsilon">
<h3><a class="doc-anchor" href="#doc-epsilon">#</a> <code>epsilon</code></h3>
<p><code>epsilon</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = epsilon $x
# or in a pipeline:
@list |> map epsilon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epsilon0">
<h3><a class="doc-anchor" href="#doc-epsilon0">#</a> <code>epsilon0</code></h3>
<p><code>vacuum_permittivity</code> (alias <code>epsilon0</code>) — ε₀ ≈ 8.854×10⁻¹² F/m. Electric constant, permittivity of free space.</p>
<pre><code class="lang-perl">p epsilon0 # 8.8541878128e-12
</code></pre>
</article>
<article class="doc-entry" id="doc-epsilon-extinction">
<h3><a class="doc-anchor" href="#doc-epsilon-extinction">#</a> <code>epsilon_extinction</code></h3>
<p><code>epsilon_extinction</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = epsilon_extinction $x
# or in a pipeline:
@list |> map epsilon_extinction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eqidx">
<h3><a class="doc-anchor" href="#doc-eqidx">#</a> <code>eqidx</code></h3>
<p><code>eqidx</code> — extended stdlib batch 3 builtin. Alias for <code>equilibrium_index</code>.</p>
<pre><code class="lang-perl">my $result = eqidx $x
# or in a pipeline:
@list |> map eqidx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eqrng">
<h3><a class="doc-anchor" href="#doc-eqrng">#</a> <code>eqrng</code></h3>
<p><code>eqrng</code> — extended stdlib builtin. Alias for <code>equal_range</code>.</p>
<pre><code class="lang-perl">my $result = eqrng $x
# or in a pipeline:
@list |> map eqrng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equal-range">
<h3><a class="doc-anchor" href="#doc-equal-range">#</a> <code>equal_range</code></h3>
<p><code>equal_range</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = equal_range $x
# or in a pipeline:
@list |> map equal_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equal-tempered-freq">
<h3><a class="doc-anchor" href="#doc-equal-tempered-freq">#</a> <code>equal_tempered_freq</code></h3>
<p><code>equal_tempered_freq</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = equal_tempered_freq $x
# or in a pipeline:
@list |> map equal_tempered_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equation-of-time">
<h3><a class="doc-anchor" href="#doc-equation-of-time">#</a> <code>equation_of_time</code></h3>
<p><code>equation_of_time</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = equation_of_time $x
# or in a pipeline:
@list |> map equation_of_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equatorial-to-galactic">
<h3><a class="doc-anchor" href="#doc-equatorial-to-galactic">#</a> <code>equatorial_to_galactic</code></h3>
<p><code>equatorial_to_galactic</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = equatorial_to_galactic $input
</code></pre>
</article>
<article class="doc-entry" id="doc-equilibrium-index">
<h3><a class="doc-anchor" href="#doc-equilibrium-index">#</a> <code>equilibrium_index</code></h3>
<p><code>equilibrium_index</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = equilibrium_index $x
# or in a pipeline:
@list |> map equilibrium_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equinox-spring">
<h3><a class="doc-anchor" href="#doc-equinox-spring">#</a> <code>equinox_spring</code></h3>
<p><code>equinox_spring</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = equinox_spring $x
# or in a pipeline:
@list |> map equinox_spring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equirectangular-project">
<h3><a class="doc-anchor" href="#doc-equirectangular-project">#</a> <code>equirectangular_project</code></h3>
<p><code>equirectangular_project</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = equirectangular_project $x
# or in a pipeline:
@list |> map equirectangular_project |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equivalent-potential-temp">
<h3><a class="doc-anchor" href="#doc-equivalent-potential-temp">#</a> <code>equivalent_potential_temp</code></h3>
<p><code>equivalent_potential_temp</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = equivalent_potential_temp $x
# or in a pipeline:
@list |> map equivalent_potential_temp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-era-plus">
<h3><a class="doc-anchor" href="#doc-era-plus">#</a> <code>era_plus</code></h3>
<p><code>era_plus</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = era_plus $x
# or in a pipeline:
@list |> map era_plus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-erf-approx">
<h3><a class="doc-anchor" href="#doc-erf-approx">#</a> <code>erf_approx</code></h3>
<p><code>erf_approx($x)</code> — error function. Used in probability, statistics, and partial differential equations.</p>
<pre><code class="lang-perl">p erf(1) # ~0.843
p erf(2) # ~0.995
</code></pre>
</article>
<article class="doc-entry" id="doc-erfcx">
<h3><a class="doc-anchor" href="#doc-erfcx">#</a> <code>erfcx</code></h3>
<p><code>erfcx</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = erfcx $x
# or in a pipeline:
@list |> map erfcx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-erfi">
<h3><a class="doc-anchor" href="#doc-erfi">#</a> <code>erfi</code></h3>
<p><code>erfi</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = erfi $x
# or in a pipeline:
@list |> map erfi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-error-correction-step">
<h3><a class="doc-anchor" href="#doc-error-correction-step">#</a> <code>error_correction_step</code></h3>
<p><code>error_correction_step</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = error_correction_step $x
# or in a pipeline:
@list |> map error_correction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ertel-pv-step">
<h3><a class="doc-anchor" href="#doc-ertel-pv-step">#</a> <code>ertel_pv_step</code></h3>
<p><code>ertel_pv_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = ertel_pv_step $x
# or in a pipeline:
@list |> map ertel_pv_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-escape-json">
<h3><a class="doc-anchor" href="#doc-escape-json">#</a> <code>escape_json</code></h3>
<p><code>escape_json</code> — json helpers builtin.</p>
<pre><code class="lang-perl">my $result = escape_json $x
# or in a pipeline:
@list |> map escape_json |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-escape-velocity">
<h3><a class="doc-anchor" href="#doc-escape-velocity">#</a> <code>escape_velocity</code></h3>
<p><code>escape_velocity($mass, $radius)</code> (alias <code>escvel</code>) — minimum velocity to escape gravitational field: v = √(2GM/r). Defaults to Earth values.</p>
<pre><code class="lang-perl">p escvel # ~11186 m/s (Earth)
p escvel(1.989e30, 6.96e8) # ~617 km/s (Sun)
</code></pre>
</article>
<article class="doc-entry" id="doc-escape-velocity-body">
<h3><a class="doc-anchor" href="#doc-escape-velocity-body">#</a> <code>escape_velocity_body</code></h3>
<p><code>escape_velocity_body</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = escape_velocity_body $x
# or in a pipeline:
@list |> map escape_velocity_body |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eslice">
<h3><a class="doc-anchor" href="#doc-eslice">#</a> <code>eslice</code></h3>
<p><code>eslice</code> — python/ruby stdlib builtin. Alias for <code>each_slice</code>.</p>
<pre><code class="lang-perl">my $result = eslice $x
# or in a pipeline:
@list |> map eslice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-et-freq-ratio">
<h3><a class="doc-anchor" href="#doc-et-freq-ratio">#</a> <code>et_freq_ratio</code></h3>
<p><code>et_freq_ratio</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = et_freq_ratio $x
# or in a pipeline:
@list |> map et_freq_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-etag-validate">
<h3><a class="doc-anchor" href="#doc-etag-validate">#</a> <code>etag_validate</code></h3>
<p><code>etag_validate</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = etag_validate $x
# or in a pipeline:
@list |> map etag_validate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-etd-rk2">
<h3><a class="doc-anchor" href="#doc-etd-rk2">#</a> <code>etd_rk2</code></h3>
<p><code>etd_rk2</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = etd_rk2 $x
# or in a pipeline:
@list |> map etd_rk2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eth-addr-check">
<h3><a class="doc-anchor" href="#doc-eth-addr-check">#</a> <code>eth_addr_check</code></h3>
<p><code>eth_addr_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = eth_addr_check $x
# or in a pipeline:
@list |> map eth_addr_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ethiopic-from-fixed">
<h3><a class="doc-anchor" href="#doc-ethiopic-from-fixed">#</a> <code>ethiopic_from_fixed</code></h3>
<p><code>ethiopic_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = ethiopic_from_fixed $x
# or in a pipeline:
@list |> map ethiopic_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-etot">
<h3><a class="doc-anchor" href="#doc-etot">#</a> <code>etot</code></h3>
<p><code>etot</code> — extended stdlib batch 3 builtin. Alias for <code>euler_totient</code>.</p>
<pre><code class="lang-perl">my $result = etot $x
# or in a pipeline:
@list |> map etot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eucdist">
<h3><a class="doc-anchor" href="#doc-eucdist">#</a> <code>eucdist</code></h3>
<p><code>eucdist</code> — math / numeric (uncategorized batch) builtin. Alias for <code>euclidean_distance</code>.</p>
<pre><code class="lang-perl">my $result = eucdist $x
# or in a pipeline:
@list |> map eucdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euclidean-distance">
<h3><a class="doc-anchor" href="#doc-euclidean-distance">#</a> <code>euclidean_distance</code></h3>
<p><code>euclidean_distance</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = euclidean_distance $x
# or in a pipeline:
@list |> map euclidean_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euclidean-distance-nd">
<h3><a class="doc-anchor" href="#doc-euclidean-distance-nd">#</a> <code>euclidean_distance_nd</code></h3>
<p><code>euclidean_distance_nd</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = euclidean_distance_nd $x
# or in a pipeline:
@list |> map euclidean_distance_nd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-char-complex">
<h3><a class="doc-anchor" href="#doc-euler-char-complex">#</a> <code>euler_char_complex</code></h3>
<p><code>euler_char_complex</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = euler_char_complex $x
# or in a pipeline:
@list |> map euler_char_complex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-characteristic">
<h3><a class="doc-anchor" href="#doc-euler-characteristic">#</a> <code>euler_characteristic</code></h3>
<p><code>euler_characteristic</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = euler_characteristic $x
# or in a pipeline:
@list |> map euler_characteristic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-e">
<h3><a class="doc-anchor" href="#doc-euler-e">#</a> <code>euler_e</code></h3>
<p><code>euler_e</code> — math / numeric (uncategorized batch) builtin. Alias for <code>euler_number</code>.</p>
<pre><code class="lang-perl">my $result = euler_e $x
# or in a pipeline:
@list |> map euler_e |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-lte">
<h3><a class="doc-anchor" href="#doc-euler-lte">#</a> <code>euler_lte</code></h3>
<p><code>euler_lte</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = euler_lte $x
# or in a pipeline:
@list |> map euler_lte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-mascheroni">
<h3><a class="doc-anchor" href="#doc-euler-mascheroni">#</a> <code>euler_mascheroni</code></h3>
<p><code>euler_mascheroni</code> (alias <code>gamma_const</code>) — Euler-Mascheroni constant γ ≈ 0.5772. Appears in number theory and analysis.</p>
<pre><code class="lang-perl">p euler_mascheroni # 0.5772156649015329
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-method">
<h3><a class="doc-anchor" href="#doc-euler-method">#</a> <code>euler_method</code></h3>
<p><code>euler_ode</code> (alias <code>euler_method</code>) solves an ODE dy/dt = f(t,y) using the Euler method. Returns [[t,y], ...].</p>
<pre><code class="lang-perl">my $sol = euler_ode(fn { $_[1] }, 0, 1, 0.01, 100) # exponential growth
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-number">
<h3><a class="doc-anchor" href="#doc-euler-number">#</a> <code>euler_number</code></h3>
<p><code>euler_number</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = euler_number $x
# or in a pipeline:
@list |> map euler_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-totient">
<h3><a class="doc-anchor" href="#doc-euler-totient">#</a> <code>euler_totient</code></h3>
<p><code>euler_totient</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = euler_totient $x
# or in a pipeline:
@list |> map euler_totient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eulerian-path-q">
<h3><a class="doc-anchor" href="#doc-eulerian-path-q">#</a> <code>eulerian_path_q</code></h3>
<p><code>eulerian_path_q</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = eulerian_path_q $x
# or in a pipeline:
@list |> map eulerian_path_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ev-to-joules">
<h3><a class="doc-anchor" href="#doc-ev-to-joules">#</a> <code>ev_to_joules</code></h3>
<p><code>ev_to_joules</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = ev_to_joules $input
</code></pre>
</article>
<article class="doc-entry" id="doc-eval-rpn">
<h3><a class="doc-anchor" href="#doc-eval-rpn">#</a> <code>eval_rpn</code></h3>
<p><code>eval_rpn</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = eval_rpn $x
# or in a pipeline:
@list |> map eval_rpn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-even">
<h3><a class="doc-anchor" href="#doc-even">#</a> <code>even</code></h3>
<p><code>even</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = even $x
# or in a pipeline:
@list |> map even |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-event-horizon-check">
<h3><a class="doc-anchor" href="#doc-event-horizon-check">#</a> <code>event_horizon_check</code></h3>
<p><code>event_horizon_check</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = event_horizon_check $x
# or in a pipeline:
@list |> map event_horizon_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-every-nth">
<h3><a class="doc-anchor" href="#doc-every-nth">#</a> <code>every_nth</code></h3>
<p><code>every_nth</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = every_nth $x
# or in a pipeline:
@list |> map every_nth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-evolutionary-stable-strategy">
<h3><a class="doc-anchor" href="#doc-evolutionary-stable-strategy">#</a> <code>evolutionary_stable_strategy</code></h3>
<p><code>evolutionary_stable_strategy</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = evolutionary_stable_strategy $x
# or in a pipeline:
@list |> map evolutionary_stable_strategy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ew">
<h3><a class="doc-anchor" href="#doc-ew">#</a> <code>ew</code></h3>
<p><code>ew</code> — trivial string ops builtin. Alias for <code>ends_with</code>.</p>
<pre><code class="lang-perl">my $result = ew $x
# or in a pipeline:
@list |> map ew |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ewma-smooth">
<h3><a class="doc-anchor" href="#doc-ewma-smooth">#</a> <code>ewma_smooth</code></h3>
<p><code>ewma_smooth</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = ewma_smooth $x
# or in a pipeline:
@list |> map ewma_smooth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ewo">
<h3><a class="doc-anchor" href="#doc-ewo">#</a> <code>ewo</code></h3>
<p><code>ewo</code> — additional missing stdlib functions builtin. Alias for <code>each_with_object</code>.</p>
<pre><code class="lang-perl">my $result = ewo $x
# or in a pipeline:
@list |> map ewo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ex-ante-value-check">
<h3><a class="doc-anchor" href="#doc-ex-ante-value-check">#</a> <code>ex_ante_value_check</code></h3>
<p><code>ex_ante_value_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = ex_ante_value_check $x
# or in a pipeline:
@list |> map ex_ante_value_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ex-post-value-check">
<h3><a class="doc-anchor" href="#doc-ex-post-value-check">#</a> <code>ex_post_value_check</code></h3>
<p><code>ex_post_value_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = ex_post_value_check $x
# or in a pipeline:
@list |> map ex_post_value_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exchange-current-density">
<h3><a class="doc-anchor" href="#doc-exchange-current-density">#</a> <code>exchange_current_density</code></h3>
<p><code>exchange_current_density</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = exchange_current_density $x
# or in a pipeline:
@list |> map exchange_current_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exe">
<h3><a class="doc-anchor" href="#doc-exe">#</a> <code>exe</code></h3>
<p><code>exe</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = exe $x
# or in a pipeline:
@list |> map exe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-executables">
<h3><a class="doc-anchor" href="#doc-executables">#</a> <code>executables</code></h3>
<p><code>executables</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = executables $x
# or in a pipeline:
@list |> map executables |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exists-key">
<h3><a class="doc-anchor" href="#doc-exists-key">#</a> <code>exists_key</code></h3>
<p><code>exists_key</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = exists_key $x
# or in a pipeline:
@list |> map exists_key |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exp2">
<h3><a class="doc-anchor" href="#doc-exp2">#</a> <code>exp2</code></h3>
<p><code>exp2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = exp2 $x
# or in a pipeline:
@list |> map exp2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exp-euler-step">
<h3><a class="doc-anchor" href="#doc-exp-euler-step">#</a> <code>exp_euler_step</code></h3>
<p><code>exp_euler_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = exp_euler_step $x
# or in a pipeline:
@list |> map exp_euler_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exp-golomb-code">
<h3><a class="doc-anchor" href="#doc-exp-golomb-code">#</a> <code>exp_golomb_code</code></h3>
<p><code>exp_golomb_code</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = exp_golomb_code $x
# or in a pipeline:
@list |> map exp_golomb_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exp-integral-e1">
<h3><a class="doc-anchor" href="#doc-exp-integral-e1">#</a> <code>exp_integral_e1</code></h3>
<p><code>exp_integral_e1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = exp_integral_e1 $x
# or in a pipeline:
@list |> map exp_integral_e1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exp-smooth-double">
<h3><a class="doc-anchor" href="#doc-exp-smooth-double">#</a> <code>exp_smooth_double</code></h3>
<p><code>exp_smooth_double</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = exp_smooth_double $x
# or in a pipeline:
@list |> map exp_smooth_double |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exp-smooth-simple">
<h3><a class="doc-anchor" href="#doc-exp-smooth-simple">#</a> <code>exp_smooth_simple</code></h3>
<p><code>exp_smooth_simple</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = exp_smooth_simple $x
# or in a pipeline:
@list |> map exp_smooth_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-expansion-scalar-step">
<h3><a class="doc-anchor" href="#doc-expansion-scalar-step">#</a> <code>expansion_scalar_step</code></h3>
<p><code>expansion_scalar_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = expansion_scalar_step $x
# or in a pipeline:
@list |> map expansion_scalar_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-expected-coverage">
<h3><a class="doc-anchor" href="#doc-expected-coverage">#</a> <code>expected_coverage</code></h3>
<p><code>expected_coverage</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = expected_coverage $x
# or in a pipeline:
@list |> map expected_coverage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-expenditure-function">
<h3><a class="doc-anchor" href="#doc-expenditure-function">#</a> <code>expenditure_function</code></h3>
<p><code>expenditure_function</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = expenditure_function $x
# or in a pipeline:
@list |> map expenditure_function |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-experience-factor">
<h3><a class="doc-anchor" href="#doc-experience-factor">#</a> <code>experience_factor</code></h3>
<p><code>experience_factor</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = experience_factor $x
# or in a pipeline:
@list |> map experience_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-expire">
<h3><a class="doc-anchor" href="#doc-expire">#</a> <code>expire</code></h3>
<p><code>expire</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = expire $x
# or in a pipeline:
@list |> map expire |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-explore-exploit-epsilon">
<h3><a class="doc-anchor" href="#doc-explore-exploit-epsilon">#</a> <code>explore_exploit_epsilon</code></h3>
<p><code>explore_exploit_epsilon</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = explore_exploit_epsilon $x
# or in a pipeline:
@list |> map explore_exploit_epsilon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exponential-moving-average">
<h3><a class="doc-anchor" href="#doc-exponential-moving-average">#</a> <code>exponential_moving_average</code></h3>
<p><code>exponential_moving_average</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = exponential_moving_average $x
# or in a pipeline:
@list |> map exponential_moving_average |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exponential-pdf">
<h3><a class="doc-anchor" href="#doc-exponential-pdf">#</a> <code>exponential_pdf</code></h3>
<p><code>exponential_pdf</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = exponential_pdf $x
# or in a pipeline:
@list |> map exponential_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exppdf">
<h3><a class="doc-anchor" href="#doc-exppdf">#</a> <code>exppdf</code></h3>
<p><code>exppdf</code> — math formulas builtin. Alias for <code>exponential_pdf</code>.</p>
<pre><code class="lang-perl">my $result = exppdf $x
# or in a pipeline:
@list |> map exppdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-extends">
<h3><a class="doc-anchor" href="#doc-extends">#</a> <code>extends</code></h3>
<p><code>extends</code> specifies parent classes for inheritance. Child classes inherit all fields and methods from parents.</p>
<pre><code class="lang-perl">class Animal { name: Str }
class Dog extends Animal { breed: Str }
class Hybrid extends Dog, Cat { } # multiple inheritance
</code></pre>
<p>Inherited fields appear first in construction order. Methods are resolved child-first (override pattern).</p>
</article>
<article class="doc-entry" id="doc-exterior-derivative-one-form">
<h3><a class="doc-anchor" href="#doc-exterior-derivative-one-form">#</a> <code>exterior_derivative_one_form</code></h3>
<p><code>exterior_derivative_one_form</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = exterior_derivative_one_form $x
# or in a pipeline:
@list |> map exterior_derivative_one_form |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-extract-between">
<h3><a class="doc-anchor" href="#doc-extract-between">#</a> <code>extract_between</code></h3>
<p><code>extract_between</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = extract_between $x
# or in a pipeline:
@list |> map extract_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-extrinsic-principal-curv">
<h3><a class="doc-anchor" href="#doc-extrinsic-principal-curv">#</a> <code>extrinsic_principal_curv</code></h3>
<p><code>extrinsic_principal_curv</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = extrinsic_principal_curv $x
# or in a pipeline:
@list |> map extrinsic_principal_curv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eye">
<h3><a class="doc-anchor" href="#doc-eye">#</a> <code>eye</code></h3>
<p><code>eye</code> — matrix / linear algebra builtin. Alias for <code>identity_matrix</code>.</p>
<pre><code class="lang-perl">my $result = eye $x
# or in a pipeline:
@list |> map eye |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eyring-k">
<h3><a class="doc-anchor" href="#doc-eyring-k">#</a> <code>eyring_k</code></h3>
<p><code>eyring_k</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = eyring_k $x
# or in a pipeline:
@list |> map eyring_k |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eyring-rate">
<h3><a class="doc-anchor" href="#doc-eyring-rate">#</a> <code>eyring_rate</code></h3>
<p><code>eyring_rate</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = eyring_rate $x
# or in a pipeline:
@list |> map eyring_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f">
<h3><a class="doc-anchor" href="#doc-f">#</a> <code>f</code></h3>
<p><code>f</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = f $x
# or in a pipeline:
@list |> map f |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f64-max">
<h3><a class="doc-anchor" href="#doc-f64-max">#</a> <code>f64_max</code></h3>
<p><code>f64_max</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = f64_max $x
# or in a pipeline:
@list |> map f64_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f64-min">
<h3><a class="doc-anchor" href="#doc-f64-min">#</a> <code>f64_min</code></h3>
<p><code>f64_min</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = f64_min $x
# or in a pipeline:
@list |> map f64_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f-beta">
<h3><a class="doc-anchor" href="#doc-f-beta">#</a> <code>f_beta</code></h3>
<p><code>f_beta</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = f_beta $x
# or in a pipeline:
@list |> map f_beta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f-pdf">
<h3><a class="doc-anchor" href="#doc-f-pdf">#</a> <code>f_pdf</code></h3>
<p><code>f_pdf</code> (alias <code>fpdf</code>) evaluates the F-distribution PDF at x with d1 and d2 degrees of freedom.</p>
<pre><code class="lang-perl">p fpdf(1.0, 5, 10)
</code></pre>
</article>
<article class="doc-entry" id="doc-f-statistic-pooled">
<h3><a class="doc-anchor" href="#doc-f-statistic-pooled">#</a> <code>f_statistic_pooled</code></h3>
<p><code>f_statistic_pooled</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = f_statistic_pooled $x
# or in a pipeline:
@list |> map f_statistic_pooled |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f-to-c">
<h3><a class="doc-anchor" href="#doc-f-to-c">#</a> <code>f_to_c</code></h3>
<p><code>f_to_c</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = f_to_c $input
</code></pre>
</article>
<article class="doc-entry" id="doc-f-to-k">
<h3><a class="doc-anchor" href="#doc-f-to-k">#</a> <code>f_to_k</code></h3>
<p><code>f_to_k</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = f_to_k $input
</code></pre>
</article>
<article class="doc-entry" id="doc-face-detect-haar">
<h3><a class="doc-anchor" href="#doc-face-detect-haar">#</a> <code>face_detect_haar</code></h3>
<p><code>face_detect_haar</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = face_detect_haar $x
# or in a pipeline:
@list |> map face_detect_haar |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fact">
<h3><a class="doc-anchor" href="#doc-fact">#</a> <code>fact</code></h3>
<p><code>fact</code> — trivial numeric / predicate builtins builtin. Alias for <code>factorial</code>.</p>
<pre><code class="lang-perl">my $result = fact $x
# or in a pipeline:
@list |> map fact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-factorial">
<h3><a class="doc-anchor" href="#doc-factorial">#</a> <code>factorial</code></h3>
<p><code>factorial</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = factorial $x
# or in a pipeline:
@list |> map factorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-factorial2">
<h3><a class="doc-anchor" href="#doc-factorial2">#</a> <code>factorial2</code></h3>
<p><code>factorial2</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = factorial2 $x
# or in a pipeline:
@list |> map factorial2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-factorialk">
<h3><a class="doc-anchor" href="#doc-factorialk">#</a> <code>factorialk</code></h3>
<p><code>factorialk</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = factorialk $x
# or in a pipeline:
@list |> map factorialk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-faf">
<h3><a class="doc-anchor" href="#doc-faf">#</a> <code>faf</code></h3>
<p><code>faf</code> — stress testing builtin. Alias for <code>fire_and_forget</code>.</p>
<pre><code class="lang-perl">my $result = faf $x
# or in a pipeline:
@list |> map faf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fair-division-envy-free">
<h3><a class="doc-anchor" href="#doc-fair-division-envy-free">#</a> <code>fair_division_envy_free</code></h3>
<p><code>fair_division_envy_free</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = fair_division_envy_free $x
# or in a pipeline:
@list |> map fair_division_envy_free |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-falf">
<h3><a class="doc-anchor" href="#doc-falf">#</a> <code>falf</code></h3>
<p><code>falf</code> — python/ruby stdlib builtin. Alias for <code>filterfalse</code>.</p>
<pre><code class="lang-perl">my $result = falf $x
# or in a pipeline:
@list |> map falf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fallback">
<h3><a class="doc-anchor" href="#doc-fallback">#</a> <code>fallback</code></h3>
<p><code>fallback</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = fallback $x
# or in a pipeline:
@list |> map fallback |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-falling-factorial">
<h3><a class="doc-anchor" href="#doc-falling-factorial">#</a> <code>falling_factorial</code></h3>
<p><code>falling_factorial</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = falling_factorial $x
# or in a pipeline:
@list |> map falling_factorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-false-position">
<h3><a class="doc-anchor" href="#doc-false-position">#</a> <code>false_position</code></h3>
<p><code>false_position</code> — batch 19 builtin. Alias for <code>regula_falsi</code>.</p>
<pre><code class="lang-perl">my $result = false_position $x
# or in a pipeline:
@list |> map false_position |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-falsy-count">
<h3><a class="doc-anchor" href="#doc-falsy-count">#</a> <code>falsy_count</code></h3>
<p><code>falsy_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = falsy_count $x
# or in a pipeline:
@list |> map falsy_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fano-inequality-bound">
<h3><a class="doc-anchor" href="#doc-fano-inequality-bound">#</a> <code>fano_inequality_bound</code></h3>
<p><code>fano_inequality_bound</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = fano_inequality_bound $x
# or in a pipeline:
@list |> map fano_inequality_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-faradaic-efficiency">
<h3><a class="doc-anchor" href="#doc-faradaic-efficiency">#</a> <code>faradaic_efficiency</code></h3>
<p><code>faradaic_efficiency</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = faradaic_efficiency $x
# or in a pipeline:
@list |> map faradaic_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-faraday">
<h3><a class="doc-anchor" href="#doc-faraday">#</a> <code>faraday</code></h3>
<p><code>faraday_constant</code> (alias <code>faraday</code>) — F ≈ 96485 C/mol. Charge per mole of electrons.</p>
<pre><code class="lang-perl">p faraday # 96485.33212
</code></pre>
</article>
<article class="doc-entry" id="doc-faraday-efficiency-h2">
<h3><a class="doc-anchor" href="#doc-faraday-efficiency-h2">#</a> <code>faraday_efficiency_h2</code></h3>
<p><code>faraday_efficiency_h2</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = faraday_efficiency_h2 $x
# or in a pipeline:
@list |> map faraday_efficiency_h2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-faraday-emf">
<h3><a class="doc-anchor" href="#doc-faraday-emf">#</a> <code>faraday_emf</code></h3>
<p><code>faraday_emf</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = faraday_emf $x
# or in a pipeline:
@list |> map faraday_emf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-faraday-mass-deposited">
<h3><a class="doc-anchor" href="#doc-faraday-mass-deposited">#</a> <code>faraday_mass_deposited</code></h3>
<p><code>faraday_mass_deposited</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = faraday_mass_deposited $x
# or in a pipeline:
@list |> map faraday_mass_deposited |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-farmhash-64">
<h3><a class="doc-anchor" href="#doc-farmhash-64">#</a> <code>farmhash_64</code></h3>
<p><code>farmhash_64</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = farmhash_64 $x
# or in a pipeline:
@list |> map farmhash_64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-farthest-insertion-step">
<h3><a class="doc-anchor" href="#doc-farthest-insertion-step">#</a> <code>farthest_insertion_step</code></h3>
<p><code>farthest_insertion_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = farthest_insertion_step $x
# or in a pipeline:
@list |> map farthest_insertion_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fb">
<h3><a class="doc-anchor" href="#doc-fb">#</a> <code>fb</code></h3>
<p><code>fb</code> — algorithms / puzzles builtin. Alias for <code>fizzbuzz</code>.</p>
<pre><code class="lang-perl">my $result = fb $x
# or in a pipeline:
@list |> map fb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fcntl">
<h3><a class="doc-anchor" href="#doc-fcntl">#</a> <code>fcntl</code></h3>
<p><code>fcntl</code> — ipc builtin.</p>
<pre><code class="lang-perl">my $result = fcntl $x
# or in a pipeline:
@list |> map fcntl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fcp">
<h3><a class="doc-anchor" href="#doc-fcp">#</a> <code>fcp</code></h3>
<p><code>fcp</code> — extended stdlib builtin. Alias for <code>from_code_point</code>.</p>
<pre><code class="lang-perl">my $result = fcp $x
# or in a pipeline:
@list |> map fcp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fdivop">
<h3><a class="doc-anchor" href="#doc-fdivop">#</a> <code>fdivop</code></h3>
<p><code>fdivop</code> — extended stdlib builtin. Alias for <code>floor_div_op</code>.</p>
<pre><code class="lang-perl">my $result = fdivop $x
# or in a pipeline:
@list |> map fdivop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-feet-to-m">
<h3><a class="doc-anchor" href="#doc-feet-to-m">#</a> <code>feet_to_m</code></h3>
<p><code>feet_to_m</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = feet_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-feet-to-meters">
<h3><a class="doc-anchor" href="#doc-feet-to-meters">#</a> <code>feet_to_meters</code></h3>
<p><code>feet_to_meters</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = feet_to_meters $input
</code></pre>
</article>
<article class="doc-entry" id="doc-feiga">
<h3><a class="doc-anchor" href="#doc-feiga">#</a> <code>feiga</code></h3>
<p><code>feiga</code> — math constants builtin. Alias for <code>feigenbaum_alpha</code>.</p>
<pre><code class="lang-perl">my $result = feiga $x
# or in a pipeline:
@list |> map feiga |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-feigd">
<h3><a class="doc-anchor" href="#doc-feigd">#</a> <code>feigd</code></h3>
<p><code>feigenbaum_delta</code> (alias <code>feigd</code>) — Feigenbaum constant δ ≈ 4.669. Universal constant in chaos theory.</p>
<pre><code class="lang-perl">p feigd # 4.669201609102990
</code></pre>
</article>
<article class="doc-entry" id="doc-feigenbaum-alpha">
<h3><a class="doc-anchor" href="#doc-feigenbaum-alpha">#</a> <code>feigenbaum_alpha</code></h3>
<p><code>feigenbaum_alpha</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = feigenbaum_alpha $x
# or in a pipeline:
@list |> map feigenbaum_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-feldspar-classify">
<h3><a class="doc-anchor" href="#doc-feldspar-classify">#</a> <code>feldspar_classify</code></h3>
<p><code>feldspar_classify</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = feldspar_classify $x
# or in a pipeline:
@list |> map feldspar_classify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-felsenstein-step">
<h3><a class="doc-anchor" href="#doc-felsenstein-step">#</a> <code>felsenstein_step</code></h3>
<p><code>felsenstein_step</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = felsenstein_step $x
# or in a pipeline:
@list |> map felsenstein_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-felzenszwalb-segment">
<h3><a class="doc-anchor" href="#doc-felzenszwalb-segment">#</a> <code>felzenszwalb_segment</code></h3>
<p><code>felzenszwalb_segment</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = felzenszwalb_segment $x
# or in a pipeline:
@list |> map felzenszwalb_segment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fenwick-build">
<h3><a class="doc-anchor" href="#doc-fenwick-build">#</a> <code>fenwick_build</code></h3>
<p><code>fenwick_build</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = fenwick_build $x
# or in a pipeline:
@list |> map fenwick_build |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fenwick-for">
<h3><a class="doc-anchor" href="#doc-fenwick-for">#</a> <code>fenwick_for</code></h3>
<p><code>fenwick_for</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = fenwick_for $x
# or in a pipeline:
@list |> map fenwick_for |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fenwick-query">
<h3><a class="doc-anchor" href="#doc-fenwick-query">#</a> <code>fenwick_query</code></h3>
<p><code>fenwick_query</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = fenwick_query $x
# or in a pipeline:
@list |> map fenwick_query |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fermat-factor">
<h3><a class="doc-anchor" href="#doc-fermat-factor">#</a> <code>fermat_factor</code></h3>
<p><code>fermat_factor</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = fermat_factor $x
# or in a pipeline:
@list |> map fermat_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fermi-dirac-int">
<h3><a class="doc-anchor" href="#doc-fermi-dirac-int">#</a> <code>fermi_dirac_int</code></h3>
<p><code>fermi_dirac_int</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = fermi_dirac_int $x
# or in a pipeline:
@list |> map fermi_dirac_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fermi-golden-rule">
<h3><a class="doc-anchor" href="#doc-fermi-golden-rule">#</a> <code>fermi_golden_rule</code></h3>
<p><code>fermi_golden_rule</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = fermi_golden_rule $x
# or in a pipeline:
@list |> map fermi_golden_rule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fermi-normal-step">
<h3><a class="doc-anchor" href="#doc-fermi-normal-step">#</a> <code>fermi_normal_step</code></h3>
<p><code>fermi_normal_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = fermi_normal_step $x
# or in a pipeline:
@list |> map fermi_normal_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ferrel-cell-step">
<h3><a class="doc-anchor" href="#doc-ferrel-cell-step">#</a> <code>ferrel_cell_step</code></h3>
<p><code>ferrel_cell_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = ferrel_cell_step $x
# or in a pipeline:
@list |> map ferrel_cell_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fetch-val">
<h3><a class="doc-anchor" href="#doc-fetch-val">#</a> <code>fetch_val</code></h3>
<p><code>fetch_val</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = fetch_val $x
# or in a pipeline:
@list |> map fetch_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ffact">
<h3><a class="doc-anchor" href="#doc-ffact">#</a> <code>ffact</code></h3>
<p><code>ffact</code> — math formulas builtin. Alias for <code>falling_factorial</code>.</p>
<pre><code class="lang-perl">my $result = ffact $x
# or in a pipeline:
@list |> map ffact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ffirst">
<h3><a class="doc-anchor" href="#doc-ffirst">#</a> <code>ffirst</code></h3>
<p><code>ffirst</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = ffirst $x
# or in a pipeline:
@list |> map ffirst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ffs">
<h3><a class="doc-anchor" href="#doc-ffs">#</a> <code>ffs</code></h3>
<p><code>ffs</code> — algebraic match builtin. Alias for <code>ffirst</code>.</p>
<pre><code class="lang-perl">my $result = ffs $x
# or in a pipeline:
@list |> map ffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fft-magnitude">
<h3><a class="doc-anchor" href="#doc-fft-magnitude">#</a> <code>fft_magnitude</code></h3>
<p><code>fft_magnitude</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = fft_magnitude $x
# or in a pipeline:
@list |> map fft_magnitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fftconvolve-step">
<h3><a class="doc-anchor" href="#doc-fftconvolve-step">#</a> <code>fftconvolve_step</code></h3>
<p><code>fftconvolve_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = fftconvolve_step $x
# or in a pipeline:
@list |> map fftconvolve_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fftmag">
<h3><a class="doc-anchor" href="#doc-fftmag">#</a> <code>fftmag</code></h3>
<p><code>fftmag</code> — math / numeric (uncategorized batch) builtin. Alias for <code>fft_magnitude</code>.</p>
<pre><code class="lang-perl">my $result = fftmag $x
# or in a pipeline:
@list |> map fftmag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fib">
<h3><a class="doc-anchor" href="#doc-fib">#</a> <code>fib</code></h3>
<p><code>fib</code> — trivial numeric / predicate builtins builtin. Alias for <code>fibonacci</code>.</p>
<pre><code class="lang-perl">my $result = fib $x
# or in a pipeline:
@list |> map fib |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fibonacci">
<h3><a class="doc-anchor" href="#doc-fibonacci">#</a> <code>fibonacci</code></h3>
<p><code>fibonacci</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = fibonacci $x
# or in a pipeline:
@list |> map fibonacci |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fibonacci-code">
<h3><a class="doc-anchor" href="#doc-fibonacci-code">#</a> <code>fibonacci_code</code></h3>
<p><code>fibonacci_code</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = fibonacci_code $x
# or in a pipeline:
@list |> map fibonacci_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fibonacci-seq">
<h3><a class="doc-anchor" href="#doc-fibonacci-seq">#</a> <code>fibonacci_seq</code></h3>
<p><code>fibonacci_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = fibonacci_seq $x
# or in a pipeline:
@list |> map fibonacci_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fibonacci-word">
<h3><a class="doc-anchor" href="#doc-fibonacci-word">#</a> <code>fibonacci_word</code></h3>
<p><code>fibonacci_word</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = fibonacci_word $x
# or in a pipeline:
@list |> map fibonacci_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fictitious-play-step">
<h3><a class="doc-anchor" href="#doc-fictitious-play-step">#</a> <code>fictitious_play_step</code></h3>
<p><code>fictitious_play_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = fictitious_play_step $x
# or in a pipeline:
@list |> map fictitious_play_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fidelity-pure-real">
<h3><a class="doc-anchor" href="#doc-fidelity-pure-real">#</a> <code>fidelity_pure_real</code></h3>
<p><code>fidelity_pure_real</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = fidelity_pure_real $x
# or in a pipeline:
@list |> map fidelity_pure_real |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fidx">
<h3><a class="doc-anchor" href="#doc-fidx">#</a> <code>fidx</code></h3>
<p><code>fidx</code> — python/ruby stdlib builtin. Alias for <code>find_index_fn</code>.</p>
<pre><code class="lang-perl">my $result = fidx $x
# or in a pipeline:
@list |> map fidx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-file-atime">
<h3><a class="doc-anchor" href="#doc-file-atime">#</a> <code>file_atime</code></h3>
<p><code>file_atime</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = file_atime $x
# or in a pipeline:
@list |> map file_atime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-file-ctime">
<h3><a class="doc-anchor" href="#doc-file-ctime">#</a> <code>file_ctime</code></h3>
<p><code>file_ctime</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = file_ctime $x
# or in a pipeline:
@list |> map file_ctime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-file-mtime">
<h3><a class="doc-anchor" href="#doc-file-mtime">#</a> <code>file_mtime</code></h3>
<p><code>file_mtime</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = file_mtime $x
# or in a pipeline:
@list |> map file_mtime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-file-size">
<h3><a class="doc-anchor" href="#doc-file-size">#</a> <code>file_size</code></h3>
<p><code>file_size</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = file_size $x
# or in a pipeline:
@list |> map file_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-files">
<h3><a class="doc-anchor" href="#doc-files">#</a> <code>files</code></h3>
<p><code>files</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = files $x
# or in a pipeline:
@list |> map files |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filesf">
<h3><a class="doc-anchor" href="#doc-filesf">#</a> <code>filesf</code></h3>
<p><code>filesf</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = filesf $x
# or in a pipeline:
@list |> map filesf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fill-arr">
<h3><a class="doc-anchor" href="#doc-fill-arr">#</a> <code>fill_arr</code></h3>
<p><code>fill_arr</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = fill_arr $x
# or in a pipeline:
@list |> map fill_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filla">
<h3><a class="doc-anchor" href="#doc-filla">#</a> <code>filla</code></h3>
<p><code>filla</code> — javascript array/object methods builtin. Alias for <code>fill_arr</code>.</p>
<pre><code class="lang-perl">my $result = filla $x
# or in a pipeline:
@list |> map filla |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-bilateral">
<h3><a class="doc-anchor" href="#doc-filter-bilateral">#</a> <code>filter_bilateral</code></h3>
<p><code>filter_bilateral</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = filter_bilateral $x
# or in a pipeline:
@list |> map filter_bilateral |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-chars">
<h3><a class="doc-anchor" href="#doc-filter-chars">#</a> <code>filter_chars</code></h3>
<p><code>filter_chars</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = filter_chars $x
# or in a pipeline:
@list |> map filter_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-indexed">
<h3><a class="doc-anchor" href="#doc-filter-indexed">#</a> <code>filter_indexed</code></h3>
<p><code>filter_indexed</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = filter_indexed $x
# or in a pipeline:
@list |> map filter_indexed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-map">
<h3><a class="doc-anchor" href="#doc-filter-map">#</a> <code>filter_map</code></h3>
<p><code>filter_map</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = filter_map $x
# or in a pipeline:
@list |> map filter_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-median">
<h3><a class="doc-anchor" href="#doc-filter-median">#</a> <code>filter_median</code></h3>
<p><code>filter_median</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = filter_median $x
# or in a pipeline:
@list |> map filter_median |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-nlmeans">
<h3><a class="doc-anchor" href="#doc-filter-nlmeans">#</a> <code>filter_nlmeans</code></h3>
<p><code>filter_nlmeans</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = filter_nlmeans $x
# or in a pipeline:
@list |> map filter_nlmeans |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-ts">
<h3><a class="doc-anchor" href="#doc-filter-ts">#</a> <code>filter_ts</code></h3>
<p><code>ts_filter</code> — linear convolution filter. Like R's filter(method='convolution').</p>
<pre><code class="lang-perl">my @smooth = @{ts_filter([1,5,2,8,3], [0.25,0.5,0.25])}
</code></pre>
</article>
<article class="doc-entry" id="doc-filterfalse">
<h3><a class="doc-anchor" href="#doc-filterfalse">#</a> <code>filterfalse</code></h3>
<p><code>filterfalse</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = filterfalse $x
# or in a pipeline:
@list |> map filterfalse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filtfilt-pad">
<h3><a class="doc-anchor" href="#doc-filtfilt-pad">#</a> <code>filtfilt_pad</code></h3>
<p><code>filtfilt_pad</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = filtfilt_pad $x
# or in a pipeline:
@list |> map filtfilt_pad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find">
<h3><a class="doc-anchor" href="#doc-find">#</a> <code>find</code></h3>
<p><code>find</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = find $x
# or in a pipeline:
@list |> map find |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-findinterval">
<h3><a class="doc-anchor" href="#doc-findinterval">#</a> <code>findInterval</code></h3>
<p><code>find_interval</code> — for each x, find which interval in breaks it falls into. Like R's findInterval().</p>
<pre><code class="lang-perl">p findInterval([1.5, 3.5, 7.5], [0, 2, 5, 10]) # [1, 2, 3]
</code></pre>
</article>
<article class="doc-entry" id="doc-find-all">
<h3><a class="doc-anchor" href="#doc-find-all">#</a> <code>find_all</code></h3>
<p><code>find_all</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = find_all $x
# or in a pipeline:
@list |> map find_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-all-indices">
<h3><a class="doc-anchor" href="#doc-find-all-indices">#</a> <code>find_all_indices</code></h3>
<p><code>find_all_indices</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = find_all_indices $x
# or in a pipeline:
@list |> map find_all_indices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-first">
<h3><a class="doc-anchor" href="#doc-find-first">#</a> <code>find_first</code></h3>
<p><code>find_first</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = find_first $x
# or in a pipeline:
@list |> map find_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-index">
<h3><a class="doc-anchor" href="#doc-find-index">#</a> <code>find_index</code></h3>
<p><code>find_index</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = find_index $x
# or in a pipeline:
@list |> map find_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-index-fn">
<h3><a class="doc-anchor" href="#doc-find-index-fn">#</a> <code>find_index_fn</code></h3>
<p><code>find_index_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = find_index_fn $x
# or in a pipeline:
@list |> map find_index_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-indices">
<h3><a class="doc-anchor" href="#doc-find-indices">#</a> <code>find_indices</code></h3>
<p><code>find_indices</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = find_indices $x
# or in a pipeline:
@list |> map find_indices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-last">
<h3><a class="doc-anchor" href="#doc-find-last">#</a> <code>find_last</code></h3>
<p><code>find_last</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = find_last $x
# or in a pipeline:
@list |> map find_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-last-index">
<h3><a class="doc-anchor" href="#doc-find-last-index">#</a> <code>find_last_index</code></h3>
<p><code>find_last_index</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = find_last_index $x
# or in a pipeline:
@list |> map find_last_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-map">
<h3><a class="doc-anchor" href="#doc-find-map">#</a> <code>find_map</code></h3>
<p><code>find_map</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = find_map $x
# or in a pipeline:
@list |> map find_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-finite-rate-lambda">
<h3><a class="doc-anchor" href="#doc-finite-rate-lambda">#</a> <code>finite_rate_lambda</code></h3>
<p><code>finite_rate_lambda</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = finite_rate_lambda $x
# or in a pipeline:
@list |> map finite_rate_lambda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fintushel-stern-step">
<h3><a class="doc-anchor" href="#doc-fintushel-stern-step">#</a> <code>fintushel_stern_step</code></h3>
<p><code>fintushel_stern_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = fintushel_stern_step $x
# or in a pipeline:
@list |> map fintushel_stern_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fip">
<h3><a class="doc-anchor" href="#doc-fip">#</a> <code>fip</code></h3>
<p><code>fip</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = fip $x
# or in a pipeline:
@list |> map fip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fir-lowpass-design">
<h3><a class="doc-anchor" href="#doc-fir-lowpass-design">#</a> <code>fir_lowpass_design</code></h3>
<p><code>fir_lowpass_design</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = fir_lowpass_design $x
# or in a pipeline:
@list |> map fir_lowpass_design |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fir-moving-average">
<h3><a class="doc-anchor" href="#doc-fir-moving-average">#</a> <code>fir_moving_average</code></h3>
<p><code>fir_moving_average</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = fir_moving_average $x
# or in a pipeline:
@list |> map fir_moving_average |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fire">
<h3><a class="doc-anchor" href="#doc-fire">#</a> <code>fire</code></h3>
<p><code>fire</code> — stress testing builtin.</p>
<pre><code class="lang-perl">my $result = fire $x
# or in a pipeline:
@list |> map fire |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fire-and-forget">
<h3><a class="doc-anchor" href="#doc-fire-and-forget">#</a> <code>fire_and_forget</code></h3>
<p><code>fire_and_forget</code> — stress testing builtin.</p>
<pre><code class="lang-perl">my $result = fire_and_forget $x
# or in a pipeline:
@list |> map fire_and_forget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-arg">
<h3><a class="doc-anchor" href="#doc-first-arg">#</a> <code>first_arg</code></h3>
<p><code>first_arg</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = first_arg $x
# or in a pipeline:
@list |> map first_arg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-elem">
<h3><a class="doc-anchor" href="#doc-first-elem">#</a> <code>first_elem</code></h3>
<p><code>first_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = first_elem $x
# or in a pipeline:
@list |> map first_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-eq">
<h3><a class="doc-anchor" href="#doc-first-eq">#</a> <code>first_eq</code></h3>
<p><code>first_eq</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = first_eq $x
# or in a pipeline:
@list |> map first_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-of-month">
<h3><a class="doc-anchor" href="#doc-first-of-month">#</a> <code>first_of_month</code></h3>
<p><code>first_of_month</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = first_of_month $x
# or in a pipeline:
@list |> map first_of_month |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-order-concentration">
<h3><a class="doc-anchor" href="#doc-first-order-concentration">#</a> <code>first_order_concentration</code></h3>
<p><code>first_order_concentration</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = first_order_concentration $x
# or in a pipeline:
@list |> map first_order_concentration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-order-half-life">
<h3><a class="doc-anchor" href="#doc-first-order-half-life">#</a> <code>first_order_half_life</code></h3>
<p><code>first_order_half_life</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = first_order_half_life $x
# or in a pipeline:
@list |> map first_order_half_life |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-price-seal">
<h3><a class="doc-anchor" href="#doc-first-price-seal">#</a> <code>first_price_seal</code></h3>
<p><code>first_price_seal</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = first_price_seal $x
# or in a pipeline:
@list |> map first_price_seal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-word">
<h3><a class="doc-anchor" href="#doc-first-word">#</a> <code>first_word</code></h3>
<p><code>first_word</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = first_word $x
# or in a pipeline:
@list |> map first_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-firwin2-freq">
<h3><a class="doc-anchor" href="#doc-firwin2-freq">#</a> <code>firwin2_freq</code></h3>
<p><code>firwin2_freq</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = firwin2_freq $x
# or in a pipeline:
@list |> map firwin2_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-firwin-bandpass">
<h3><a class="doc-anchor" href="#doc-firwin-bandpass">#</a> <code>firwin_bandpass</code></h3>
<p><code>firwin_bandpass</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = firwin_bandpass $x
# or in a pipeline:
@list |> map firwin_bandpass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-firwin-bandstop">
<h3><a class="doc-anchor" href="#doc-firwin-bandstop">#</a> <code>firwin_bandstop</code></h3>
<p><code>firwin_bandstop</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = firwin_bandstop $x
# or in a pipeline:
@list |> map firwin_bandstop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-firwin-highpass">
<h3><a class="doc-anchor" href="#doc-firwin-highpass">#</a> <code>firwin_highpass</code></h3>
<p><code>firwin_highpass</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = firwin_highpass $x
# or in a pipeline:
@list |> map firwin_highpass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-firwin-lowpass">
<h3><a class="doc-anchor" href="#doc-firwin-lowpass">#</a> <code>firwin_lowpass</code></h3>
<p><code>firwin_lowpass</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = firwin_lowpass $x
# or in a pipeline:
@list |> map firwin_lowpass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fiscal-year-us">
<h3><a class="doc-anchor" href="#doc-fiscal-year-us">#</a> <code>fiscal_year_us</code></h3>
<p><code>fiscal_year_us</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = fiscal_year_us $x
# or in a pipeline:
@list |> map fiscal_year_us |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fisher-info-metric">
<h3><a class="doc-anchor" href="#doc-fisher-info-metric">#</a> <code>fisher_info_metric</code></h3>
<p><code>fisher_info_metric</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = fisher_info_metric $x
# or in a pipeline:
@list |> map fisher_info_metric |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fisher-yates-shuffle">
<h3><a class="doc-anchor" href="#doc-fisher-yates-shuffle">#</a> <code>fisher_yates_shuffle</code></h3>
<p><code>fisher_yates_shuffle</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = fisher_yates_shuffle $x
# or in a pipeline:
@list |> map fisher_yates_shuffle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fista-step">
<h3><a class="doc-anchor" href="#doc-fista-step">#</a> <code>fista_step</code></h3>
<p><code>fista_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = fista_step $x
# or in a pipeline:
@list |> map fista_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-five-number-summary">
<h3><a class="doc-anchor" href="#doc-five-number-summary">#</a> <code>five_number_summary</code></h3>
<p><code>five_number_summary(@data)</code> (alias <code>fivenum</code>) — returns [min, Q1, median, Q3, max], the classic five-number summary used for box plots. Provides a quick view of data distribution.</p>
<pre><code class="lang-perl">my @data = 1:100
my $f = fivenum(@data)
p "min=$f->[0] Q1=$f->[1] med=$f->[2] Q3=$f->[3] max=$f->[4]"
</code></pre>
</article>
<article class="doc-entry" id="doc-fixed-from-french">
<h3><a class="doc-anchor" href="#doc-fixed-from-french">#</a> <code>fixed_from_french</code></h3>
<p><code>fixed_from_french</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = fixed_from_french $x
# or in a pipeline:
@list |> map fixed_from_french |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fixed-from-gregorian">
<h3><a class="doc-anchor" href="#doc-fixed-from-gregorian">#</a> <code>fixed_from_gregorian</code></h3>
<p><code>fixed_from_gregorian</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = fixed_from_gregorian $x
# or in a pipeline:
@list |> map fixed_from_gregorian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fixed-from-hebrew">
<h3><a class="doc-anchor" href="#doc-fixed-from-hebrew">#</a> <code>fixed_from_hebrew</code></h3>
<p><code>fixed_from_hebrew</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = fixed_from_hebrew $x
# or in a pipeline:
@list |> map fixed_from_hebrew |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fixed-from-islamic">
<h3><a class="doc-anchor" href="#doc-fixed-from-islamic">#</a> <code>fixed_from_islamic</code></h3>
<p><code>fixed_from_islamic</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = fixed_from_islamic $x
# or in a pipeline:
@list |> map fixed_from_islamic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fixed-from-julian">
<h3><a class="doc-anchor" href="#doc-fixed-from-julian">#</a> <code>fixed_from_julian</code></h3>
<p><code>fixed_from_julian</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = fixed_from_julian $x
# or in a pipeline:
@list |> map fixed_from_julian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fixed-from-persian">
<h3><a class="doc-anchor" href="#doc-fixed-from-persian">#</a> <code>fixed_from_persian</code></h3>
<p><code>fixed_from_persian</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = fixed_from_persian $x
# or in a pipeline:
@list |> map fixed_from_persian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fixed-quad">
<h3><a class="doc-anchor" href="#doc-fixed-quad">#</a> <code>fixed_quad</code></h3>
<p><code>fixed_quad</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = fixed_quad $x
# or in a pipeline:
@list |> map fixed_quad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fizzbuzz">
<h3><a class="doc-anchor" href="#doc-fizzbuzz">#</a> <code>fizzbuzz</code></h3>
<p><code>fizzbuzz</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = fizzbuzz $x
# or in a pipeline:
@list |> map fizzbuzz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-band-potential">
<h3><a class="doc-anchor" href="#doc-flat-band-potential">#</a> <code>flat_band_potential</code></h3>
<p><code>flat_band_potential</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = flat_band_potential $x
# or in a pipeline:
@list |> map flat_band_potential |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-depth">
<h3><a class="doc-anchor" href="#doc-flat-depth">#</a> <code>flat_depth</code></h3>
<p><code>flat_depth</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = flat_depth $x
# or in a pipeline:
@list |> map flat_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-map">
<h3><a class="doc-anchor" href="#doc-flat-map">#</a> <code>flat_map</code></h3>
<p><code>flat_map</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = flat_map $x
# or in a pipeline:
@list |> map flat_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-map-fn">
<h3><a class="doc-anchor" href="#doc-flat-map-fn">#</a> <code>flat_map_fn</code></h3>
<p><code>flat_map_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = flat_map_fn $x
# or in a pipeline:
@list |> map flat_map_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-maps">
<h3><a class="doc-anchor" href="#doc-flat-maps">#</a> <code>flat_maps</code></h3>
<p><code>flat_maps { BLOCK } LIST</code> — a lazy streaming flat-map that evaluates the block for each element and flattens the resulting lists into a single iterator. Where <code>maps</code> expects the block to return one value, <code>flat_maps</code> handles blocks that return zero or more values per element and concatenates them seamlessly. This is the streaming equivalent of calling <code>map</code> with a multi-value block. Use it in <code>|></code> chains when each input element fans out into multiple outputs and you want lazy evaluation.</p>
<pre><code class="lang-perl">1:3 |> flat_maps { (_, _ * 10) } |> e p
# 1 10 2 20 3 30
@nested |> flat_maps { @_ } |> e p # flatten array-of-arrays
</code></pre>
</article>
<article class="doc-entry" id="doc-flatnonzero">
<h3><a class="doc-anchor" href="#doc-flatnonzero">#</a> <code>flatnonzero</code></h3>
<p><code>flatnonzero</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = flatnonzero $x
# or in a pipeline:
@list |> map flatnonzero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flatten-deep">
<h3><a class="doc-anchor" href="#doc-flatten-deep">#</a> <code>flatten_deep</code></h3>
<p><code>flatten_deep</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = flatten_deep $x
# or in a pipeline:
@list |> map flatten_deep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flatten-once">
<h3><a class="doc-anchor" href="#doc-flatten-once">#</a> <code>flatten_once</code></h3>
<p><code>flatten_once</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = flatten_once $x
# or in a pipeline:
@list |> map flatten_once |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flattop-w">
<h3><a class="doc-anchor" href="#doc-flattop-w">#</a> <code>flattop_w</code></h3>
<p><code>flattop_w</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = flattop_w $x
# or in a pipeline:
@list |> map flattop_w |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fldr">
<h3><a class="doc-anchor" href="#doc-fldr">#</a> <code>fldr</code></h3>
<p><code>fldr</code> — rust iterator methods builtin. Alias for <code>fold_right</code>.</p>
<pre><code class="lang-perl">my $result = fldr $x
# or in a pipeline:
@list |> map fldr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flesch-kincaid-grade">
<h3><a class="doc-anchor" href="#doc-flesch-kincaid-grade">#</a> <code>flesch_kincaid_grade</code></h3>
<p><code>flesch_kincaid_grade</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = flesch_kincaid_grade $x
# or in a pipeline:
@list |> map flesch_kincaid_grade |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flesch-reading-ease">
<h3><a class="doc-anchor" href="#doc-flesch-reading-ease">#</a> <code>flesch_reading_ease</code></h3>
<p><code>flesch_reading_ease</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = flesch_reading_ease $x
# or in a pipeline:
@list |> map flesch_reading_ease |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flip-args">
<h3><a class="doc-anchor" href="#doc-flip-args">#</a> <code>flip_args</code></h3>
<p><code>flip_args</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = flip_args $x
# or in a pipeline:
@list |> map flip_args |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-float-bits">
<h3><a class="doc-anchor" href="#doc-float-bits">#</a> <code>float_bits</code></h3>
<p><code>float_bits</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = float_bits $x
# or in a pipeline:
@list |> map float_bits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floer-homology-rank">
<h3><a class="doc-anchor" href="#doc-floer-homology-rank">#</a> <code>floer_homology_rank</code></h3>
<p><code>floer_homology_rank</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = floer_homology_rank $x
# or in a pipeline:
@list |> map floer_homology_rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor">
<h3><a class="doc-anchor" href="#doc-floor">#</a> <code>floor</code></h3>
<p><code>floor</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = floor $x
# or in a pipeline:
@list |> map floor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor-div">
<h3><a class="doc-anchor" href="#doc-floor-div">#</a> <code>floor_div</code></h3>
<p><code>floor_div</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = floor_div $x
# or in a pipeline:
@list |> map floor_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor-div-op">
<h3><a class="doc-anchor" href="#doc-floor-div-op">#</a> <code>floor_div_op</code></h3>
<p><code>floor_div_op</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = floor_div_op $x
# or in a pipeline:
@list |> map floor_div_op |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor-each">
<h3><a class="doc-anchor" href="#doc-floor-each">#</a> <code>floor_each</code></h3>
<p><code>floor_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = floor_each $x
# or in a pipeline:
@list |> map floor_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor-mod">
<h3><a class="doc-anchor" href="#doc-floor-mod">#</a> <code>floor_mod</code></h3>
<p><code>floor_mod</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = floor_mod $x
# or in a pipeline:
@list |> map floor_mod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flow-shop-johnson-step">
<h3><a class="doc-anchor" href="#doc-flow-shop-johnson-step">#</a> <code>flow_shop_johnson_step</code></h3>
<p><code>flow_shop_johnson_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = flow_shop_johnson_step $x
# or in a pipeline:
@list |> map flow_shop_johnson_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floyd-warshall-step">
<h3><a class="doc-anchor" href="#doc-floyd-warshall-step">#</a> <code>floyd_warshall_step</code></h3>
<p><code>floyd_warshall_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = floyd_warshall_step $x
# or in a pipeline:
@list |> map floyd_warshall_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fltd">
<h3><a class="doc-anchor" href="#doc-fltd">#</a> <code>fltd</code></h3>
<p><code>fltd</code> — javascript array/object methods builtin. Alias for <code>flat_depth</code>.</p>
<pre><code class="lang-perl">my $result = fltd $x
# or in a pipeline:
@list |> map fltd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flti">
<h3><a class="doc-anchor" href="#doc-flti">#</a> <code>flti</code></h3>
<p><code>flti</code> — go/general functional utilities builtin. Alias for <code>filter_indexed</code>.</p>
<pre><code class="lang-perl">my $result = flti $x
# or in a pipeline:
@list |> map flti |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fltm">
<h3><a class="doc-anchor" href="#doc-fltm">#</a> <code>fltm</code></h3>
<p><code>fltm</code> — rust iterator methods builtin. Alias for <code>filter_map</code>.</p>
<pre><code class="lang-perl">my $result = fltm $x
# or in a pipeline:
@list |> map fltm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flux-richardson-full">
<h3><a class="doc-anchor" href="#doc-flux-richardson-full">#</a> <code>flux_richardson_full</code></h3>
<p><code>flux_richardson_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = flux_richardson_full $x
# or in a pipeline:
@list |> map flux_richardson_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fma">
<h3><a class="doc-anchor" href="#doc-fma">#</a> <code>fma</code></h3>
<p><code>fma</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = fma $x
# or in a pipeline:
@list |> map fma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fmadd">
<h3><a class="doc-anchor" href="#doc-fmadd">#</a> <code>fmadd</code></h3>
<p><code>fmadd</code> — extended stdlib builtin. Alias for <code>fused_mul_add</code>.</p>
<pre><code class="lang-perl">my $result = fmadd $x
# or in a pipeline:
@list |> map fmadd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fmf">
<h3><a class="doc-anchor" href="#doc-fmf">#</a> <code>fmf</code></h3>
<p><code>fmf</code> — python/ruby stdlib builtin. Alias for <code>flat_map_fn</code>.</p>
<pre><code class="lang-perl">my $result = fmf $x
# or in a pipeline:
@list |> map fmf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fmin-cobyla">
<h3><a class="doc-anchor" href="#doc-fmin-cobyla">#</a> <code>fmin_cobyla</code></h3>
<p><code>fmin_cobyla</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = fmin_cobyla $x
# or in a pipeline:
@list |> map fmin_cobyla |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fmin-powell">
<h3><a class="doc-anchor" href="#doc-fmin-powell">#</a> <code>fmin_powell</code></h3>
<p><code>fmin_powell</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = fmin_powell $x
# or in a pipeline:
@list |> map fmin_powell |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fmod">
<h3><a class="doc-anchor" href="#doc-fmod">#</a> <code>fmod</code></h3>
<p><code>fmod</code> — extended stdlib builtin. Alias for <code>floor_mod</code>.</p>
<pre><code class="lang-perl">my $result = fmod $x
# or in a pipeline:
@list |> map fmod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndalli">
<h3><a class="doc-anchor" href="#doc-fndalli">#</a> <code>fndalli</code></h3>
<p><code>fndalli</code> — extended stdlib builtin. Alias for <code>find_all_indices</code>.</p>
<pre><code class="lang-perl">my $result = fndalli $x
# or in a pipeline:
@list |> map fndalli |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndidxs">
<h3><a class="doc-anchor" href="#doc-fndidxs">#</a> <code>fndidxs</code></h3>
<p><code>fndidxs</code> — additional missing stdlib functions builtin. Alias for <code>find_indices</code>.</p>
<pre><code class="lang-perl">my $result = fndidxs $x
# or in a pipeline:
@list |> map fndidxs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndl">
<h3><a class="doc-anchor" href="#doc-fndl">#</a> <code>fndl</code></h3>
<p><code>fndl</code> — javascript array/object methods builtin. Alias for <code>find_last</code>.</p>
<pre><code class="lang-perl">my $result = fndl $x
# or in a pipeline:
@list |> map fndl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndli">
<h3><a class="doc-anchor" href="#doc-fndli">#</a> <code>fndli</code></h3>
<p><code>fndli</code> — javascript array/object methods builtin. Alias for <code>find_last_index</code>.</p>
<pre><code class="lang-perl">my $result = fndli $x
# or in a pipeline:
@list |> map fndli |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndm">
<h3><a class="doc-anchor" href="#doc-fndm">#</a> <code>fndm</code></h3>
<p><code>fndm</code> — rust iterator methods builtin. Alias for <code>find_map</code>.</p>
<pre><code class="lang-perl">my $result = fndm $x
# or in a pipeline:
@list |> map fndm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fne">
<h3><a class="doc-anchor" href="#doc-fne">#</a> <code>fne</code></h3>
<p><code>fne</code> — algebraic match builtin. Alias for <code>fnext</code>.</p>
<pre><code class="lang-perl">my $result = fne $x
# or in a pipeline:
@list |> map fne |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fnext">
<h3><a class="doc-anchor" href="#doc-fnext">#</a> <code>fnext</code></h3>
<p><code>fnext</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = fnext $x
# or in a pipeline:
@list |> map fnext |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fnv0-32">
<h3><a class="doc-anchor" href="#doc-fnv0-32">#</a> <code>fnv0_32</code></h3>
<p><code>fnv0_32</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = fnv0_32 $x
# or in a pipeline:
@list |> map fnv0_32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fnv1a">
<h3><a class="doc-anchor" href="#doc-fnv1a">#</a> <code>fnv1a</code></h3>
<p><code>fnv1a</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = fnv1a $x
# or in a pipeline:
@list |> map fnv1a |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fnv1a-32">
<h3><a class="doc-anchor" href="#doc-fnv1a-32">#</a> <code>fnv1a_32</code></h3>
<p><code>fnv1a_32</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = fnv1a_32 $x
# or in a pipeline:
@list |> map fnv1a_32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fnv1a-64">
<h3><a class="doc-anchor" href="#doc-fnv1a-64">#</a> <code>fnv1a_64</code></h3>
<p><code>fnv1a_64</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = fnv1a_64 $x
# or in a pipeline:
@list |> map fnv1a_64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fnv1a-hash">
<h3><a class="doc-anchor" href="#doc-fnv1a-hash">#</a> <code>fnv1a_hash</code></h3>
<p><code>fnv1a_hash</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = fnv1a_hash $x
# or in a pipeline:
@list |> map fnv1a_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fold-axis">
<h3><a class="doc-anchor" href="#doc-fold-axis">#</a> <code>fold_axis</code></h3>
<p><code>fold_axis</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = fold_axis $x
# or in a pipeline:
@list |> map fold_axis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fold-left">
<h3><a class="doc-anchor" href="#doc-fold-left">#</a> <code>fold_left</code></h3>
<p><code>fold_left</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = fold_left $x
# or in a pipeline:
@list |> map fold_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fold-right">
<h3><a class="doc-anchor" href="#doc-fold-right">#</a> <code>fold_right</code></h3>
<p><code>fold_right</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = fold_right $x
# or in a pipeline:
@list |> map fold_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-folk-theorem-value">
<h3><a class="doc-anchor" href="#doc-folk-theorem-value">#</a> <code>folk_theorem_value</code></h3>
<p><code>folk_theorem_value</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = folk_theorem_value $x
# or in a pipeline:
@list |> map folk_theorem_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-force-mass-acc">
<h3><a class="doc-anchor" href="#doc-force-mass-acc">#</a> <code>force_mass_acc</code></h3>
<p><code>force_mass_acc</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = force_mass_acc $x
# or in a pipeline:
@list |> map force_mass_acc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-force-of-mortality">
<h3><a class="doc-anchor" href="#doc-force-of-mortality">#</a> <code>force_of_mortality</code></h3>
<p><code>force_of_mortality</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = force_of_mortality $x
# or in a pipeline:
@list |> map force_of_mortality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ford-fulkerson-step">
<h3><a class="doc-anchor" href="#doc-ford-fulkerson-step">#</a> <code>ford_fulkerson_step</code></h3>
<p><code>ford_fulkerson_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = ford_fulkerson_step $x
# or in a pipeline:
@list |> map ford_fulkerson_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-formal-charge">
<h3><a class="doc-anchor" href="#doc-formal-charge">#</a> <code>formal_charge</code></h3>
<p><code>formal_charge</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = formal_charge $x
# or in a pipeline:
@list |> map formal_charge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-bytes">
<h3><a class="doc-anchor" href="#doc-format-bytes">#</a> <code>format_bytes</code></h3>
<p><code>format_bytes</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = format_bytes $x
# or in a pipeline:
@list |> map format_bytes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-duration">
<h3><a class="doc-anchor" href="#doc-format-duration">#</a> <code>format_duration</code></h3>
<p><code>format_duration</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = format_duration $x
# or in a pipeline:
@list |> map format_duration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-number">
<h3><a class="doc-anchor" href="#doc-format-number">#</a> <code>format_number</code></h3>
<p><code>format_number</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = format_number $x
# or in a pipeline:
@list |> map format_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-percent">
<h3><a class="doc-anchor" href="#doc-format-percent">#</a> <code>format_percent</code></h3>
<p><code>format_percent</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = format_percent $x
# or in a pipeline:
@list |> map format_percent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-table-simple">
<h3><a class="doc-anchor" href="#doc-format-table-simple">#</a> <code>format_table_simple</code></h3>
<p><code>format_table_simple</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = format_table_simple $x
# or in a pipeline:
@list |> map format_table_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-forward-backward-pos">
<h3><a class="doc-anchor" href="#doc-forward-backward-pos">#</a> <code>forward_backward_pos</code></h3>
<p><code>forward_backward_pos</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = forward_backward_pos $x
# or in a pipeline:
@list |> map forward_backward_pos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-forward-kinematics-dh">
<h3><a class="doc-anchor" href="#doc-forward-kinematics-dh">#</a> <code>forward_kinematics_dh</code></h3>
<p><code>forward_kinematics_dh</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = forward_kinematics_dh $x
# or in a pipeline:
@list |> map forward_kinematics_dh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-forward-rate">
<h3><a class="doc-anchor" href="#doc-forward-rate">#</a> <code>forward_rate</code></h3>
<p><code>forward_rate</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = forward_rate $x
# or in a pipeline:
@list |> map forward_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fourier-number-step">
<h3><a class="doc-anchor" href="#doc-fourier-number-step">#</a> <code>fourier_number_step</code></h3>
<p><code>fourier_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = fourier_number_step $x
# or in a pipeline:
@list |> map fourier_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fp-depression">
<h3><a class="doc-anchor" href="#doc-fp-depression">#</a> <code>fp_depression</code></h3>
<p><code>fp_depression</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = fp_depression $x
# or in a pipeline:
@list |> map fp_depression |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fr">
<h3><a class="doc-anchor" href="#doc-fr">#</a> <code>fr</code></h3>
<p><code>fr</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = fr $x
# or in a pipeline:
@list |> map fr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-frac-part">
<h3><a class="doc-anchor" href="#doc-frac-part">#</a> <code>frac_part</code></h3>
<p><code>frac_part</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = frac_part $x
# or in a pipeline:
@list |> map frac_part |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fracp">
<h3><a class="doc-anchor" href="#doc-fracp">#</a> <code>fracp</code></h3>
<p><code>fracp</code> — extended stdlib builtin. Alias for <code>frac_part</code>.</p>
<pre><code class="lang-perl">my $result = fracp $x
# or in a pipeline:
@list |> map fracp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fractional-chromatic-lower">
<h3><a class="doc-anchor" href="#doc-fractional-chromatic-lower">#</a> <code>fractional_chromatic_lower</code></h3>
<p><code>fractional_chromatic_lower</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = fractional_chromatic_lower $x
# or in a pipeline:
@list |> map fractional_chromatic_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-frank-wolfe-step">
<h3><a class="doc-anchor" href="#doc-frank-wolfe-step">#</a> <code>frank_wolfe_step</code></h3>
<p><code>frank_wolfe_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = frank_wolfe_step $x
# or in a pipeline:
@list |> map frank_wolfe_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fredkin-gate">
<h3><a class="doc-anchor" href="#doc-fredkin-gate">#</a> <code>fredkin_gate</code></h3>
<p><code>fredkin_gate</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = fredkin_gate $x
# or in a pipeline:
@list |> map fredkin_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-free-energy-principle">
<h3><a class="doc-anchor" href="#doc-free-energy-principle">#</a> <code>free_energy_principle</code></h3>
<p><code>free_energy_principle</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = free_energy_principle $x
# or in a pipeline:
@list |> map free_energy_principle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-free-group-rank-lower">
<h3><a class="doc-anchor" href="#doc-free-group-rank-lower">#</a> <code>free_group_rank_lower</code></h3>
<p><code>free_group_rank_lower</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = free_group_rank_lower $x
# or in a pipeline:
@list |> map free_group_rank_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-free-particle-energy">
<h3><a class="doc-anchor" href="#doc-free-particle-energy">#</a> <code>free_particle_energy</code></h3>
<p><code>free_particle_energy</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = free_particle_energy $x
# or in a pipeline:
@list |> map free_particle_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-freefall-time">
<h3><a class="doc-anchor" href="#doc-freefall-time">#</a> <code>freefall_time</code></h3>
<p><code>freefall_time</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = freefall_time $x
# or in a pipeline:
@list |> map freefall_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-freefall-velocity-schwarzschild">
<h3><a class="doc-anchor" href="#doc-freefall-velocity-schwarzschild">#</a> <code>freefall_velocity_schwarzschild</code></h3>
<p><code>freefall_velocity_schwarzschild</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = freefall_velocity_schwarzschild $x
# or in a pipeline:
@list |> map freefall_velocity_schwarzschild |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-french-revolutionary-leap">
<h3><a class="doc-anchor" href="#doc-french-revolutionary-leap">#</a> <code>french_revolutionary_leap</code></h3>
<p><code>french_revolutionary_leap</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = french_revolutionary_leap $x
# or in a pipeline:
@list |> map french_revolutionary_leap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-freq-wavelength">
<h3><a class="doc-anchor" href="#doc-freq-wavelength">#</a> <code>freq_wavelength</code></h3>
<p><code>freq_wavelength</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = freq_wavelength $x
# or in a pipeline:
@list |> map freq_wavelength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-freqs-eval">
<h3><a class="doc-anchor" href="#doc-freqs-eval">#</a> <code>freqs_eval</code></h3>
<p><code>freqs_eval</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = freqs_eval $x
# or in a pipeline:
@list |> map freqs_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-freqz-eval">
<h3><a class="doc-anchor" href="#doc-freqz-eval">#</a> <code>freqz_eval</code></h3>
<p><code>freqz_eval</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = freqz_eval $x
# or in a pipeline:
@list |> map freqz_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fresnel-reflection-normal">
<h3><a class="doc-anchor" href="#doc-fresnel-reflection-normal">#</a> <code>fresnel_reflection_normal</code></h3>
<p><code>fresnel_reflection_normal</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = fresnel_reflection_normal $x
# or in a pipeline:
@list |> map fresnel_reflection_normal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fresnel-rp">
<h3><a class="doc-anchor" href="#doc-fresnel-rp">#</a> <code>fresnel_rp</code></h3>
<p><code>fresnel_rp</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = fresnel_rp $x
# or in a pipeline:
@list |> map fresnel_rp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fresnel-rs">
<h3><a class="doc-anchor" href="#doc-fresnel-rs">#</a> <code>fresnel_rs</code></h3>
<p><code>fresnel_rs</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = fresnel_rs $x
# or in a pipeline:
@list |> map fresnel_rs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-friction-factor-laminar">
<h3><a class="doc-anchor" href="#doc-friction-factor-laminar">#</a> <code>friction_factor_laminar</code></h3>
<p><code>friction_factor_laminar</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = friction_factor_laminar $x
# or in a pipeline:
@list |> map friction_factor_laminar |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-friedmann-density-total">
<h3><a class="doc-anchor" href="#doc-friedmann-density-total">#</a> <code>friedmann_density_total</code></h3>
<p><code>friedmann_density_total</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = friedmann_density_total $x
# or in a pipeline:
@list |> map friedmann_density_total |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-base">
<h3><a class="doc-anchor" href="#doc-from-base">#</a> <code>from_base</code></h3>
<p><code>from_base</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = from_base $x
# or in a pipeline:
@list |> map from_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-bin">
<h3><a class="doc-anchor" href="#doc-from-bin">#</a> <code>from_bin</code></h3>
<p><code>from_bin</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = from_bin $x
# or in a pipeline:
@list |> map from_bin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-code-point">
<h3><a class="doc-anchor" href="#doc-from-code-point">#</a> <code>from_code_point</code></h3>
<p><code>from_code_point</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = from_code_point $x
# or in a pipeline:
@list |> map from_code_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-csv-line">
<h3><a class="doc-anchor" href="#doc-from-csv-line">#</a> <code>from_csv_line</code></h3>
<p><code>from_csv_line</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = from_csv_line $x
# or in a pipeline:
@list |> map from_csv_line |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-digits">
<h3><a class="doc-anchor" href="#doc-from-digits">#</a> <code>from_digits</code></h3>
<p><code>from_digits</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = from_digits $x
# or in a pipeline:
@list |> map from_digits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-hex">
<h3><a class="doc-anchor" href="#doc-from-hex">#</a> <code>from_hex</code></h3>
<p><code>from_hex</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = from_hex $x
# or in a pipeline:
@list |> map from_hex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-oct">
<h3><a class="doc-anchor" href="#doc-from-oct">#</a> <code>from_oct</code></h3>
<p><code>from_oct</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = from_oct $x
# or in a pipeline:
@list |> map from_oct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-pairs">
<h3><a class="doc-anchor" href="#doc-from-pairs">#</a> <code>from_pairs</code></h3>
<p><code>from_pairs</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = from_pairs $x
# or in a pipeline:
@list |> map from_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-froude-number">
<h3><a class="doc-anchor" href="#doc-froude-number">#</a> <code>froude_number</code></h3>
<p><code>froude_number</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = froude_number $x
# or in a pipeline:
@list |> map froude_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-froude-number-step">
<h3><a class="doc-anchor" href="#doc-froude-number-step">#</a> <code>froude_number_step</code></h3>
<p><code>froude_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = froude_number_step $x
# or in a pipeline:
@list |> map froude_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-frustum-volume">
<h3><a class="doc-anchor" href="#doc-frustum-volume">#</a> <code>frustum_volume</code></h3>
<p><code>frustum_volume($r1, $r2, $h)</code> — computes the volume of a conical frustum (truncated cone) with base radii r1 and r2 and height h.</p>
<pre><code class="lang-perl">p frustum_volume(5, 3, 10) # ~513
</code></pre>
</article>
<article class="doc-entry" id="doc-frustvol">
<h3><a class="doc-anchor" href="#doc-frustvol">#</a> <code>frustvol</code></h3>
<p><code>frustvol</code> — geometry (extended) builtin. Alias for <code>frustum_volume</code>.</p>
<pre><code class="lang-perl">my $result = frustvol $x
# or in a pipeline:
@list |> map frustvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fsize">
<h3><a class="doc-anchor" href="#doc-fsize">#</a> <code>fsize</code></h3>
<p><code>fsize</code> — file stat / path builtin. Alias for <code>file_size</code>.</p>
<pre><code class="lang-perl">my $result = fsize $x
# or in a pipeline:
@list |> map fsize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fst">
<h3><a class="doc-anchor" href="#doc-fst">#</a> <code>fst</code></h3>
<p><code>fst</code> — functional / iterator builtin. Alias for <code>first</code>.</p>
<pre><code class="lang-perl">my $result = fst $x
# or in a pipeline:
@list |> map fst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ft">
<h3><a class="doc-anchor" href="#doc-ft">#</a> <code>ft</code></h3>
<p><code>ft</code> — data / network builtin. Alias for <code>fetch</code>.</p>
<pre><code class="lang-perl">my $result = ft $x
# or in a pipeline:
@list |> map ft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fta">
<h3><a class="doc-anchor" href="#doc-fta">#</a> <code>fta</code></h3>
<p><code>fta</code> — data / network builtin. Alias for <code>fetch_async</code>.</p>
<pre><code class="lang-perl">my $result = fta $x
# or in a pipeline:
@list |> map fta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ftaj">
<h3><a class="doc-anchor" href="#doc-ftaj">#</a> <code>ftaj</code></h3>
<p><code>ftaj</code> — data / network builtin. Alias for <code>fetch_async_json</code>.</p>
<pre><code class="lang-perl">my $result = ftaj $x
# or in a pipeline:
@list |> map ftaj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ftj">
<h3><a class="doc-anchor" href="#doc-ftj">#</a> <code>ftj</code></h3>
<p><code>ftj</code> — data / network builtin. Alias for <code>fetch_json</code>.</p>
<pre><code class="lang-perl">my $result = ftj $x
# or in a pipeline:
@list |> map ftj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fuel-cell-polarization">
<h3><a class="doc-anchor" href="#doc-fuel-cell-polarization">#</a> <code>fuel_cell_polarization</code></h3>
<p><code>fuel_cell_polarization</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = fuel_cell_polarization $x
# or in a pipeline:
@list |> map fuel_cell_polarization |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fundamental-group-zn">
<h3><a class="doc-anchor" href="#doc-fundamental-group-zn">#</a> <code>fundamental_group_zn</code></h3>
<p><code>fundamental_group_zn</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = fundamental_group_zn $x
# or in a pipeline:
@list |> map fundamental_group_zn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fused-mul-add">
<h3><a class="doc-anchor" href="#doc-fused-mul-add">#</a> <code>fused_mul_add</code></h3>
<p><code>fused_mul_add</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = fused_mul_add $x
# or in a pipeline:
@list |> map fused_mul_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fusion-rule-su2-step">
<h3><a class="doc-anchor" href="#doc-fusion-rule-su2-step">#</a> <code>fusion_rule_su2_step</code></h3>
<p><code>fusion_rule_su2_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = fusion_rule_su2_step $x
# or in a pipeline:
@list |> map fusion_rule_su2_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-future-value">
<h3><a class="doc-anchor" href="#doc-future-value">#</a> <code>future_value</code></h3>
<p><code>future_value</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = future_value $x
# or in a pipeline:
@list |> map future_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fv">
<h3><a class="doc-anchor" href="#doc-fv">#</a> <code>fv</code></h3>
<p><code>fv</code> — python/ruby stdlib builtin. Alias for <code>fetch_val</code>.</p>
<pre><code class="lang-perl">my $result = fv $x
# or in a pipeline:
@list |> map fv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fx-forward">
<h3><a class="doc-anchor" href="#doc-fx-forward">#</a> <code>fx_forward</code></h3>
<p><code>fx_forward</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = fx_forward $x
# or in a pipeline:
@list |> map fx_forward |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-g2-zero">
<h3><a class="doc-anchor" href="#doc-g2-zero">#</a> <code>g2_zero</code></h3>
<p><code>g2_zero</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = g2_zero $x
# or in a pipeline:
@list |> map g2_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-g-to-oz">
<h3><a class="doc-anchor" href="#doc-g-to-oz">#</a> <code>g_to_oz</code></h3>
<p><code>g_to_oz</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = g_to_oz $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gabor-filter">
<h3><a class="doc-anchor" href="#doc-gabor-filter">#</a> <code>gabor_filter</code></h3>
<p><code>gabor_filter</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = gabor_filter $x
# or in a pipeline:
@list |> map gabor_filter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gabor-kernel">
<h3><a class="doc-anchor" href="#doc-gabor-kernel">#</a> <code>gabor_kernel</code></h3>
<p><code>gabor_kernel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = gabor_kernel $x
# or in a pipeline:
@list |> map gabor_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gae-advantage-step">
<h3><a class="doc-anchor" href="#doc-gae-advantage-step">#</a> <code>gae_advantage_step</code></h3>
<p><code>gae_advantage_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = gae_advantage_step $x
# or in a pipeline:
@list |> map gae_advantage_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gain-ratio">
<h3><a class="doc-anchor" href="#doc-gain-ratio">#</a> <code>gain_ratio</code></h3>
<p><code>gain_ratio</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = gain_ratio $x
# or in a pipeline:
@list |> map gain_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gale-optimal">
<h3><a class="doc-anchor" href="#doc-gale-optimal">#</a> <code>gale_optimal</code></h3>
<p><code>gale_optimal</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = gale_optimal $x
# or in a pipeline:
@list |> map gale_optimal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gale-shapley-step">
<h3><a class="doc-anchor" href="#doc-gale-shapley-step">#</a> <code>gale_shapley_step</code></h3>
<p><code>gale_shapley_step</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = gale_shapley_step $x
# or in a pipeline:
@list |> map gale_shapley_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gallons-to-liters">
<h3><a class="doc-anchor" href="#doc-gallons-to-liters">#</a> <code>gallons_to_liters</code></h3>
<p><code>gallons_to_liters</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = gallons_to_liters $input
</code></pre>
</article>
<article class="doc-entry" id="doc-game-of-life-step">
<h3><a class="doc-anchor" href="#doc-game-of-life-step">#</a> <code>game_of_life_step</code></h3>
<p><code>game_of_life_step</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = game_of_life_step $x
# or in a pipeline:
@list |> map game_of_life_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-game-two-player-value">
<h3><a class="doc-anchor" href="#doc-game-two-player-value">#</a> <code>game_two_player_value</code></h3>
<p><code>game_two_player_value</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = game_two_player_value $x
# or in a pipeline:
@list |> map game_two_player_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gamma-approx">
<h3><a class="doc-anchor" href="#doc-gamma-approx">#</a> <code>gamma_approx</code></h3>
<p><code>gamma_approx($z)</code> — Gamma function Γ(z) using Lanczos approximation. Extends factorial: Γ(n) = (n-1)!</p>
<pre><code class="lang-perl">p gamma(5) # 24 (same as 4!)
p gamma(0.5) # ~1.772 (√π)
</code></pre>
</article>
<article class="doc-entry" id="doc-gamma-pdf">
<h3><a class="doc-anchor" href="#doc-gamma-pdf">#</a> <code>gamma_pdf</code></h3>
<p><code>gamma_pdf</code> (alias <code>gammapdf</code>) evaluates the Gamma distribution PDF at x with shape k and scale theta.</p>
<pre><code class="lang-perl">p gammapdf(2.0, 2, 1) # Gamma(2,1) at x=2
</code></pre>
</article>
<article class="doc-entry" id="doc-gamow-factor">
<h3><a class="doc-anchor" href="#doc-gamow-factor">#</a> <code>gamow_factor</code></h3>
<p><code>gamow_factor</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = gamow_factor $x
# or in a pipeline:
@list |> map gamow_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-garch-fit">
<h3><a class="doc-anchor" href="#doc-garch-fit">#</a> <code>garch_fit</code></h3>
<p><code>garch_fit</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = garch_fit $x
# or in a pipeline:
@list |> map garch_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-garch-step">
<h3><a class="doc-anchor" href="#doc-garch-step">#</a> <code>garch_step</code></h3>
<p><code>garch_step</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = garch_step $x
# or in a pipeline:
@list |> map garch_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-garman-kohlhagen-call">
<h3><a class="doc-anchor" href="#doc-garman-kohlhagen-call">#</a> <code>garman_kohlhagen_call</code></h3>
<p><code>garman_kohlhagen_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = garman_kohlhagen_call $x
# or in a pipeline:
@list |> map garman_kohlhagen_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gas-constant">
<h3><a class="doc-anchor" href="#doc-gas-constant">#</a> <code>gas_constant</code></h3>
<p><code>gas_constant</code> (alias <code>rgas</code>) — R ≈ 8.314 J/(mol⋅K). Universal gas constant.</p>
<pre><code class="lang-perl">p rgas # 8.314462618
</code></pre>
</article>
<article class="doc-entry" id="doc-gas-constant-r">
<h3><a class="doc-anchor" href="#doc-gas-constant-r">#</a> <code>gas_constant_r</code></h3>
<p><code>gas_constant_r</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = gas_constant_r $x
# or in a pipeline:
@list |> map gas_constant_r |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gas-constant-value">
<h3><a class="doc-anchor" href="#doc-gas-constant-value">#</a> <code>gas_constant_value</code></h3>
<p><code>gas_constant_value</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = gas_constant_value $x
# or in a pipeline:
@list |> map gas_constant_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gasp">
<h3><a class="doc-anchor" href="#doc-gasp">#</a> <code>gasp</code></h3>
<p><code>ideal_gas_pressure($n, $V, $T)</code> (alias <code>gasp</code>) — pressure P = nRT/V. n moles, V volume (m³), T temperature (K).</p>
<pre><code class="lang-perl">p gasp(1, 0.0224, 273.15) # ~101325 Pa (1 mol at STP)
</code></pre>
</article>
<article class="doc-entry" id="doc-gasv">
<h3><a class="doc-anchor" href="#doc-gasv">#</a> <code>gasv</code></h3>
<p><code>gasv</code> — physics formulas builtin. Alias for <code>ideal_gas_volume</code>.</p>
<pre><code class="lang-perl">my $result = gasv $x
# or in a pipeline:
@list |> map gasv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gate-decompose">
<h3><a class="doc-anchor" href="#doc-gate-decompose">#</a> <code>gate_decompose</code></h3>
<p><code>gate_decompose</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = gate_decompose $x
# or in a pipeline:
@list |> map gate_decompose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gauss-bonnet-term-2d">
<h3><a class="doc-anchor" href="#doc-gauss-bonnet-term-2d">#</a> <code>gauss_bonnet_term_2d</code></h3>
<p><code>gauss_bonnet_term_2d</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = gauss_bonnet_term_2d $x
# or in a pipeline:
@list |> map gauss_bonnet_term_2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gauss-bonnet-total">
<h3><a class="doc-anchor" href="#doc-gauss-bonnet-total">#</a> <code>gauss_bonnet_total</code></h3>
<p><code>gauss_bonnet_total</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = gauss_bonnet_total $x
# or in a pipeline:
@list |> map gauss_bonnet_total |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gauss-codazzi-step">
<h3><a class="doc-anchor" href="#doc-gauss-codazzi-step">#</a> <code>gauss_codazzi_step</code></h3>
<p><code>gauss_codazzi_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = gauss_codazzi_step $x
# or in a pipeline:
@list |> map gauss_codazzi_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gauss-irk-2-stage">
<h3><a class="doc-anchor" href="#doc-gauss-irk-2-stage">#</a> <code>gauss_irk_2_stage</code></h3>
<p><code>gauss_irk_2_stage</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = gauss_irk_2_stage $x
# or in a pipeline:
@list |> map gauss_irk_2_stage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gauss-kronrod-15">
<h3><a class="doc-anchor" href="#doc-gauss-kronrod-15">#</a> <code>gauss_kronrod_15</code></h3>
<p><code>gauss_kronrod_15</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = gauss_kronrod_15 $x
# or in a pipeline:
@list |> map gauss_kronrod_15 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gauss-legendre-5">
<h3><a class="doc-anchor" href="#doc-gauss-legendre-5">#</a> <code>gauss_legendre_5</code></h3>
<p><code>gauss_legendre_5</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = gauss_legendre_5 $x
# or in a pipeline:
@list |> map gauss_legendre_5 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gaussian-curvature-step">
<h3><a class="doc-anchor" href="#doc-gaussian-curvature-step">#</a> <code>gaussian_curvature_step</code></h3>
<p><code>gaussian_curvature_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = gaussian_curvature_step $x
# or in a pipeline:
@list |> map gaussian_curvature_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gaussian-filter-window">
<h3><a class="doc-anchor" href="#doc-gaussian-filter-window">#</a> <code>gaussian_filter_window</code></h3>
<p><code>gaussian_filter_window</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = gaussian_filter_window $x
# or in a pipeline:
@list |> map gaussian_filter_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gaussian-window">
<h3><a class="doc-anchor" href="#doc-gaussian-window">#</a> <code>gaussian_window</code></h3>
<p><code>gaussian_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = gaussian_window $x
# or in a pipeline:
@list |> map gaussian_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gb-to-bytes">
<h3><a class="doc-anchor" href="#doc-gb-to-bytes">#</a> <code>gb_to_bytes</code></h3>
<p><code>gb_to_bytes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = gb_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gbf">
<h3><a class="doc-anchor" href="#doc-gbf">#</a> <code>gbf</code></h3>
<p><code>gbf</code> — go/general functional utilities builtin. Alias for <code>group_by_fn</code>.</p>
<pre><code class="lang-perl">my $result = gbf $x
# or in a pipeline:
@list |> map gbf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gbi">
<h3><a class="doc-anchor" href="#doc-gbi">#</a> <code>gbi</code></h3>
<p><code>gbi</code> — python/ruby stdlib builtin. Alias for <code>groupby_iter</code>.</p>
<pre><code class="lang-perl">my $result = gbi $x
# or in a pipeline:
@list |> map gbi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gcby">
<h3><a class="doc-anchor" href="#doc-gcby">#</a> <code>gcby</code></h3>
<p><code>gcby</code> — matrix operations (uncategorized batch) builtin. Alias for <code>group_consecutive_by</code>.</p>
<pre><code class="lang-perl">my $result = gcby $x
# or in a pipeline:
@list |> map gcby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gcd">
<h3><a class="doc-anchor" href="#doc-gcd">#</a> <code>gcd</code></h3>
<p><code>gcd</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = gcd $x
# or in a pipeline:
@list |> map gcd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gconst">
<h3><a class="doc-anchor" href="#doc-gconst">#</a> <code>gconst</code></h3>
<p><code>gconst</code> — constants builtin. Alias for <code>gravitational_constant</code>.</p>
<pre><code class="lang-perl">my $result = gconst $x
# or in a pipeline:
@list |> map gconst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gelu">
<h3><a class="doc-anchor" href="#doc-gelu">#</a> <code>gelu</code></h3>
<p><code>gelu</code> applies the Gaussian Error Linear Unit, used in BERT/GPT transformers.</p>
<pre><code class="lang-perl">p gelu(1) # 0.8412
p gelu(-1) # -0.1588
</code></pre>
</article>
<article class="doc-entry" id="doc-generalized-advantage">
<h3><a class="doc-anchor" href="#doc-generalized-advantage">#</a> <code>generalized_advantage</code></h3>
<p><code>generalized_advantage</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = generalized_advantage $x
# or in a pipeline:
@list |> map generalized_advantage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-generation-time">
<h3><a class="doc-anchor" href="#doc-generation-time">#</a> <code>generation_time</code></h3>
<p><code>generation_time</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = generation_time $x
# or in a pipeline:
@list |> map generation_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-generation-time-demo">
<h3><a class="doc-anchor" href="#doc-generation-time-demo">#</a> <code>generation_time_demo</code></h3>
<p><code>generation_time_demo</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = generation_time_demo $x
# or in a pipeline:
@list |> map generation_time_demo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-generation-time-step">
<h3><a class="doc-anchor" href="#doc-generation-time-step">#</a> <code>generation_time_step</code></h3>
<p><code>generation_time_step</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = generation_time_step $x
# or in a pipeline:
@list |> map generation_time_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-genetic-crossover-one-point">
<h3><a class="doc-anchor" href="#doc-genetic-crossover-one-point">#</a> <code>genetic_crossover_one_point</code></h3>
<p><code>genetic_crossover_one_point</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = genetic_crossover_one_point $x
# or in a pipeline:
@list |> map genetic_crossover_one_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-genus-curve-arith">
<h3><a class="doc-anchor" href="#doc-genus-curve-arith">#</a> <code>genus_curve_arith</code></h3>
<p><code>genus_curve_arith</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = genus_curve_arith $x
# or in a pipeline:
@list |> map genus_curve_arith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-genus-curve-geo">
<h3><a class="doc-anchor" href="#doc-genus-curve-geo">#</a> <code>genus_curve_geo</code></h3>
<p><code>genus_curve_geo</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = genus_curve_geo $x
# or in a pipeline:
@list |> map genus_curve_geo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-genus-from-euler">
<h3><a class="doc-anchor" href="#doc-genus-from-euler">#</a> <code>genus_from_euler</code></h3>
<p><code>genus_from_euler</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = genus_from_euler $x
# or in a pipeline:
@list |> map genus_from_euler |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-genus-surface">
<h3><a class="doc-anchor" href="#doc-genus-surface">#</a> <code>genus_surface</code></h3>
<p><code>genus_surface</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = genus_surface $x
# or in a pipeline:
@list |> map genus_surface |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geoadd">
<h3><a class="doc-anchor" href="#doc-geoadd">#</a> <code>geoadd</code></h3>
<p><code>geoadd</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = geoadd $x
# or in a pipeline:
@list |> map geoadd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geodesic-curvature-step">
<h3><a class="doc-anchor" href="#doc-geodesic-curvature-step">#</a> <code>geodesic_curvature_step</code></h3>
<p><code>geodesic_curvature_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = geodesic_curvature_step $x
# or in a pipeline:
@list |> map geodesic_curvature_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geodesic-equation-step-zero">
<h3><a class="doc-anchor" href="#doc-geodesic-equation-step-zero">#</a> <code>geodesic_equation_step_zero</code></h3>
<p><code>geodesic_equation_step_zero</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = geodesic_equation_step_zero $x
# or in a pipeline:
@list |> map geodesic_equation_step_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geodist">
<h3><a class="doc-anchor" href="#doc-geodist">#</a> <code>geodist</code></h3>
<p><code>geodist</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = geodist $x
# or in a pipeline:
@list |> map geodist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geohash">
<h3><a class="doc-anchor" href="#doc-geohash">#</a> <code>geohash</code></h3>
<p><code>geohash</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = geohash $x
# or in a pipeline:
@list |> map geohash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geohash-bbox">
<h3><a class="doc-anchor" href="#doc-geohash-bbox">#</a> <code>geohash_bbox</code></h3>
<p><code>geohash_bbox</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = geohash_bbox $x
# or in a pipeline:
@list |> map geohash_bbox |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geohash-decode">
<h3><a class="doc-anchor" href="#doc-geohash-decode">#</a> <code>geohash_decode</code></h3>
<p><code>geohash_decode</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = geohash_decode $x
# or in a pipeline:
@list |> map geohash_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geohash-encode">
<h3><a class="doc-anchor" href="#doc-geohash-encode">#</a> <code>geohash_encode</code></h3>
<p><code>geohash_encode</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = geohash_encode $x
# or in a pipeline:
@list |> map geohash_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geohash-neighbor">
<h3><a class="doc-anchor" href="#doc-geohash-neighbor">#</a> <code>geohash_neighbor</code></h3>
<p><code>geohash_neighbor</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = geohash_neighbor $x
# or in a pipeline:
@list |> map geohash_neighbor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geohash-neighbors">
<h3><a class="doc-anchor" href="#doc-geohash-neighbors">#</a> <code>geohash_neighbors</code></h3>
<p><code>geohash_neighbors</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = geohash_neighbors $x
# or in a pipeline:
@list |> map geohash_neighbors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geomagnetic-kp-index">
<h3><a class="doc-anchor" href="#doc-geomagnetic-kp-index">#</a> <code>geomagnetic_kp_index</code></h3>
<p><code>geomagnetic_kp_index</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = geomagnetic_kp_index $x
# or in a pipeline:
@list |> map geomagnetic_kp_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geometric-height-full">
<h3><a class="doc-anchor" href="#doc-geometric-height-full">#</a> <code>geometric_height_full</code></h3>
<p><code>geometric_height_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = geometric_height_full $x
# or in a pipeline:
@list |> map geometric_height_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geometric-intersection-number">
<h3><a class="doc-anchor" href="#doc-geometric-intersection-number">#</a> <code>geometric_intersection_number</code></h3>
<p><code>geometric_intersection_number</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = geometric_intersection_number $x
# or in a pipeline:
@list |> map geometric_intersection_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geometric-mean">
<h3><a class="doc-anchor" href="#doc-geometric-mean">#</a> <code>geometric_mean</code></h3>
<p><code>geometric_mean</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = geometric_mean $x
# or in a pipeline:
@list |> map geometric_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geometric-mean-arr">
<h3><a class="doc-anchor" href="#doc-geometric-mean-arr">#</a> <code>geometric_mean_arr</code></h3>
<p><code>geometric_mean_arr</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = geometric_mean_arr $x
# or in a pipeline:
@list |> map geometric_mean_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geometric-sequence">
<h3><a class="doc-anchor" href="#doc-geometric-sequence">#</a> <code>geometric_sequence</code></h3>
<p><code>geometric_sequence</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = geometric_sequence $x
# or in a pipeline:
@list |> map geometric_sequence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geometric-series">
<h3><a class="doc-anchor" href="#doc-geometric-series">#</a> <code>geometric_series</code></h3>
<p><code>geometric_series($a1, $r, $n)</code> (alias <code>geomser</code>) — sum of n terms of geometric sequence. Formula: a1×(1-rⁿ)/(1-r). If r=1, returns a1×n.</p>
<pre><code class="lang-perl">p geomser(1, 2, 10) # 1023 (1+2+4+...+512)
p geomser(1, 0.5, 10) # ~1.998 (converging to 2)
</code></pre>
</article>
<article class="doc-entry" id="doc-geopotential-height-full">
<h3><a class="doc-anchor" href="#doc-geopotential-height-full">#</a> <code>geopotential_height_full</code></h3>
<p><code>geopotential_height_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = geopotential_height_full $x
# or in a pipeline:
@list |> map geopotential_height_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geostrophic-wind-step">
<h3><a class="doc-anchor" href="#doc-geostrophic-wind-step">#</a> <code>geostrophic_wind_step</code></h3>
<p><code>geostrophic_wind_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = geostrophic_wind_step $x
# or in a pipeline:
@list |> map geostrophic_wind_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-get-in">
<h3><a class="doc-anchor" href="#doc-get-in">#</a> <code>get_in</code></h3>
<p><code>get_in</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = get_in $x
# or in a pipeline:
@list |> map get_in |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gethostent">
<h3><a class="doc-anchor" href="#doc-gethostent">#</a> <code>gethostent</code></h3>
<p><code>gethostent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = gethostent $x
# or in a pipeline:
@list |> map gethostent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getnetbyname">
<h3><a class="doc-anchor" href="#doc-getnetbyname">#</a> <code>getnetbyname</code></h3>
<p><code>getnetbyname</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = getnetbyname $x
# or in a pipeline:
@list |> map getnetbyname |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getnetent">
<h3><a class="doc-anchor" href="#doc-getnetent">#</a> <code>getnetent</code></h3>
<p><code>getnetent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = getnetent $x
# or in a pipeline:
@list |> map getnetent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getprotoent">
<h3><a class="doc-anchor" href="#doc-getprotoent">#</a> <code>getprotoent</code></h3>
<p><code>getprotoent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = getprotoent $x
# or in a pipeline:
@list |> map getprotoent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getrange">
<h3><a class="doc-anchor" href="#doc-getrange">#</a> <code>getrange</code></h3>
<p><code>getrange</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = getrange $x
# or in a pipeline:
@list |> map getrange |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getservent">
<h3><a class="doc-anchor" href="#doc-getservent">#</a> <code>getservent</code></h3>
<p><code>getservent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = getservent $x
# or in a pipeline:
@list |> map getservent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getset">
<h3><a class="doc-anchor" href="#doc-getset">#</a> <code>getset</code></h3>
<p><code>getset</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = getset $x
# or in a pipeline:
@list |> map getset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gf256-multiply">
<h3><a class="doc-anchor" href="#doc-gf256-multiply">#</a> <code>gf256_multiply</code></h3>
<p><code>gf256_multiply</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = gf256_multiply $x
# or in a pipeline:
@list |> map gf256_multiply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gforce">
<h3><a class="doc-anchor" href="#doc-gforce">#</a> <code>gforce</code></h3>
<p><code>gravitational_force($m1, $m2, $r)</code> (alias <code>gforce</code>) — Newton's law of gravitation: F = Gm₁m₂/r².</p>
<pre><code class="lang-perl">p gforce(5.972e24, 1000, 6.371e6) # ~9820 N (1 ton at Earth surface)
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-aabb-intersect-check">
<h3><a class="doc-anchor" href="#doc-gfx-aabb-intersect-check">#</a> <code>gfx_aabb_intersect_check</code></h3>
<p><code>gfx_aabb_intersect_check</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_aabb_intersect_check $x
# or in a pipeline:
@list |> map gfx_aabb_intersect_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-axis-angle-to-quat">
<h3><a class="doc-anchor" href="#doc-gfx-axis-angle-to-quat">#</a> <code>gfx_axis_angle_to_quat</code></h3>
<p><code>gfx_axis_angle_to_quat</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_axis_angle_to_quat $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-barycentric-alpha">
<h3><a class="doc-anchor" href="#doc-gfx-barycentric-alpha">#</a> <code>gfx_barycentric_alpha</code></h3>
<p><code>gfx_barycentric_alpha</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_barycentric_alpha $x
# or in a pipeline:
@list |> map gfx_barycentric_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-barycentric-beta">
<h3><a class="doc-anchor" href="#doc-gfx-barycentric-beta">#</a> <code>gfx_barycentric_beta</code></h3>
<p><code>gfx_barycentric_beta</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_barycentric_beta $x
# or in a pipeline:
@list |> map gfx_barycentric_beta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-barycentric-gamma">
<h3><a class="doc-anchor" href="#doc-gfx-barycentric-gamma">#</a> <code>gfx_barycentric_gamma</code></h3>
<p><code>gfx_barycentric_gamma</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_barycentric_gamma $x
# or in a pipeline:
@list |> map gfx_barycentric_gamma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-blinn-specular-step">
<h3><a class="doc-anchor" href="#doc-gfx-blinn-specular-step">#</a> <code>gfx_blinn_specular_step</code></h3>
<p><code>gfx_blinn_specular_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_blinn_specular_step $x
# or in a pipeline:
@list |> map gfx_blinn_specular_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-blue-noise-value">
<h3><a class="doc-anchor" href="#doc-gfx-blue-noise-value">#</a> <code>gfx_blue_noise_value</code></h3>
<p><code>gfx_blue_noise_value</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_blue_noise_value $x
# or in a pipeline:
@list |> map gfx_blue_noise_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-bresenham-step-x">
<h3><a class="doc-anchor" href="#doc-gfx-bresenham-step-x">#</a> <code>gfx_bresenham_step_x</code></h3>
<p><code>gfx_bresenham_step_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_bresenham_step_x $x
# or in a pipeline:
@list |> map gfx_bresenham_step_x |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-bresenham-step-y">
<h3><a class="doc-anchor" href="#doc-gfx-bresenham-step-y">#</a> <code>gfx_bresenham_step_y</code></h3>
<p><code>gfx_bresenham_step_y</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_bresenham_step_y $x
# or in a pipeline:
@list |> map gfx_bresenham_step_y |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-clip-polygon-step">
<h3><a class="doc-anchor" href="#doc-gfx-clip-polygon-step">#</a> <code>gfx_clip_polygon_step</code></h3>
<p><code>gfx_clip_polygon_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_clip_polygon_step $x
# or in a pipeline:
@list |> map gfx_clip_polygon_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-cohen-sutherland-code">
<h3><a class="doc-anchor" href="#doc-gfx-cohen-sutherland-code">#</a> <code>gfx_cohen_sutherland_code</code></h3>
<p><code>gfx_cohen_sutherland_code</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_cohen_sutherland_code $x
# or in a pipeline:
@list |> map gfx_cohen_sutherland_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-cook-torrance-d-ggx">
<h3><a class="doc-anchor" href="#doc-gfx-cook-torrance-d-ggx">#</a> <code>gfx_cook_torrance_d_ggx</code></h3>
<p><code>gfx_cook_torrance_d_ggx</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_cook_torrance_d_ggx $x
# or in a pipeline:
@list |> map gfx_cook_torrance_d_ggx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-cook-torrance-f-schlick">
<h3><a class="doc-anchor" href="#doc-gfx-cook-torrance-f-schlick">#</a> <code>gfx_cook_torrance_f_schlick</code></h3>
<p><code>gfx_cook_torrance_f_schlick</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_cook_torrance_f_schlick $x
# or in a pipeline:
@list |> map gfx_cook_torrance_f_schlick |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-cook-torrance-g-smith">
<h3><a class="doc-anchor" href="#doc-gfx-cook-torrance-g-smith">#</a> <code>gfx_cook_torrance_g_smith</code></h3>
<p><code>gfx_cook_torrance_g_smith</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_cook_torrance_g_smith $x
# or in a pipeline:
@list |> map gfx_cook_torrance_g_smith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-cube-map-face-index">
<h3><a class="doc-anchor" href="#doc-gfx-cube-map-face-index">#</a> <code>gfx_cube_map_face_index</code></h3>
<p><code>gfx_cube_map_face_index</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_cube_map_face_index $x
# or in a pipeline:
@list |> map gfx_cube_map_face_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-curl-noise-step">
<h3><a class="doc-anchor" href="#doc-gfx-curl-noise-step">#</a> <code>gfx_curl_noise_step</code></h3>
<p><code>gfx_curl_noise_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_curl_noise_step $x
# or in a pipeline:
@list |> map gfx_curl_noise_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-disney-principled-d">
<h3><a class="doc-anchor" href="#doc-gfx-disney-principled-d">#</a> <code>gfx_disney_principled_d</code></h3>
<p><code>gfx_disney_principled_d</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_disney_principled_d $x
# or in a pipeline:
@list |> map gfx_disney_principled_d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-dither-bayer-4x4">
<h3><a class="doc-anchor" href="#doc-gfx-dither-bayer-4x4">#</a> <code>gfx_dither_bayer_4x4</code></h3>
<p><code>gfx_dither_bayer_4x4</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_dither_bayer_4x4 $x
# or in a pipeline:
@list |> map gfx_dither_bayer_4x4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-dither-floyd-steinberg">
<h3><a class="doc-anchor" href="#doc-gfx-dither-floyd-steinberg">#</a> <code>gfx_dither_floyd_steinberg</code></h3>
<p><code>gfx_dither_floyd_steinberg</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_dither_floyd_steinberg $x
# or in a pipeline:
@list |> map gfx_dither_floyd_steinberg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-environment-map-uv-u">
<h3><a class="doc-anchor" href="#doc-gfx-environment-map-uv-u">#</a> <code>gfx_environment_map_uv_u</code></h3>
<p><code>gfx_environment_map_uv_u</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_environment_map_uv_u $x
# or in a pipeline:
@list |> map gfx_environment_map_uv_u |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-environment-map-uv-v">
<h3><a class="doc-anchor" href="#doc-gfx-environment-map-uv-v">#</a> <code>gfx_environment_map_uv_v</code></h3>
<p><code>gfx_environment_map_uv_v</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_environment_map_uv_v $x
# or in a pipeline:
@list |> map gfx_environment_map_uv_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-euler-to-quat-w">
<h3><a class="doc-anchor" href="#doc-gfx-euler-to-quat-w">#</a> <code>gfx_euler_to_quat_w</code></h3>
<p><code>gfx_euler_to_quat_w</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_euler_to_quat_w $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-euler-to-quat-x">
<h3><a class="doc-anchor" href="#doc-gfx-euler-to-quat-x">#</a> <code>gfx_euler_to_quat_x</code></h3>
<p><code>gfx_euler_to_quat_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_euler_to_quat_x $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-euler-to-quat-y">
<h3><a class="doc-anchor" href="#doc-gfx-euler-to-quat-y">#</a> <code>gfx_euler_to_quat_y</code></h3>
<p><code>gfx_euler_to_quat_y</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_euler_to_quat_y $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-euler-to-quat-z">
<h3><a class="doc-anchor" href="#doc-gfx-euler-to-quat-z">#</a> <code>gfx_euler_to_quat_z</code></h3>
<p><code>gfx_euler_to_quat_z</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_euler_to_quat_z $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-fbm-noise-step">
<h3><a class="doc-anchor" href="#doc-gfx-fbm-noise-step">#</a> <code>gfx_fbm_noise_step</code></h3>
<p><code>gfx_fbm_noise_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_fbm_noise_step $x
# or in a pipeline:
@list |> map gfx_fbm_noise_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-fresnel-conductor-step">
<h3><a class="doc-anchor" href="#doc-gfx-fresnel-conductor-step">#</a> <code>gfx_fresnel_conductor_step</code></h3>
<p><code>gfx_fresnel_conductor_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_fresnel_conductor_step $x
# or in a pipeline:
@list |> map gfx_fresnel_conductor_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-fresnel-dielectric-step">
<h3><a class="doc-anchor" href="#doc-gfx-fresnel-dielectric-step">#</a> <code>gfx_fresnel_dielectric_step</code></h3>
<p><code>gfx_fresnel_dielectric_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_fresnel_dielectric_step $x
# or in a pipeline:
@list |> map gfx_fresnel_dielectric_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-gamma-correct-step">
<h3><a class="doc-anchor" href="#doc-gfx-gamma-correct-step">#</a> <code>gfx_gamma_correct_step</code></h3>
<p><code>gfx_gamma_correct_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_gamma_correct_step $x
# or in a pipeline:
@list |> map gfx_gamma_correct_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-geometric-attenuation-smith">
<h3><a class="doc-anchor" href="#doc-gfx-geometric-attenuation-smith">#</a> <code>gfx_geometric_attenuation_smith</code></h3>
<p><code>gfx_geometric_attenuation_smith</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_geometric_attenuation_smith $x
# or in a pipeline:
@list |> map gfx_geometric_attenuation_smith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-gradient-noise-step">
<h3><a class="doc-anchor" href="#doc-gfx-gradient-noise-step">#</a> <code>gfx_gradient_noise_step</code></h3>
<p><code>gfx_gradient_noise_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_gradient_noise_step $x
# or in a pipeline:
@list |> map gfx_gradient_noise_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-halton-step">
<h3><a class="doc-anchor" href="#doc-gfx-halton-step">#</a> <code>gfx_halton_step</code></h3>
<p><code>gfx_halton_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_halton_step $x
# or in a pipeline:
@list |> map gfx_halton_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-homogeneous-divide">
<h3><a class="doc-anchor" href="#doc-gfx-homogeneous-divide">#</a> <code>gfx_homogeneous_divide</code></h3>
<p><code>gfx_homogeneous_divide</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_homogeneous_divide $x
# or in a pipeline:
@list |> map gfx_homogeneous_divide |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-index-of-refraction">
<h3><a class="doc-anchor" href="#doc-gfx-index-of-refraction">#</a> <code>gfx_index_of_refraction</code></h3>
<p><code>gfx_index_of_refraction</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_index_of_refraction $x
# or in a pipeline:
@list |> map gfx_index_of_refraction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-irradiance-sh-eval">
<h3><a class="doc-anchor" href="#doc-gfx-irradiance-sh-eval">#</a> <code>gfx_irradiance_sh_eval</code></h3>
<p><code>gfx_irradiance_sh_eval</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_irradiance_sh_eval $x
# or in a pipeline:
@list |> map gfx_irradiance_sh_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-lambert-term">
<h3><a class="doc-anchor" href="#doc-gfx-lambert-term">#</a> <code>gfx_lambert_term</code></h3>
<p><code>gfx_lambert_term</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_lambert_term $x
# or in a pipeline:
@list |> map gfx_lambert_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-liang-barsky-t">
<h3><a class="doc-anchor" href="#doc-gfx-liang-barsky-t">#</a> <code>gfx_liang_barsky_t</code></h3>
<p><code>gfx_liang_barsky_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_liang_barsky_t $x
# or in a pipeline:
@list |> map gfx_liang_barsky_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-linear-to-srgb">
<h3><a class="doc-anchor" href="#doc-gfx-linear-to-srgb">#</a> <code>gfx_linear_to_srgb</code></h3>
<p><code>gfx_linear_to_srgb</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_linear_to_srgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-lookat-forward">
<h3><a class="doc-anchor" href="#doc-gfx-lookat-forward">#</a> <code>gfx_lookat_forward</code></h3>
<p><code>gfx_lookat_forward</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_lookat_forward $x
# or in a pipeline:
@list |> map gfx_lookat_forward |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-lookat-right">
<h3><a class="doc-anchor" href="#doc-gfx-lookat-right">#</a> <code>gfx_lookat_right</code></h3>
<p><code>gfx_lookat_right</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_lookat_right $x
# or in a pipeline:
@list |> map gfx_lookat_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-lookat-up">
<h3><a class="doc-anchor" href="#doc-gfx-lookat-up">#</a> <code>gfx_lookat_up</code></h3>
<p><code>gfx_lookat_up</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_lookat_up $x
# or in a pipeline:
@list |> map gfx_lookat_up |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-low-discrepancy-step">
<h3><a class="doc-anchor" href="#doc-gfx-low-discrepancy-step">#</a> <code>gfx_low_discrepancy_step</code></h3>
<p><code>gfx_low_discrepancy_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_low_discrepancy_step $x
# or in a pipeline:
@list |> map gfx_low_discrepancy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-microfacet-brdf-step">
<h3><a class="doc-anchor" href="#doc-gfx-microfacet-brdf-step">#</a> <code>gfx_microfacet_brdf_step</code></h3>
<p><code>gfx_microfacet_brdf_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_microfacet_brdf_step $x
# or in a pipeline:
@list |> map gfx_microfacet_brdf_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ndc-to-screen-x">
<h3><a class="doc-anchor" href="#doc-gfx-ndc-to-screen-x">#</a> <code>gfx_ndc_to_screen_x</code></h3>
<p><code>gfx_ndc_to_screen_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ndc_to_screen_x $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ndc-to-screen-y">
<h3><a class="doc-anchor" href="#doc-gfx-ndc-to-screen-y">#</a> <code>gfx_ndc_to_screen_y</code></h3>
<p><code>gfx_ndc_to_screen_y</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ndc_to_screen_y $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-normal-distribution-ggx">
<h3><a class="doc-anchor" href="#doc-gfx-normal-distribution-ggx">#</a> <code>gfx_normal_distribution_ggx</code></h3>
<p><code>gfx_normal_distribution_ggx</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_normal_distribution_ggx $x
# or in a pipeline:
@list |> map gfx_normal_distribution_ggx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-obb-overlap-step">
<h3><a class="doc-anchor" href="#doc-gfx-obb-overlap-step">#</a> <code>gfx_obb_overlap_step</code></h3>
<p><code>gfx_obb_overlap_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_obb_overlap_step $x
# or in a pipeline:
@list |> map gfx_obb_overlap_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-octahedral-encode-x">
<h3><a class="doc-anchor" href="#doc-gfx-octahedral-encode-x">#</a> <code>gfx_octahedral_encode_x</code></h3>
<p><code>gfx_octahedral_encode_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_octahedral_encode_x $x
# or in a pipeline:
@list |> map gfx_octahedral_encode_x |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-octahedral-encode-y">
<h3><a class="doc-anchor" href="#doc-gfx-octahedral-encode-y">#</a> <code>gfx_octahedral_encode_y</code></h3>
<p><code>gfx_octahedral_encode_y</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_octahedral_encode_y $x
# or in a pipeline:
@list |> map gfx_octahedral_encode_y |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-oklab-a-step">
<h3><a class="doc-anchor" href="#doc-gfx-oklab-a-step">#</a> <code>gfx_oklab_a_step</code></h3>
<p><code>gfx_oklab_a_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_oklab_a_step $x
# or in a pipeline:
@list |> map gfx_oklab_a_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-oklab-b-step">
<h3><a class="doc-anchor" href="#doc-gfx-oklab-b-step">#</a> <code>gfx_oklab_b_step</code></h3>
<p><code>gfx_oklab_b_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_oklab_b_step $x
# or in a pipeline:
@list |> map gfx_oklab_b_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-oklab-l-step">
<h3><a class="doc-anchor" href="#doc-gfx-oklab-l-step">#</a> <code>gfx_oklab_l_step</code></h3>
<p><code>gfx_oklab_l_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_oklab_l_step $x
# or in a pipeline:
@list |> map gfx_oklab_l_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-oklch-chroma">
<h3><a class="doc-anchor" href="#doc-gfx-oklch-chroma">#</a> <code>gfx_oklch_chroma</code></h3>
<p><code>gfx_oklch_chroma</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_oklch_chroma $x
# or in a pipeline:
@list |> map gfx_oklch_chroma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-oklch-hue">
<h3><a class="doc-anchor" href="#doc-gfx-oklch-hue">#</a> <code>gfx_oklch_hue</code></h3>
<p><code>gfx_oklch_hue</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_oklch_hue $x
# or in a pipeline:
@list |> map gfx_oklch_hue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-oren-nayar-term">
<h3><a class="doc-anchor" href="#doc-gfx-oren-nayar-term">#</a> <code>gfx_oren_nayar_term</code></h3>
<p><code>gfx_oren_nayar_term</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_oren_nayar_term $x
# or in a pipeline:
@list |> map gfx_oren_nayar_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-orthographic-proj">
<h3><a class="doc-anchor" href="#doc-gfx-orthographic-proj">#</a> <code>gfx_orthographic_proj</code></h3>
<p><code>gfx_orthographic_proj</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_orthographic_proj $x
# or in a pipeline:
@list |> map gfx_orthographic_proj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-pcg-hash-step">
<h3><a class="doc-anchor" href="#doc-gfx-pcg-hash-step">#</a> <code>gfx_pcg_hash_step</code></h3>
<p><code>gfx_pcg_hash_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_pcg_hash_step $x
# or in a pipeline:
@list |> map gfx_pcg_hash_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-perlin-noise-step">
<h3><a class="doc-anchor" href="#doc-gfx-perlin-noise-step">#</a> <code>gfx_perlin_noise_step</code></h3>
<p><code>gfx_perlin_noise_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_perlin_noise_step $x
# or in a pipeline:
@list |> map gfx_perlin_noise_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-perspective-proj-x">
<h3><a class="doc-anchor" href="#doc-gfx-perspective-proj-x">#</a> <code>gfx_perspective_proj_x</code></h3>
<p><code>gfx_perspective_proj_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_perspective_proj_x $x
# or in a pipeline:
@list |> map gfx_perspective_proj_x |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-perspective-proj-y">
<h3><a class="doc-anchor" href="#doc-gfx-perspective-proj-y">#</a> <code>gfx_perspective_proj_y</code></h3>
<p><code>gfx_perspective_proj_y</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_perspective_proj_y $x
# or in a pipeline:
@list |> map gfx_perspective_proj_y |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-phong-ambient-step">
<h3><a class="doc-anchor" href="#doc-gfx-phong-ambient-step">#</a> <code>gfx_phong_ambient_step</code></h3>
<p><code>gfx_phong_ambient_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_phong_ambient_step $x
# or in a pipeline:
@list |> map gfx_phong_ambient_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-phong-diffuse-step">
<h3><a class="doc-anchor" href="#doc-gfx-phong-diffuse-step">#</a> <code>gfx_phong_diffuse_step</code></h3>
<p><code>gfx_phong_diffuse_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_phong_diffuse_step $x
# or in a pipeline:
@list |> map gfx_phong_diffuse_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-phong-specular-step">
<h3><a class="doc-anchor" href="#doc-gfx-phong-specular-step">#</a> <code>gfx_phong_specular_step</code></h3>
<p><code>gfx_phong_specular_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_phong_specular_step $x
# or in a pipeline:
@list |> map gfx_phong_specular_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-quat-dot-two">
<h3><a class="doc-anchor" href="#doc-gfx-quat-dot-two">#</a> <code>gfx_quat_dot_two</code></h3>
<p><code>gfx_quat_dot_two</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_quat_dot_two $x
# or in a pipeline:
@list |> map gfx_quat_dot_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-quat-inverse-step">
<h3><a class="doc-anchor" href="#doc-gfx-quat-inverse-step">#</a> <code>gfx_quat_inverse_step</code></h3>
<p><code>gfx_quat_inverse_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_quat_inverse_step $x
# or in a pipeline:
@list |> map gfx_quat_inverse_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-quat-nlerp-step">
<h3><a class="doc-anchor" href="#doc-gfx-quat-nlerp-step">#</a> <code>gfx_quat_nlerp_step</code></h3>
<p><code>gfx_quat_nlerp_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_quat_nlerp_step $x
# or in a pipeline:
@list |> map gfx_quat_nlerp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-quat-slerp-step">
<h3><a class="doc-anchor" href="#doc-gfx-quat-slerp-step">#</a> <code>gfx_quat_slerp_step</code></h3>
<p><code>gfx_quat_slerp_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_quat_slerp_step $x
# or in a pipeline:
@list |> map gfx_quat_slerp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-quat-to-axis-angle">
<h3><a class="doc-anchor" href="#doc-gfx-quat-to-axis-angle">#</a> <code>gfx_quat_to_axis_angle</code></h3>
<p><code>gfx_quat_to_axis_angle</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_quat_to_axis_angle $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-quat-to-euler-pitch">
<h3><a class="doc-anchor" href="#doc-gfx-quat-to-euler-pitch">#</a> <code>gfx_quat_to_euler_pitch</code></h3>
<p><code>gfx_quat_to_euler_pitch</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_quat_to_euler_pitch $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-quat-to-euler-roll">
<h3><a class="doc-anchor" href="#doc-gfx-quat-to-euler-roll">#</a> <code>gfx_quat_to_euler_roll</code></h3>
<p><code>gfx_quat_to_euler_roll</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_quat_to_euler_roll $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-quat-to-euler-yaw">
<h3><a class="doc-anchor" href="#doc-gfx-quat-to-euler-yaw">#</a> <code>gfx_quat_to_euler_yaw</code></h3>
<p><code>gfx_quat_to_euler_yaw</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_quat_to_euler_yaw $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-radiance-sh-eval">
<h3><a class="doc-anchor" href="#doc-gfx-radiance-sh-eval">#</a> <code>gfx_radiance_sh_eval</code></h3>
<p><code>gfx_radiance_sh_eval</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_radiance_sh_eval $x
# or in a pipeline:
@list |> map gfx_radiance_sh_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-box-t">
<h3><a class="doc-anchor" href="#doc-gfx-ray-box-t">#</a> <code>gfx_ray_box_t</code></h3>
<p><code>gfx_ray_box_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_box_t $x
# or in a pipeline:
@list |> map gfx_ray_box_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-cone-t">
<h3><a class="doc-anchor" href="#doc-gfx-ray-cone-t">#</a> <code>gfx_ray_cone_t</code></h3>
<p><code>gfx_ray_cone_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_cone_t $x
# or in a pipeline:
@list |> map gfx_ray_cone_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-cylinder-t">
<h3><a class="doc-anchor" href="#doc-gfx-ray-cylinder-t">#</a> <code>gfx_ray_cylinder_t</code></h3>
<p><code>gfx_ray_cylinder_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_cylinder_t $x
# or in a pipeline:
@list |> map gfx_ray_cylinder_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-disk-t">
<h3><a class="doc-anchor" href="#doc-gfx-ray-disk-t">#</a> <code>gfx_ray_disk_t</code></h3>
<p><code>gfx_ray_disk_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_disk_t $x
# or in a pipeline:
@list |> map gfx_ray_disk_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-ellipsoid-t">
<h3><a class="doc-anchor" href="#doc-gfx-ray-ellipsoid-t">#</a> <code>gfx_ray_ellipsoid_t</code></h3>
<p><code>gfx_ray_ellipsoid_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_ellipsoid_t $x
# or in a pipeline:
@list |> map gfx_ray_ellipsoid_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-plane-t">
<h3><a class="doc-anchor" href="#doc-gfx-ray-plane-t">#</a> <code>gfx_ray_plane_t</code></h3>
<p><code>gfx_ray_plane_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_plane_t $x
# or in a pipeline:
@list |> map gfx_ray_plane_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-sphere-t">
<h3><a class="doc-anchor" href="#doc-gfx-ray-sphere-t">#</a> <code>gfx_ray_sphere_t</code></h3>
<p><code>gfx_ray_sphere_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_sphere_t $x
# or in a pipeline:
@list |> map gfx_ray_sphere_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-torus-t-approx">
<h3><a class="doc-anchor" href="#doc-gfx-ray-torus-t-approx">#</a> <code>gfx_ray_torus_t_approx</code></h3>
<p><code>gfx_ray_torus_t_approx</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_torus_t_approx $x
# or in a pipeline:
@list |> map gfx_ray_torus_t_approx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-ray-triangle-t">
<h3><a class="doc-anchor" href="#doc-gfx-ray-triangle-t">#</a> <code>gfx_ray_triangle_t</code></h3>
<p><code>gfx_ray_triangle_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_ray_triangle_t $x
# or in a pipeline:
@list |> map gfx_ray_triangle_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-reflect-direction-x">
<h3><a class="doc-anchor" href="#doc-gfx-reflect-direction-x">#</a> <code>gfx_reflect_direction_x</code></h3>
<p><code>gfx_reflect_direction_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_reflect_direction_x $x
# or in a pipeline:
@list |> map gfx_reflect_direction_x |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-refract-direction-x">
<h3><a class="doc-anchor" href="#doc-gfx-refract-direction-x">#</a> <code>gfx_refract_direction_x</code></h3>
<p><code>gfx_refract_direction_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_refract_direction_x $x
# or in a pipeline:
@list |> map gfx_refract_direction_x |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-rotation-matrix-xx">
<h3><a class="doc-anchor" href="#doc-gfx-rotation-matrix-xx">#</a> <code>gfx_rotation_matrix_xx</code></h3>
<p><code>gfx_rotation_matrix_xx</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_rotation_matrix_xx $x
# or in a pipeline:
@list |> map gfx_rotation_matrix_xx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-rotation-matrix-yy">
<h3><a class="doc-anchor" href="#doc-gfx-rotation-matrix-yy">#</a> <code>gfx_rotation_matrix_yy</code></h3>
<p><code>gfx_rotation_matrix_yy</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_rotation_matrix_yy $x
# or in a pipeline:
@list |> map gfx_rotation_matrix_yy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-rotation-matrix-zz">
<h3><a class="doc-anchor" href="#doc-gfx-rotation-matrix-zz">#</a> <code>gfx_rotation_matrix_zz</code></h3>
<p><code>gfx_rotation_matrix_zz</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_rotation_matrix_zz $x
# or in a pipeline:
@list |> map gfx_rotation_matrix_zz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-scale-matrix-step">
<h3><a class="doc-anchor" href="#doc-gfx-scale-matrix-step">#</a> <code>gfx_scale_matrix_step</code></h3>
<p><code>gfx_scale_matrix_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_scale_matrix_step $x
# or in a pipeline:
@list |> map gfx_scale_matrix_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-screen-space-x">
<h3><a class="doc-anchor" href="#doc-gfx-screen-space-x">#</a> <code>gfx_screen_space_x</code></h3>
<p><code>gfx_screen_space_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_screen_space_x $x
# or in a pipeline:
@list |> map gfx_screen_space_x |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-screen-space-y">
<h3><a class="doc-anchor" href="#doc-gfx-screen-space-y">#</a> <code>gfx_screen_space_y</code></h3>
<p><code>gfx_screen_space_y</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_screen_space_y $x
# or in a pipeline:
@list |> map gfx_screen_space_y |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-screen-to-ndc-x">
<h3><a class="doc-anchor" href="#doc-gfx-screen-to-ndc-x">#</a> <code>gfx_screen_to_ndc_x</code></h3>
<p><code>gfx_screen_to_ndc_x</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_screen_to_ndc_x $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-screen-to-ndc-y">
<h3><a class="doc-anchor" href="#doc-gfx-screen-to-ndc-y">#</a> <code>gfx_screen_to_ndc_y</code></h3>
<p><code>gfx_screen_to_ndc_y</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_screen_to_ndc_y $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-shear-matrix-xy">
<h3><a class="doc-anchor" href="#doc-gfx-shear-matrix-xy">#</a> <code>gfx_shear_matrix_xy</code></h3>
<p><code>gfx_shear_matrix_xy</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_shear_matrix_xy $x
# or in a pipeline:
@list |> map gfx_shear_matrix_xy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-signed-distance-box">
<h3><a class="doc-anchor" href="#doc-gfx-signed-distance-box">#</a> <code>gfx_signed_distance_box</code></h3>
<p><code>gfx_signed_distance_box</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_signed_distance_box $x
# or in a pipeline:
@list |> map gfx_signed_distance_box |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-signed-distance-capsule">
<h3><a class="doc-anchor" href="#doc-gfx-signed-distance-capsule">#</a> <code>gfx_signed_distance_capsule</code></h3>
<p><code>gfx_signed_distance_capsule</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_signed_distance_capsule $x
# or in a pipeline:
@list |> map gfx_signed_distance_capsule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-signed-distance-sphere">
<h3><a class="doc-anchor" href="#doc-gfx-signed-distance-sphere">#</a> <code>gfx_signed_distance_sphere</code></h3>
<p><code>gfx_signed_distance_sphere</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_signed_distance_sphere $x
# or in a pipeline:
@list |> map gfx_signed_distance_sphere |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-simplex-noise-step">
<h3><a class="doc-anchor" href="#doc-gfx-simplex-noise-step">#</a> <code>gfx_simplex_noise_step</code></h3>
<p><code>gfx_simplex_noise_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_simplex_noise_step $x
# or in a pipeline:
@list |> map gfx_simplex_noise_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-skybox-uv-u">
<h3><a class="doc-anchor" href="#doc-gfx-skybox-uv-u">#</a> <code>gfx_skybox_uv_u</code></h3>
<p><code>gfx_skybox_uv_u</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_skybox_uv_u $x
# or in a pipeline:
@list |> map gfx_skybox_uv_u |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-skybox-uv-v">
<h3><a class="doc-anchor" href="#doc-gfx-skybox-uv-v">#</a> <code>gfx_skybox_uv_v</code></h3>
<p><code>gfx_skybox_uv_v</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_skybox_uv_v $x
# or in a pipeline:
@list |> map gfx_skybox_uv_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-snells-law-angle">
<h3><a class="doc-anchor" href="#doc-gfx-snells-law-angle">#</a> <code>gfx_snells_law_angle</code></h3>
<p><code>gfx_snells_law_angle</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_snells_law_angle $x
# or in a pipeline:
@list |> map gfx_snells_law_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-sobol-step">
<h3><a class="doc-anchor" href="#doc-gfx-sobol-step">#</a> <code>gfx_sobol_step</code></h3>
<p><code>gfx_sobol_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_sobol_step $x
# or in a pipeline:
@list |> map gfx_sobol_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-sphere-intersect-t">
<h3><a class="doc-anchor" href="#doc-gfx-sphere-intersect-t">#</a> <code>gfx_sphere_intersect_t</code></h3>
<p><code>gfx_sphere_intersect_t</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_sphere_intersect_t $x
# or in a pipeline:
@list |> map gfx_sphere_intersect_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-spherical-harmonic-y00">
<h3><a class="doc-anchor" href="#doc-gfx-spherical-harmonic-y00">#</a> <code>gfx_spherical_harmonic_y00</code></h3>
<p><code>gfx_spherical_harmonic_y00</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_spherical_harmonic_y00 $x
# or in a pipeline:
@list |> map gfx_spherical_harmonic_y00 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-spherical-harmonic-y10">
<h3><a class="doc-anchor" href="#doc-gfx-spherical-harmonic-y10">#</a> <code>gfx_spherical_harmonic_y10</code></h3>
<p><code>gfx_spherical_harmonic_y10</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_spherical_harmonic_y10 $x
# or in a pipeline:
@list |> map gfx_spherical_harmonic_y10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-spherical-harmonic-y11">
<h3><a class="doc-anchor" href="#doc-gfx-spherical-harmonic-y11">#</a> <code>gfx_spherical_harmonic_y11</code></h3>
<p><code>gfx_spherical_harmonic_y11</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_spherical_harmonic_y11 $x
# or in a pipeline:
@list |> map gfx_spherical_harmonic_y11 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-spherical-harmonic-y20">
<h3><a class="doc-anchor" href="#doc-gfx-spherical-harmonic-y20">#</a> <code>gfx_spherical_harmonic_y20</code></h3>
<p><code>gfx_spherical_harmonic_y20</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_spherical_harmonic_y20 $x
# or in a pipeline:
@list |> map gfx_spherical_harmonic_y20 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-srgb-to-linear">
<h3><a class="doc-anchor" href="#doc-gfx-srgb-to-linear">#</a> <code>gfx_srgb_to_linear</code></h3>
<p><code>gfx_srgb_to_linear</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_srgb_to_linear $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-subsurface-scattering-term">
<h3><a class="doc-anchor" href="#doc-gfx-subsurface-scattering-term">#</a> <code>gfx_subsurface_scattering_term</code></h3>
<p><code>gfx_subsurface_scattering_term</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_subsurface_scattering_term $x
# or in a pipeline:
@list |> map gfx_subsurface_scattering_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-sutherland-hodgman">
<h3><a class="doc-anchor" href="#doc-gfx-sutherland-hodgman">#</a> <code>gfx_sutherland_hodgman</code></h3>
<p><code>gfx_sutherland_hodgman</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_sutherland_hodgman $x
# or in a pipeline:
@list |> map gfx_sutherland_hodgman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-tonemap-aces">
<h3><a class="doc-anchor" href="#doc-gfx-tonemap-aces">#</a> <code>gfx_tonemap_aces</code></h3>
<p><code>gfx_tonemap_aces</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_tonemap_aces $x
# or in a pipeline:
@list |> map gfx_tonemap_aces |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-tonemap-filmic">
<h3><a class="doc-anchor" href="#doc-gfx-tonemap-filmic">#</a> <code>gfx_tonemap_filmic</code></h3>
<p><code>gfx_tonemap_filmic</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_tonemap_filmic $x
# or in a pipeline:
@list |> map gfx_tonemap_filmic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-tonemap-reinhard">
<h3><a class="doc-anchor" href="#doc-gfx-tonemap-reinhard">#</a> <code>gfx_tonemap_reinhard</code></h3>
<p><code>gfx_tonemap_reinhard</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_tonemap_reinhard $x
# or in a pipeline:
@list |> map gfx_tonemap_reinhard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-tonemap-uncharted2">
<h3><a class="doc-anchor" href="#doc-gfx-tonemap-uncharted2">#</a> <code>gfx_tonemap_uncharted2</code></h3>
<p><code>gfx_tonemap_uncharted2</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_tonemap_uncharted2 $x
# or in a pipeline:
@list |> map gfx_tonemap_uncharted2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-total-internal-reflection">
<h3><a class="doc-anchor" href="#doc-gfx-total-internal-reflection">#</a> <code>gfx_total_internal_reflection</code></h3>
<p><code>gfx_total_internal_reflection</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_total_internal_reflection $x
# or in a pipeline:
@list |> map gfx_total_internal_reflection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-translation-matrix-step">
<h3><a class="doc-anchor" href="#doc-gfx-translation-matrix-step">#</a> <code>gfx_translation_matrix_step</code></h3>
<p><code>gfx_translation_matrix_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_translation_matrix_step $x
# or in a pipeline:
@list |> map gfx_translation_matrix_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-translucent-falloff">
<h3><a class="doc-anchor" href="#doc-gfx-translucent-falloff">#</a> <code>gfx_translucent_falloff</code></h3>
<p><code>gfx_translucent_falloff</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_translucent_falloff $x
# or in a pipeline:
@list |> map gfx_translucent_falloff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-value-noise-step">
<h3><a class="doc-anchor" href="#doc-gfx-value-noise-step">#</a> <code>gfx_value_noise_step</code></h3>
<p><code>gfx_value_noise_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_value_noise_step $x
# or in a pipeline:
@list |> map gfx_value_noise_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-van-der-corput">
<h3><a class="doc-anchor" href="#doc-gfx-van-der-corput">#</a> <code>gfx_van_der_corput</code></h3>
<p><code>gfx_van_der_corput</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_van_der_corput $x
# or in a pipeline:
@list |> map gfx_van_der_corput |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-view-matrix-step">
<h3><a class="doc-anchor" href="#doc-gfx-view-matrix-step">#</a> <code>gfx_view_matrix_step</code></h3>
<p><code>gfx_view_matrix_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_view_matrix_step $x
# or in a pipeline:
@list |> map gfx_view_matrix_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-voronoi-distance">
<h3><a class="doc-anchor" href="#doc-gfx-voronoi-distance">#</a> <code>gfx_voronoi_distance</code></h3>
<p><code>gfx_voronoi_distance</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_voronoi_distance $x
# or in a pipeline:
@list |> map gfx_voronoi_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-worley-noise-step">
<h3><a class="doc-anchor" href="#doc-gfx-worley-noise-step">#</a> <code>gfx_worley_noise_step</code></h3>
<p><code>gfx_worley_noise_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_worley_noise_step $x
# or in a pipeline:
@list |> map gfx_worley_noise_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-xiaolin-wu-intensity">
<h3><a class="doc-anchor" href="#doc-gfx-xiaolin-wu-intensity">#</a> <code>gfx_xiaolin_wu_intensity</code></h3>
<p><code>gfx_xiaolin_wu_intensity</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_xiaolin_wu_intensity $x
# or in a pipeline:
@list |> map gfx_xiaolin_wu_intensity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-xorshift-step">
<h3><a class="doc-anchor" href="#doc-gfx-xorshift-step">#</a> <code>gfx_xorshift_step</code></h3>
<p><code>gfx_xorshift_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_xorshift_step $x
# or in a pipeline:
@list |> map gfx_xorshift_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gfx-zonal-harmonic-step">
<h3><a class="doc-anchor" href="#doc-gfx-zonal-harmonic-step">#</a> <code>gfx_zonal_harmonic_step</code></h3>
<p><code>gfx_zonal_harmonic_step</code> — batch 47 builtin.</p>
<pre><code class="lang-perl">my $result = gfx_zonal_harmonic_step $x
# or in a pipeline:
@list |> map gfx_zonal_harmonic_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ghz-state">
<h3><a class="doc-anchor" href="#doc-ghz-state">#</a> <code>ghz_state</code></h3>
<p><code>ghz_state</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = ghz_state $x
# or in a pipeline:
@list |> map ghz_state |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ghz-state-n">
<h3><a class="doc-anchor" href="#doc-ghz-state-n">#</a> <code>ghz_state_n</code></h3>
<p><code>ghz_state_n</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = ghz_state_n $x
# or in a pipeline:
@list |> map ghz_state_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gibbard-satterthwaite-check">
<h3><a class="doc-anchor" href="#doc-gibbard-satterthwaite-check">#</a> <code>gibbard_satterthwaite_check</code></h3>
<p><code>gibbard_satterthwaite_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = gibbard_satterthwaite_check $x
# or in a pipeline:
@list |> map gibbard_satterthwaite_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gibbs-thomson-undercooling">
<h3><a class="doc-anchor" href="#doc-gibbs-thomson-undercooling">#</a> <code>gibbs_thomson_undercooling</code></h3>
<p><code>gibbs_thomson_undercooling</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = gibbs_thomson_undercooling $x
# or in a pipeline:
@list |> map gibbs_thomson_undercooling |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gid">
<h3><a class="doc-anchor" href="#doc-gid">#</a> <code>gid</code></h3>
<p><code>gid</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = gid $x
# or in a pipeline:
@list |> map gid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gin">
<h3><a class="doc-anchor" href="#doc-gin">#</a> <code>gin</code></h3>
<p><code>gin</code> — algebraic match builtin. Alias for <code>get_in</code>.</p>
<pre><code class="lang-perl">my $result = gin $x
# or in a pipeline:
@list |> map gin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gini">
<h3><a class="doc-anchor" href="#doc-gini">#</a> <code>gini</code></h3>
<p><code>gini(@data)</code> (alias <code>gini_coefficient</code>) — computes the Gini coefficient measuring inequality in a distribution. Returns a value from 0 (perfect equality) to 1 (perfect inequality). Commonly used for income distribution analysis.</p>
<pre><code class="lang-perl">p gini(1, 1, 1, 1) # 0 (perfect equality)
p gini(0, 0, 0, 100) # ~0.75 (high inequality)
</code></pre>
</article>
<article class="doc-entry" id="doc-gini-impurity">
<h3><a class="doc-anchor" href="#doc-gini-impurity">#</a> <code>gini_impurity</code></h3>
<p><code>gini_impurity</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = gini_impurity $x
# or in a pipeline:
@list |> map gini_impurity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gini-inequality-health">
<h3><a class="doc-anchor" href="#doc-gini-inequality-health">#</a> <code>gini_inequality_health</code></h3>
<p><code>gini_inequality_health</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = gini_inequality_health $x
# or in a pipeline:
@list |> map gini_inequality_health |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gini-market">
<h3><a class="doc-anchor" href="#doc-gini-market">#</a> <code>gini_market</code></h3>
<p><code>gini_market</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = gini_market $x
# or in a pipeline:
@list |> map gini_market |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-girth">
<h3><a class="doc-anchor" href="#doc-girth">#</a> <code>girth</code></h3>
<p><code>girth</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = girth $x
# or in a pipeline:
@list |> map girth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-girvan-newman">
<h3><a class="doc-anchor" href="#doc-girvan-newman">#</a> <code>girvan_newman</code></h3>
<p><code>girvan_newman</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = girvan_newman $x
# or in a pipeline:
@list |> map girvan_newman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gk15">
<h3><a class="doc-anchor" href="#doc-gk15">#</a> <code>gk15</code></h3>
<p><code>gk15</code> — batch 19 builtin. Alias for <code>gauss_kronrod_15</code>.</p>
<pre><code class="lang-perl">my $result = gk15 $x
# or in a pipeline:
@list |> map gk15 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gl5">
<h3><a class="doc-anchor" href="#doc-gl5">#</a> <code>gl5</code></h3>
<p><code>gl5</code> — batch 19 builtin. Alias for <code>gauss_legendre_5</code>.</p>
<pre><code class="lang-perl">my $result = gl5 $x
# or in a pipeline:
@list |> map gl5 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-glaisher">
<h3><a class="doc-anchor" href="#doc-glaisher">#</a> <code>glaisher</code></h3>
<p><code>glaisher</code> — math constants builtin. Alias for <code>glaisher_constant</code>.</p>
<pre><code class="lang-perl">my $result = glaisher $x
# or in a pipeline:
@list |> map glaisher |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-glaisher-constant">
<h3><a class="doc-anchor" href="#doc-glaisher-constant">#</a> <code>glaisher_constant</code></h3>
<p><code>glaisher_constant</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = glaisher_constant $x
# or in a pipeline:
@list |> map glaisher_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-glicko-rating">
<h3><a class="doc-anchor" href="#doc-glicko-rating">#</a> <code>glicko_rating</code></h3>
<p><code>glicko_rating</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = glicko_rating $x
# or in a pipeline:
@list |> map glicko_rating |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-glm">
<h3><a class="doc-anchor" href="#doc-glm">#</a> <code>glm</code></h3>
<p><code>glm</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = glm $x
# or in a pipeline:
@list |> map glm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-glob-to-regex">
<h3><a class="doc-anchor" href="#doc-glob-to-regex">#</a> <code>glob_to_regex</code></h3>
<p><code>glob_to_regex</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = glob_to_regex $input
</code></pre>
</article>
<article class="doc-entry" id="doc-global-efficiency">
<h3><a class="doc-anchor" href="#doc-global-efficiency">#</a> <code>global_efficiency</code></h3>
<p><code>global_efficiency</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = global_efficiency $x
# or in a pipeline:
@list |> map global_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-glushkov-construction">
<h3><a class="doc-anchor" href="#doc-glushkov-construction">#</a> <code>glushkov_construction</code></h3>
<p><code>glushkov_construction</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = glushkov_construction $x
# or in a pipeline:
@list |> map glushkov_construction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gmm-moment-condition">
<h3><a class="doc-anchor" href="#doc-gmm-moment-condition">#</a> <code>gmm_moment_condition</code></h3>
<p><code>gmm_moment_condition</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = gmm_moment_condition $x
# or in a pipeline:
@list |> map gmm_moment_condition |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gmm-moment-function">
<h3><a class="doc-anchor" href="#doc-gmm-moment-function">#</a> <code>gmm_moment_function</code></h3>
<p><code>gmm_moment_function</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = gmm_moment_function $x
# or in a pipeline:
@list |> map gmm_moment_function |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-go-enrichment-p">
<h3><a class="doc-anchor" href="#doc-go-enrichment-p">#</a> <code>go_enrichment_p</code></h3>
<p><code>go_enrichment_p</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = go_enrichment_p $x
# or in a pipeline:
@list |> map go_enrichment_p |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-goals-above-avg">
<h3><a class="doc-anchor" href="#doc-goals-above-avg">#</a> <code>goals_above_avg</code></h3>
<p><code>goals_above_avg</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = goals_above_avg $x
# or in a pipeline:
@list |> map goals_above_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-goertzel">
<h3><a class="doc-anchor" href="#doc-goertzel">#</a> <code>goertzel</code></h3>
<p><code>goertzel</code> computes the magnitude of a single DFT frequency bin using the Goertzel algorithm. Much faster than full FFT when you need one frequency.</p>
<pre><code class="lang-perl">my $mag = goertzel(\@signal, 440, 44100) # 440 Hz component
</code></pre>
</article>
<article class="doc-entry" id="doc-goldb">
<h3><a class="doc-anchor" href="#doc-goldb">#</a> <code>goldb</code></h3>
<p><code>goldb</code> — math / numeric (uncategorized batch) builtin. Alias for <code>goldbach</code>.</p>
<pre><code class="lang-perl">my $result = goldb $x
# or in a pipeline:
@list |> map goldb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-goldbach">
<h3><a class="doc-anchor" href="#doc-goldbach">#</a> <code>goldbach</code></h3>
<p><code>goldbach</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = goldbach $x
# or in a pipeline:
@list |> map goldbach |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-goldbach-pair">
<h3><a class="doc-anchor" href="#doc-goldbach-pair">#</a> <code>goldbach_pair</code></h3>
<p><code>goldbach_pair</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = goldbach_pair $x
# or in a pipeline:
@list |> map goldbach_pair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-golden">
<h3><a class="doc-anchor" href="#doc-golden">#</a> <code>golden</code></h3>
<p><code>golden_section</code> (aliases <code>golden</code>, <code>gss</code>) finds the minimum of f on [a,b] via golden-section search.</p>
<pre><code class="lang-perl">my $xmin = golden(fn { ($_[0]-3)**2 }, 0, 10) # 3.0
</code></pre>
</article>
<article class="doc-entry" id="doc-golden-ratio">
<h3><a class="doc-anchor" href="#doc-golden-ratio">#</a> <code>golden_ratio</code></h3>
<p><code>golden_ratio</code> (alias <code>phi</code>) — φ = (1+√5)/2 ≈ 1.618. The golden ratio, appears throughout nature and art.</p>
<pre><code class="lang-perl">p phi # 1.618033988749895
# Fibonacci limit: fib(n)/fib(n-1) → φ
</code></pre>
</article>
<article class="doc-entry" id="doc-goldfeld-quandt">
<h3><a class="doc-anchor" href="#doc-goldfeld-quandt">#</a> <code>goldfeld_quandt</code></h3>
<p><code>goldfeld_quandt</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = goldfeld_quandt $x
# or in a pipeline:
@list |> map goldfeld_quandt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-golomb-rice-code">
<h3><a class="doc-anchor" href="#doc-golomb-rice-code">#</a> <code>golomb_rice_code</code></h3>
<p><code>golomb_rice_code</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = golomb_rice_code $x
# or in a pipeline:
@list |> map golomb_rice_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-golstep">
<h3><a class="doc-anchor" href="#doc-golstep">#</a> <code>golstep</code></h3>
<p><code>golstep</code> — algorithms / puzzles builtin. Alias for <code>game_of_life_step</code>.</p>
<pre><code class="lang-perl">my $result = golstep $x
# or in a pipeline:
@list |> map golstep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gomory-cut-step">
<h3><a class="doc-anchor" href="#doc-gomory-cut-step">#</a> <code>gomory_cut_step</code></h3>
<p><code>gomory_cut_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = gomory_cut_step $x
# or in a pipeline:
@list |> map gomory_cut_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gomory-hu-step">
<h3><a class="doc-anchor" href="#doc-gomory-hu-step">#</a> <code>gomory_hu_step</code></h3>
<p><code>gomory_hu_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = gomory_hu_step $x
# or in a pipeline:
@list |> map gomory_hu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gompertz-growth-step">
<h3><a class="doc-anchor" href="#doc-gompertz-growth-step">#</a> <code>gompertz_growth_step</code></h3>
<p><code>gompertz_growth_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = gompertz_growth_step $x
# or in a pipeline:
@list |> map gompertz_growth_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gompertz-pdf">
<h3><a class="doc-anchor" href="#doc-gompertz-pdf">#</a> <code>gompertz_pdf</code></h3>
<p><code>gompertz_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = gompertz_pdf $x
# or in a pipeline:
@list |> map gompertz_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-goto">
<h3><a class="doc-anchor" href="#doc-goto">#</a> <code>goto</code></h3>
<p><code>goto</code> — control flow builtin.</p>
<pre><code class="lang-perl">my $result = goto $x
# or in a pipeline:
@list |> map goto |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gouy-chapman-potential">
<h3><a class="doc-anchor" href="#doc-gouy-chapman-potential">#</a> <code>gouy_chapman_potential</code></h3>
<p><code>gouy_chapman_potential</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = gouy_chapman_potential $x
# or in a pipeline:
@list |> map gouy_chapman_potential |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gradient-descent-step">
<h3><a class="doc-anchor" href="#doc-gradient-descent-step">#</a> <code>gradient_descent_step</code></h3>
<p><code>gradient_descent_step</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = gradient_descent_step $x
# or in a pipeline:
@list |> map gradient_descent_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gradient-geothermal">
<h3><a class="doc-anchor" href="#doc-gradient-geothermal">#</a> <code>gradient_geothermal</code></h3>
<p><code>gradient_geothermal</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = gradient_geothermal $x
# or in a pipeline:
@list |> map gradient_geothermal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gradient-richardson-full">
<h3><a class="doc-anchor" href="#doc-gradient-richardson-full">#</a> <code>gradient_richardson_full</code></h3>
<p><code>gradient_richardson_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = gradient_richardson_full $x
# or in a pipeline:
@list |> map gradient_richardson_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gradient-temporal-diff">
<h3><a class="doc-anchor" href="#doc-gradient-temporal-diff">#</a> <code>gradient_temporal_diff</code></h3>
<p><code>gradient_temporal_diff</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = gradient_temporal_diff $x
# or in a pipeline:
@list |> map gradient_temporal_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gradient-wind-step">
<h3><a class="doc-anchor" href="#doc-gradient-wind-step">#</a> <code>gradient_wind_step</code></h3>
<p><code>gradient_wind_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = gradient_wind_step $x
# or in a pipeline:
@list |> map gradient_wind_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graham-2approx-bound">
<h3><a class="doc-anchor" href="#doc-graham-2approx-bound">#</a> <code>graham_2approx_bound</code></h3>
<p><code>graham_2approx_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = graham_2approx_bound $x
# or in a pipeline:
@list |> map graham_2approx_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gram-schmidt">
<h3><a class="doc-anchor" href="#doc-gram-schmidt">#</a> <code>gram_schmidt</code></h3>
<p><code>gram_schmidt</code> — batch 11 builtin. Alias for <code>orthogonalize_vectors</code>.</p>
<pre><code class="lang-perl">my $result = gram_schmidt $x
# or in a pipeline:
@list |> map gram_schmidt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-granger-causality">
<h3><a class="doc-anchor" href="#doc-granger-causality">#</a> <code>granger_causality</code></h3>
<p><code>granger_causality</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = granger_causality $x
# or in a pipeline:
@list |> map granger_causality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-granger-causality-chi2">
<h3><a class="doc-anchor" href="#doc-granger-causality-chi2">#</a> <code>granger_causality_chi2</code></h3>
<p><code>granger_causality_chi2</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = granger_causality_chi2 $x
# or in a pipeline:
@list |> map granger_causality_chi2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-average-degree">
<h3><a class="doc-anchor" href="#doc-graph-average-degree">#</a> <code>graph_average_degree</code></h3>
<p><code>graph_average_degree</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = graph_average_degree $x
# or in a pipeline:
@list |> map graph_average_degree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-avg-clustering">
<h3><a class="doc-anchor" href="#doc-graph-avg-clustering">#</a> <code>graph_avg_clustering</code></h3>
<p><code>graph_avg_clustering</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_avg_clustering $x
# or in a pipeline:
@list |> map graph_avg_clustering |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-bipartite-match-simple">
<h3><a class="doc-anchor" href="#doc-graph-bipartite-match-simple">#</a> <code>graph_bipartite_match_simple</code></h3>
<p><code>graph_bipartite_match_simple</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_bipartite_match_simple $x
# or in a pipeline:
@list |> map graph_bipartite_match_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-coloring-brooks-bound">
<h3><a class="doc-anchor" href="#doc-graph-coloring-brooks-bound">#</a> <code>graph_coloring_brooks_bound</code></h3>
<p><code>graph_coloring_brooks_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = graph_coloring_brooks_bound $x
# or in a pipeline:
@list |> map graph_coloring_brooks_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-coloring-dsatur-step">
<h3><a class="doc-anchor" href="#doc-graph-coloring-dsatur-step">#</a> <code>graph_coloring_dsatur_step</code></h3>
<p><code>graph_coloring_dsatur_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = graph_coloring_dsatur_step $x
# or in a pipeline:
@list |> map graph_coloring_dsatur_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-coloring-greedy">
<h3><a class="doc-anchor" href="#doc-graph-coloring-greedy">#</a> <code>graph_coloring_greedy</code></h3>
<p><code>graph_coloring_greedy</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = graph_coloring_greedy $x
# or in a pipeline:
@list |> map graph_coloring_greedy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-coloring-lp-bound">
<h3><a class="doc-anchor" href="#doc-graph-coloring-lp-bound">#</a> <code>graph_coloring_lp_bound</code></h3>
<p><code>graph_coloring_lp_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = graph_coloring_lp_bound $x
# or in a pipeline:
@list |> map graph_coloring_lp_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-coloring-welsh-powell">
<h3><a class="doc-anchor" href="#doc-graph-coloring-welsh-powell">#</a> <code>graph_coloring_welsh_powell</code></h3>
<p><code>graph_coloring_welsh_powell</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = graph_coloring_welsh_powell $x
# or in a pipeline:
@list |> map graph_coloring_welsh_powell |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-complement">
<h3><a class="doc-anchor" href="#doc-graph-complement">#</a> <code>graph_complement</code></h3>
<p><code>graph_complement</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = graph_complement $x
# or in a pipeline:
@list |> map graph_complement |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-count-edges">
<h3><a class="doc-anchor" href="#doc-graph-count-edges">#</a> <code>graph_count_edges</code></h3>
<p><code>graph_count_edges</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_count_edges $x
# or in a pipeline:
@list |> map graph_count_edges |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-count-paths-length-k">
<h3><a class="doc-anchor" href="#doc-graph-count-paths-length-k">#</a> <code>graph_count_paths_length_k</code></h3>
<p><code>graph_count_paths_length_k</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_count_paths_length_k $x
# or in a pipeline:
@list |> map graph_count_paths_length_k |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-count-triangles">
<h3><a class="doc-anchor" href="#doc-graph-count-triangles">#</a> <code>graph_count_triangles</code></h3>
<p><code>graph_count_triangles</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_count_triangles $x
# or in a pipeline:
@list |> map graph_count_triangles |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-cut-segment">
<h3><a class="doc-anchor" href="#doc-graph-cut-segment">#</a> <code>graph_cut_segment</code></h3>
<p><code>graph_cut_segment</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = graph_cut_segment $x
# or in a pipeline:
@list |> map graph_cut_segment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-degree-distribution">
<h3><a class="doc-anchor" href="#doc-graph-degree-distribution">#</a> <code>graph_degree_distribution</code></h3>
<p><code>graph_degree_distribution</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_degree_distribution $x
# or in a pipeline:
@list |> map graph_degree_distribution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-density">
<h3><a class="doc-anchor" href="#doc-graph-density">#</a> <code>graph_density</code></h3>
<p><code>graph_density</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = graph_density $x
# or in a pipeline:
@list |> map graph_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-eccentricity-all">
<h3><a class="doc-anchor" href="#doc-graph-eccentricity-all">#</a> <code>graph_eccentricity_all</code></h3>
<p><code>graph_eccentricity_all</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = graph_eccentricity_all $x
# or in a pipeline:
@list |> map graph_eccentricity_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-independent-set-brute">
<h3><a class="doc-anchor" href="#doc-graph-independent-set-brute">#</a> <code>graph_independent_set_brute</code></h3>
<p><code>graph_independent_set_brute</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_independent_set_brute $x
# or in a pipeline:
@list |> map graph_independent_set_brute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-is-tree">
<h3><a class="doc-anchor" href="#doc-graph-is-tree">#</a> <code>graph_is_tree</code></h3>
<p><code>graph_is_tree</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = graph_is_tree $x
# or in a pipeline:
@list |> map graph_is_tree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-max-clique-brute">
<h3><a class="doc-anchor" href="#doc-graph-max-clique-brute">#</a> <code>graph_max_clique_brute</code></h3>
<p><code>graph_max_clique_brute</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_max_clique_brute $x
# or in a pipeline:
@list |> map graph_max_clique_brute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-max-degree">
<h3><a class="doc-anchor" href="#doc-graph-max-degree">#</a> <code>graph_max_degree</code></h3>
<p><code>graph_max_degree</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = graph_max_degree $x
# or in a pipeline:
@list |> map graph_max_degree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-min-degree">
<h3><a class="doc-anchor" href="#doc-graph-min-degree">#</a> <code>graph_min_degree</code></h3>
<p><code>graph_min_degree</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = graph_min_degree $x
# or in a pipeline:
@list |> map graph_min_degree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-pagerank-simple">
<h3><a class="doc-anchor" href="#doc-graph-pagerank-simple">#</a> <code>graph_pagerank_simple</code></h3>
<p><code>graph_pagerank_simple</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_pagerank_simple $x
# or in a pipeline:
@list |> map graph_pagerank_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-graph-transitivity">
<h3><a class="doc-anchor" href="#doc-graph-transitivity">#</a> <code>graph_transitivity</code></h3>
<p><code>graph_transitivity</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = graph_transitivity $x
# or in a pipeline:
@list |> map graph_transitivity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grashof-number">
<h3><a class="doc-anchor" href="#doc-grashof-number">#</a> <code>grashof_number</code></h3>
<p><code>grashof_number</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = grashof_number $x
# or in a pipeline:
@list |> map grashof_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grashof-number-step">
<h3><a class="doc-anchor" href="#doc-grashof-number-step">#</a> <code>grashof_number_step</code></h3>
<p><code>grashof_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = grashof_number_step $x
# or in a pipeline:
@list |> map grashof_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grav-binding-energy">
<h3><a class="doc-anchor" href="#doc-grav-binding-energy">#</a> <code>grav_binding_energy</code></h3>
<p><code>grav_binding_energy</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = grav_binding_energy $x
# or in a pipeline:
@list |> map grav_binding_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grav-dilation-factor">
<h3><a class="doc-anchor" href="#doc-grav-dilation-factor">#</a> <code>grav_dilation_factor</code></h3>
<p><code>grav_dilation_factor</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = grav_dilation_factor $x
# or in a pipeline:
@list |> map grav_dilation_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grav-redshift">
<h3><a class="doc-anchor" href="#doc-grav-redshift">#</a> <code>grav_redshift</code></h3>
<p><code>grav_redshift</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = grav_redshift $x
# or in a pipeline:
@list |> map grav_redshift |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grav-time-dilation">
<h3><a class="doc-anchor" href="#doc-grav-time-dilation">#</a> <code>grav_time_dilation</code></h3>
<p><code>grav_time_dilation</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = grav_time_dilation $x
# or in a pipeline:
@list |> map grav_time_dilation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gravitational-constant">
<h3><a class="doc-anchor" href="#doc-gravitational-constant">#</a> <code>gravitational_constant</code></h3>
<p><code>gravitational_constant</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = gravitational_constant $x
# or in a pipeline:
@list |> map gravitational_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gravitational-pe">
<h3><a class="doc-anchor" href="#doc-gravitational-pe">#</a> <code>gravitational_pe</code></h3>
<p><code>gravitational_pe</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = gravitational_pe $x
# or in a pipeline:
@list |> map gravitational_pe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gravitational-wave-quadrupole">
<h3><a class="doc-anchor" href="#doc-gravitational-wave-quadrupole">#</a> <code>gravitational_wave_quadrupole</code></h3>
<p><code>gravitational_wave_quadrupole</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = gravitational_wave_quadrupole $x
# or in a pipeline:
@list |> map gravitational_wave_quadrupole |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gravity">
<h3><a class="doc-anchor" href="#doc-gravity">#</a> <code>gravity</code></h3>
<p><code>gravity</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = gravity $x
# or in a pipeline:
@list |> map gravity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gravity-at-radius">
<h3><a class="doc-anchor" href="#doc-gravity-at-radius">#</a> <code>gravity_at_radius</code></h3>
<p><code>gravity_at_radius</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = gravity_at_radius $x
# or in a pipeline:
@list |> map gravity_at_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gray">
<h3><a class="doc-anchor" href="#doc-gray">#</a> <code>gray</code></h3>
<p><code>gray</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = gray $x
# or in a pipeline:
@list |> map gray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gray2b">
<h3><a class="doc-anchor" href="#doc-gray2b">#</a> <code>gray2b</code></h3>
<p><code>gray2b</code> — base / gray code builtin. Alias for <code>gray_to_binary</code>.</p>
<pre><code class="lang-perl">my $result = gray2b $x
# or in a pipeline:
@list |> map gray2b |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gray-code-sequence">
<h3><a class="doc-anchor" href="#doc-gray-code-sequence">#</a> <code>gray_code_sequence</code></h3>
<p><code>gray_code_sequence</code> — base / gray code builtin.</p>
<pre><code class="lang-perl">my $result = gray_code_sequence $x
# or in a pipeline:
@list |> map gray_code_sequence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gray-to-bin">
<h3><a class="doc-anchor" href="#doc-gray-to-bin">#</a> <code>gray_to_bin</code></h3>
<p><code>gray_to_bin</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = gray_to_bin $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gray-to-binary">
<h3><a class="doc-anchor" href="#doc-gray-to-binary">#</a> <code>gray_to_binary</code></h3>
<p><code>gray_to_binary</code> — base / gray code builtin.</p>
<pre><code class="lang-perl">my $result = gray_to_binary $input
</code></pre>
</article>
<article class="doc-entry" id="doc-grayseq">
<h3><a class="doc-anchor" href="#doc-grayseq">#</a> <code>grayseq</code></h3>
<p><code>grayseq</code> — base / gray code builtin. Alias for <code>gray_code_sequence</code>.</p>
<pre><code class="lang-perl">my $result = grayseq $x
# or in a pipeline:
@list |> map grayseq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-great-circle-law-of-cos">
<h3><a class="doc-anchor" href="#doc-great-circle-law-of-cos">#</a> <code>great_circle_law_of_cos</code></h3>
<p><code>great_circle_law_of_cos</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = great_circle_law_of_cos $x
# or in a pipeline:
@list |> map great_circle_law_of_cos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-greedy-coloring">
<h3><a class="doc-anchor" href="#doc-greedy-coloring">#</a> <code>greedy_coloring</code></h3>
<p><code>greedy_coloring</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = greedy_coloring $x
# or in a pipeline:
@list |> map greedy_coloring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-greedy-edge-tour">
<h3><a class="doc-anchor" href="#doc-greedy-edge-tour">#</a> <code>greedy_edge_tour</code></h3>
<p><code>greedy_edge_tour</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = greedy_edge_tour $x
# or in a pipeline:
@list |> map greedy_edge_tour |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-greedy-set-cover-round">
<h3><a class="doc-anchor" href="#doc-greedy-set-cover-round">#</a> <code>greedy_set_cover_round</code></h3>
<p><code>greedy_set_cover_round</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = greedy_set_cover_round $x
# or in a pipeline:
@list |> map greedy_set_cover_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-green">
<h3><a class="doc-anchor" href="#doc-green">#</a> <code>green</code></h3>
<p><code>green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = green $x
# or in a pipeline:
@list |> map green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-green-bold">
<h3><a class="doc-anchor" href="#doc-green-bold">#</a> <code>green_bold</code></h3>
<p><code>green_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = green_bold $x
# or in a pipeline:
@list |> map green_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-greenhouse-forcing-step">
<h3><a class="doc-anchor" href="#doc-greenhouse-forcing-step">#</a> <code>greenhouse_forcing_step</code></h3>
<p><code>greenhouse_forcing_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = greenhouse_forcing_step $x
# or in a pipeline:
@list |> map greenhouse_forcing_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gregorian-from-fixed">
<h3><a class="doc-anchor" href="#doc-gregorian-from-fixed">#</a> <code>gregorian_from_fixed</code></h3>
<p><code>gregorian_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = gregorian_from_fixed $x
# or in a pipeline:
@list |> map gregorian_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grepv">
<h3><a class="doc-anchor" href="#doc-grepv">#</a> <code>grepv</code></h3>
<p><code>grepv</code> — functional / iterator builtin. Alias for <code>take_while</code>.</p>
<pre><code class="lang-perl">my $result = grepv $x
# or in a pipeline:
@list |> map grepv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grey">
<h3><a class="doc-anchor" href="#doc-grey">#</a> <code>grey</code></h3>
<p><code>grey</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = grey $x
# or in a pipeline:
@list |> map grey |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grim-trigger-step">
<h3><a class="doc-anchor" href="#doc-grim-trigger-step">#</a> <code>grim_trigger_step</code></h3>
<p><code>grim_trigger_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = grim_trigger_step $x
# or in a pipeline:
@list |> map grim_trigger_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gromov-wasserstein-step">
<h3><a class="doc-anchor" href="#doc-gromov-wasserstein-step">#</a> <code>gromov_wasserstein_step</code></h3>
<p><code>gromov_wasserstein_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = gromov_wasserstein_step $x
# or in a pipeline:
@list |> map gromov_wasserstein_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gromov-witten-invariant">
<h3><a class="doc-anchor" href="#doc-gromov-witten-invariant">#</a> <code>gromov_witten_invariant</code></h3>
<p><code>gromov_witten_invariant</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = gromov_witten_invariant $x
# or in a pipeline:
@list |> map gromov_witten_invariant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gross-premium-load">
<h3><a class="doc-anchor" href="#doc-gross-premium-load">#</a> <code>gross_premium_load</code></h3>
<p><code>gross_premium_load</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = gross_premium_load $x
# or in a pipeline:
@list |> map gross_premium_load |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-by">
<h3><a class="doc-anchor" href="#doc-group-by">#</a> <code>group_by</code></h3>
<p><code>group_by</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = group_by $x
# or in a pipeline:
@list |> map group_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-by-fn">
<h3><a class="doc-anchor" href="#doc-group-by-fn">#</a> <code>group_by_fn</code></h3>
<p><code>group_by_fn</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = group_by_fn $x
# or in a pipeline:
@list |> map group_by_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-by-size">
<h3><a class="doc-anchor" href="#doc-group-by-size">#</a> <code>group_by_size</code></h3>
<p><code>group_by_size</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = group_by_size $x
# or in a pipeline:
@list |> map group_by_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-cohomology-dim">
<h3><a class="doc-anchor" href="#doc-group-cohomology-dim">#</a> <code>group_cohomology_dim</code></h3>
<p><code>group_cohomology_dim</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = group_cohomology_dim $x
# or in a pipeline:
@list |> map group_cohomology_dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-consecutive">
<h3><a class="doc-anchor" href="#doc-group-consecutive">#</a> <code>group_consecutive</code></h3>
<p><code>group_consecutive</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = group_consecutive $x
# or in a pipeline:
@list |> map group_consecutive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-consecutive-by">
<h3><a class="doc-anchor" href="#doc-group-consecutive-by">#</a> <code>group_consecutive_by</code></h3>
<p><code>group_consecutive_by</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = group_consecutive_by $x
# or in a pipeline:
@list |> map group_consecutive_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-delay-eval">
<h3><a class="doc-anchor" href="#doc-group-delay-eval">#</a> <code>group_delay_eval</code></h3>
<p><code>group_delay_eval</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = group_delay_eval $x
# or in a pipeline:
@list |> map group_delay_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-homology-dim">
<h3><a class="doc-anchor" href="#doc-group-homology-dim">#</a> <code>group_homology_dim</code></h3>
<p><code>group_homology_dim</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = group_homology_dim $x
# or in a pipeline:
@list |> map group_homology_dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-number">
<h3><a class="doc-anchor" href="#doc-group-number">#</a> <code>group_number</code></h3>
<p><code>group_number</code> — file stat / path builtin. Alias for <code>format_number</code>.</p>
<pre><code class="lang-perl">my $result = group_number $x
# or in a pipeline:
@list |> map group_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-of-n">
<h3><a class="doc-anchor" href="#doc-group-of-n">#</a> <code>group_of_n</code></h3>
<p><code>group_of_n</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = group_of_n $x
# or in a pipeline:
@list |> map group_of_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-runs">
<h3><a class="doc-anchor" href="#doc-group-runs">#</a> <code>group_runs</code></h3>
<p><code>group_runs</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = group_runs $x
# or in a pipeline:
@list |> map group_runs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-groupby-iter">
<h3><a class="doc-anchor" href="#doc-groupby-iter">#</a> <code>groupby_iter</code></h3>
<p><code>groupby_iter</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = groupby_iter $x
# or in a pipeline:
@list |> map groupby_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grover-iter">
<h3><a class="doc-anchor" href="#doc-grover-iter">#</a> <code>grover_iter</code></h3>
<p><code>grover_iter</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = grover_iter $x
# or in a pipeline:
@list |> map grover_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-growing-perpetuity">
<h3><a class="doc-anchor" href="#doc-growing-perpetuity">#</a> <code>growing_perpetuity</code></h3>
<p><code>growing_perpetuity</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = growing_perpetuity $x
# or in a pipeline:
@list |> map growing_perpetuity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-growth-rate-from-ratio">
<h3><a class="doc-anchor" href="#doc-growth-rate-from-ratio">#</a> <code>growth_rate_from_ratio</code></h3>
<p><code>growth_rate_from_ratio</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = growth_rate_from_ratio $x
# or in a pipeline:
@list |> map growth_rate_from_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gruns">
<h3><a class="doc-anchor" href="#doc-gruns">#</a> <code>gruns</code></h3>
<p><code>gruns</code> — haskell list functions builtin. Alias for <code>group_runs</code>.</p>
<pre><code class="lang-perl">my $result = gruns $x
# or in a pipeline:
@list |> map gruns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gullstrand-painleve-step">
<h3><a class="doc-anchor" href="#doc-gullstrand-painleve-step">#</a> <code>gullstrand_painleve_step</code></h3>
<p><code>gullstrand_painleve_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = gullstrand_painleve_step $x
# or in a pipeline:
@list |> map gullstrand_painleve_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gunning-fog">
<h3><a class="doc-anchor" href="#doc-gunning-fog">#</a> <code>gunning_fog</code></h3>
<p><code>gunning_fog</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = gunning_fog $x
# or in a pipeline:
@list |> map gunning_fog |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gutenberg-richter-b">
<h3><a class="doc-anchor" href="#doc-gutenberg-richter-b">#</a> <code>gutenberg_richter_b</code></h3>
<p><code>gutenberg_richter_b</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = gutenberg_richter_b $x
# or in a pipeline:
@list |> map gutenberg_richter_b |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gw-strain-amplitude">
<h3><a class="doc-anchor" href="#doc-gw-strain-amplitude">#</a> <code>gw_strain_amplitude</code></h3>
<p><code>gw_strain_amplitude</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = gw_strain_amplitude $x
# or in a pipeline:
@list |> map gw_strain_amplitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gx-diameter">
<h3><a class="doc-anchor" href="#doc-gx-diameter">#</a> <code>gx_diameter</code></h3>
<p><code>gx_diameter</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = gx_diameter $x
# or in a pipeline:
@list |> map gx_diameter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gx-eccentricity">
<h3><a class="doc-anchor" href="#doc-gx-eccentricity">#</a> <code>gx_eccentricity</code></h3>
<p><code>gx_eccentricity</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = gx_eccentricity $x
# or in a pipeline:
@list |> map gx_eccentricity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gx-radius">
<h3><a class="doc-anchor" href="#doc-gx-radius">#</a> <code>gx_radius</code></h3>
<p><code>gx_radius</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = gx_radius $x
# or in a pipeline:
@list |> map gx_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gz">
<h3><a class="doc-anchor" href="#doc-gz">#</a> <code>gz</code></h3>
<p><code>gz</code> — crypto / encoding builtin. Alias for <code>gzip</code>.</p>
<pre><code class="lang-perl">my $result = gz $x
# or in a pipeline:
@list |> map gz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gzip-crc32-init">
<h3><a class="doc-anchor" href="#doc-gzip-crc32-init">#</a> <code>gzip_crc32_init</code></h3>
<p><code>gzip_crc32_init</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = gzip_crc32_init $x
# or in a pipeline:
@list |> map gzip_crc32_init |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gzip-encode-step">
<h3><a class="doc-anchor" href="#doc-gzip-encode-step">#</a> <code>gzip_encode_step</code></h3>
<p><code>gzip_encode_step</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = gzip_encode_step $x
# or in a pipeline:
@list |> map gzip_encode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gzip-isize">
<h3><a class="doc-anchor" href="#doc-gzip-isize">#</a> <code>gzip_isize</code></h3>
<p><code>gzip_isize</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = gzip_isize $x
# or in a pipeline:
@list |> map gzip_isize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gzip-member-step">
<h3><a class="doc-anchor" href="#doc-gzip-member-step">#</a> <code>gzip_member_step</code></h3>
<p><code>gzip_member_step</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = gzip_member_step $x
# or in a pipeline:
@list |> map gzip_member_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-h0">
<h3><a class="doc-anchor" href="#doc-h0">#</a> <code>h0</code></h3>
<p><code>h0</code> — physics constants builtin. Alias for <code>hubble_constant</code>.</p>
<pre><code class="lang-perl">my $result = h0 $x
# or in a pipeline:
@list |> map h0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-h3-geo-to-h3">
<h3><a class="doc-anchor" href="#doc-h3-geo-to-h3">#</a> <code>h3_geo_to_h3</code></h3>
<p><code>h3_geo_to_h3</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = h3_geo_to_h3 $input
</code></pre>
</article>
<article class="doc-entry" id="doc-h3-h3-to-geo">
<h3><a class="doc-anchor" href="#doc-h3-h3-to-geo">#</a> <code>h3_h3_to_geo</code></h3>
<p><code>h3_h3_to_geo</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = h3_h3_to_geo $input
</code></pre>
</article>
<article class="doc-entry" id="doc-h3-index">
<h3><a class="doc-anchor" href="#doc-h3-index">#</a> <code>h3_index</code></h3>
<p><code>h3_index</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = h3_index $x
# or in a pipeline:
@list |> map h3_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-h3-k-ring">
<h3><a class="doc-anchor" href="#doc-h3-k-ring">#</a> <code>h3_k_ring</code></h3>
<p><code>h3_k_ring</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = h3_k_ring $x
# or in a pipeline:
@list |> map h3_k_ring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-h3-neighbor">
<h3><a class="doc-anchor" href="#doc-h3-neighbor">#</a> <code>h3_neighbor</code></h3>
<p><code>h3_neighbor</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = h3_neighbor $x
# or in a pipeline:
@list |> map h3_neighbor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-h3-resolution">
<h3><a class="doc-anchor" href="#doc-h3-resolution">#</a> <code>h3_resolution</code></h3>
<p><code>h3_resolution</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = h3_resolution $x
# or in a pipeline:
@list |> map h3_resolution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-h-infinity-norm">
<h3><a class="doc-anchor" href="#doc-h-infinity-norm">#</a> <code>h_infinity_norm</code></h3>
<p><code>h_infinity_norm</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = h_infinity_norm $x
# or in a pipeline:
@list |> map h_infinity_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-haar-2d-step">
<h3><a class="doc-anchor" href="#doc-haar-2d-step">#</a> <code>haar_2d_step</code></h3>
<p><code>haar_2d_step</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = haar_2d_step $x
# or in a pipeline:
@list |> map haar_2d_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hadamard-walsh-transform-step">
<h3><a class="doc-anchor" href="#doc-hadamard-walsh-transform-step">#</a> <code>hadamard_walsh_transform_step</code></h3>
<p><code>hadamard_walsh_transform_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = hadamard_walsh_transform_step $x
# or in a pipeline:
@list |> map hadamard_walsh_transform_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hadley-cell-max-lat">
<h3><a class="doc-anchor" href="#doc-hadley-cell-max-lat">#</a> <code>hadley_cell_max_lat</code></h3>
<p><code>hadley_cell_max_lat</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = hadley_cell_max_lat $x
# or in a pipeline:
@list |> map hadley_cell_max_lat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hagen-poiseuille-eo">
<h3><a class="doc-anchor" href="#doc-hagen-poiseuille-eo">#</a> <code>hagen_poiseuille_eo</code></h3>
<p><code>hagen_poiseuille_eo</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = hagen_poiseuille_eo $x
# or in a pipeline:
@list |> map hagen_poiseuille_eo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-half">
<h3><a class="doc-anchor" href="#doc-half">#</a> <code>half</code></h3>
<p><code>half</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = half $x
# or in a pipeline:
@list |> map half |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-half-cauchy-pdf">
<h3><a class="doc-anchor" href="#doc-half-cauchy-pdf">#</a> <code>half_cauchy_pdf</code></h3>
<p><code>half_cauchy_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = half_cauchy_pdf $x
# or in a pipeline:
@list |> map half_cauchy_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-half-each">
<h3><a class="doc-anchor" href="#doc-half-each">#</a> <code>half_each</code></h3>
<p><code>half_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = half_each $x
# or in a pipeline:
@list |> map half_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-half-logistic-pdf">
<h3><a class="doc-anchor" href="#doc-half-logistic-pdf">#</a> <code>half_logistic_pdf</code></h3>
<p><code>half_logistic_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = half_logistic_pdf $x
# or in a pipeline:
@list |> map half_logistic_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-half-reaction-balance">
<h3><a class="doc-anchor" href="#doc-half-reaction-balance">#</a> <code>half_reaction_balance</code></h3>
<p><code>half_reaction_balance</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = half_reaction_balance $x
# or in a pipeline:
@list |> map half_reaction_balance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hall-inner-product-two">
<h3><a class="doc-anchor" href="#doc-hall-inner-product-two">#</a> <code>hall_inner_product_two</code></h3>
<p><code>hall_inner_product_two</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = hall_inner_product_two $x
# or in a pipeline:
@list |> map hall_inner_product_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-halley">
<h3><a class="doc-anchor" href="#doc-halley">#</a> <code>halley</code></h3>
<p><code>halley</code> — batch 19 builtin. Alias for <code>halley_root</code>.</p>
<pre><code class="lang-perl">my $result = halley $x
# or in a pipeline:
@list |> map halley |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-halley-root">
<h3><a class="doc-anchor" href="#doc-halley-root">#</a> <code>halley_root</code></h3>
<p><code>halley_root</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = halley_root $x
# or in a pipeline:
@list |> map halley_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamdist">
<h3><a class="doc-anchor" href="#doc-hamdist">#</a> <code>hamdist</code></h3>
<p><code>hamdist</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = hamdist $x
# or in a pipeline:
@list |> map hamdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamdist-int">
<h3><a class="doc-anchor" href="#doc-hamdist-int">#</a> <code>hamdist_int</code></h3>
<p><code>hamdist_int</code> — batch 10 builtin. Alias for <code>hamming_distance_int</code>.</p>
<pre><code class="lang-perl">my $result = hamdist_int $x
# or in a pipeline:
@list |> map hamdist_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamiltonian-brute">
<h3><a class="doc-anchor" href="#doc-hamiltonian-brute">#</a> <code>hamiltonian_brute</code></h3>
<p><code>hamiltonian_brute</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = hamiltonian_brute $x
# or in a pipeline:
@list |> map hamiltonian_brute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamiltonian-path">
<h3><a class="doc-anchor" href="#doc-hamiltonian-path">#</a> <code>hamiltonian_path</code></h3>
<p><code>hamiltonian_path</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = hamiltonian_path $x
# or in a pipeline:
@list |> map hamiltonian_path |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming">
<h3><a class="doc-anchor" href="#doc-hamming">#</a> <code>hamming</code></h3>
<p><code>window_hamming($n)</code> (alias <code>hamming</code>) — generates a Hamming window of length n. Similar to Hann but with slightly different coefficients, optimized for speech processing.</p>
<pre><code class="lang-perl">my $w = hamming(1024)
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming-distance">
<h3><a class="doc-anchor" href="#doc-hamming-distance">#</a> <code>hamming_distance</code></h3>
<p><code>hamming_distance</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = hamming_distance $x
# or in a pipeline:
@list |> map hamming_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming-distance-int">
<h3><a class="doc-anchor" href="#doc-hamming-distance-int">#</a> <code>hamming_distance_int</code></h3>
<p><code>hamming_distance_int</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = hamming_distance_int $x
# or in a pipeline:
@list |> map hamming_distance_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming-distance-str">
<h3><a class="doc-anchor" href="#doc-hamming-distance-str">#</a> <code>hamming_distance_str</code></h3>
<p><code>hamming_distance_str</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = hamming_distance_str $x
# or in a pipeline:
@list |> map hamming_distance_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming-protein">
<h3><a class="doc-anchor" href="#doc-hamming-protein">#</a> <code>hamming_protein</code></h3>
<p><code>hamming_protein</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = hamming_protein $x
# or in a pipeline:
@list |> map hamming_protein |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming-w">
<h3><a class="doc-anchor" href="#doc-hamming-w">#</a> <code>hamming_w</code></h3>
<p><code>hamming_w</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = hamming_w $x
# or in a pipeline:
@list |> map hamming_w |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming-weight">
<h3><a class="doc-anchor" href="#doc-hamming-weight">#</a> <code>hamming_weight</code></h3>
<p><code>hamming_weight</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = hamming_weight $x
# or in a pipeline:
@list |> map hamming_weight |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming-window">
<h3><a class="doc-anchor" href="#doc-hamming-window">#</a> <code>hamming_window</code></h3>
<p><code>hamming_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = hamming_window $x
# or in a pipeline:
@list |> map hamming_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hann">
<h3><a class="doc-anchor" href="#doc-hann">#</a> <code>hann</code></h3>
<p><code>window_hann($n)</code> (alias <code>hann</code>) — generates a Hann (raised cosine) window of length n. Common window function for spectral analysis that reduces spectral leakage.</p>
<pre><code class="lang-perl">my $w = hann(1024)
</code></pre>
</article>
<article class="doc-entry" id="doc-hann-w">
<h3><a class="doc-anchor" href="#doc-hann-w">#</a> <code>hann_w</code></h3>
<p><code>hann_w</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = hann_w $x
# or in a pipeline:
@list |> map hann_w |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hann-window">
<h3><a class="doc-anchor" href="#doc-hann-window">#</a> <code>hann_window</code></h3>
<p><code>hann_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = hann_window $x
# or in a pipeline:
@list |> map hann_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hannan-quinn-ic">
<h3><a class="doc-anchor" href="#doc-hannan-quinn-ic">#</a> <code>hannan_quinn_ic</code></h3>
<p><code>hannan_quinn_ic</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = hannan_quinn_ic $x
# or in a pipeline:
@list |> map hannan_quinn_ic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hanoi">
<h3><a class="doc-anchor" href="#doc-hanoi">#</a> <code>hanoi</code></h3>
<p><code>hanoi</code> — algorithms / puzzles builtin. Alias for <code>tower_of_hanoi</code>.</p>
<pre><code class="lang-perl">my $result = hanoi $x
# or in a pipeline:
@list |> map hanoi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hansen-j-test">
<h3><a class="doc-anchor" href="#doc-hansen-j-test">#</a> <code>hansen_j_test</code></h3>
<p><code>hansen_j_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = hansen_j_test $x
# or in a pipeline:
@list |> map hansen_j_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hard-sigmoid">
<h3><a class="doc-anchor" href="#doc-hard-sigmoid">#</a> <code>hard_sigmoid</code></h3>
<p><code>hard_sigmoid</code> — ml activation functions builtin.</p>
<pre><code class="lang-perl">my $result = hard_sigmoid $x
# or in a pipeline:
@list |> map hard_sigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hard-swish">
<h3><a class="doc-anchor" href="#doc-hard-swish">#</a> <code>hard_swish</code></h3>
<p><code>hard_swish</code> — ml activation functions builtin.</p>
<pre><code class="lang-perl">my $result = hard_swish $x
# or in a pipeline:
@list |> map hard_swish |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hardsigmoid">
<h3><a class="doc-anchor" href="#doc-hardsigmoid">#</a> <code>hardsigmoid</code></h3>
<p><code>hardsigmoid</code> — ml activation functions builtin. Alias for <code>hard_sigmoid</code>.</p>
<pre><code class="lang-perl">my $result = hardsigmoid $x
# or in a pipeline:
@list |> map hardsigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hardswish">
<h3><a class="doc-anchor" href="#doc-hardswish">#</a> <code>hardswish</code></h3>
<p><code>hardswish</code> — ml activation functions builtin. Alias for <code>hard_swish</code>.</p>
<pre><code class="lang-perl">my $result = hardswish $x
# or in a pipeline:
@list |> map hardswish |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonic">
<h3><a class="doc-anchor" href="#doc-harmonic">#</a> <code>harmonic</code></h3>
<p><code>harmonic_number</code> (alias <code>harmonic</code>) computes the nth harmonic number H_n = 1 + 1/2 + 1/3 + ... + 1/n.</p>
<pre><code class="lang-perl">p harmonic(1) # 1.0
p harmonic(10) # 2.9290
p harmonic(100) # 5.1874
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonic-centrality">
<h3><a class="doc-anchor" href="#doc-harmonic-centrality">#</a> <code>harmonic_centrality</code></h3>
<p><code>harmonic_centrality</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = harmonic_centrality $x
# or in a pipeline:
@list |> map harmonic_centrality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonic-mean">
<h3><a class="doc-anchor" href="#doc-harmonic-mean">#</a> <code>harmonic_mean</code></h3>
<p><code>harmonic_mean</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = harmonic_mean $x
# or in a pipeline:
@list |> map harmonic_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonic-mean-arr">
<h3><a class="doc-anchor" href="#doc-harmonic-mean-arr">#</a> <code>harmonic_mean_arr</code></h3>
<p><code>harmonic_mean_arr</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = harmonic_mean_arr $x
# or in a pipeline:
@list |> map harmonic_mean_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonic-oscillator-energy">
<h3><a class="doc-anchor" href="#doc-harmonic-oscillator-energy">#</a> <code>harmonic_oscillator_energy</code></h3>
<p><code>harmonic_oscillator_energy</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = harmonic_oscillator_energy $x
# or in a pipeline:
@list |> map harmonic_oscillator_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonic-seq-sum">
<h3><a class="doc-anchor" href="#doc-harmonic-seq-sum">#</a> <code>harmonic_seq_sum</code></h3>
<p><code>harmonic_seq_sum</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = harmonic_seq_sum $x
# or in a pipeline:
@list |> map harmonic_seq_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonics-partial">
<h3><a class="doc-anchor" href="#doc-harmonics-partial">#</a> <code>harmonics_partial</code></h3>
<p><code>harmonics_partial</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = harmonics_partial $x
# or in a pipeline:
@list |> map harmonics_partial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-harris-corners">
<h3><a class="doc-anchor" href="#doc-harris-corners">#</a> <code>harris_corners</code></h3>
<p><code>harris_corners</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = harris_corners $x
# or in a pipeline:
@list |> map harris_corners |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hartle-thorne-metric">
<h3><a class="doc-anchor" href="#doc-hartle-thorne-metric">#</a> <code>hartle_thorne_metric</code></h3>
<p><code>hartle_thorne_metric</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = hartle_thorne_metric $x
# or in a pipeline:
@list |> map hartle_thorne_metric |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-all-keys">
<h3><a class="doc-anchor" href="#doc-has-all-keys">#</a> <code>has_all_keys</code></h3>
<p><code>has_all_keys</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = has_all_keys $x
# or in a pipeline:
@list |> map has_all_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-any-key">
<h3><a class="doc-anchor" href="#doc-has-any-key">#</a> <code>has_any_key</code></h3>
<p><code>has_any_key</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = has_any_key $x
# or in a pipeline:
@list |> map has_any_key |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-cycle-directed">
<h3><a class="doc-anchor" href="#doc-has-cycle-directed">#</a> <code>has_cycle_directed</code></h3>
<p><code>has_cycle_directed</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = has_cycle_directed $x
# or in a pipeline:
@list |> map has_cycle_directed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-cycle-graph">
<h3><a class="doc-anchor" href="#doc-has-cycle-graph">#</a> <code>has_cycle_graph</code></h3>
<p><code>has_cycle_graph</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = has_cycle_graph $x
# or in a pipeline:
@list |> map has_cycle_graph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-cycle-undirected">
<h3><a class="doc-anchor" href="#doc-has-cycle-undirected">#</a> <code>has_cycle_undirected</code></h3>
<p><code>has_cycle_undirected</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = has_cycle_undirected $x
# or in a pipeline:
@list |> map has_cycle_undirected |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-duplicates">
<h3><a class="doc-anchor" href="#doc-has-duplicates">#</a> <code>has_duplicates</code></h3>
<p><code>has_duplicates</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = has_duplicates $x
# or in a pipeline:
@list |> map has_duplicates |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-key">
<h3><a class="doc-anchor" href="#doc-has-key">#</a> <code>has_key</code></h3>
<p><code>has_key</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = has_key $x
# or in a pipeline:
@list |> map has_key |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-stderr-tty">
<h3><a class="doc-anchor" href="#doc-has-stderr-tty">#</a> <code>has_stderr_tty</code></h3>
<p><code>has_stderr_tty</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = has_stderr_tty $x
# or in a pipeline:
@list |> map has_stderr_tty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-stdin-tty">
<h3><a class="doc-anchor" href="#doc-has-stdin-tty">#</a> <code>has_stdin_tty</code></h3>
<p><code>has_stdin_tty</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = has_stdin_tty $x
# or in a pipeline:
@list |> map has_stdin_tty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-stdout-tty">
<h3><a class="doc-anchor" href="#doc-has-stdout-tty">#</a> <code>has_stdout_tty</code></h3>
<p><code>has_stdout_tty</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = has_stdout_tty $x
# or in a pipeline:
@list |> map has_stdout_tty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hascyc">
<h3><a class="doc-anchor" href="#doc-hascyc">#</a> <code>hascyc</code></h3>
<p><code>hascyc</code> — extended stdlib builtin. Alias for <code>has_cycle_graph</code>.</p>
<pre><code class="lang-perl">my $result = hascyc $x
# or in a pipeline:
@list |> map hascyc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-combine">
<h3><a class="doc-anchor" href="#doc-hash-combine">#</a> <code>hash_combine</code></h3>
<p><code>hash_combine</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = hash_combine $x
# or in a pipeline:
@list |> map hash_combine |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-delete">
<h3><a class="doc-anchor" href="#doc-hash-delete">#</a> <code>hash_delete</code></h3>
<p><code>hash_delete</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hash_delete $x
# or in a pipeline:
@list |> map hash_delete |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-eq">
<h3><a class="doc-anchor" href="#doc-hash-eq">#</a> <code>hash_eq</code></h3>
<p><code>hash_eq</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = hash_eq $x
# or in a pipeline:
@list |> map hash_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-filter-keys">
<h3><a class="doc-anchor" href="#doc-hash-filter-keys">#</a> <code>hash_filter_keys</code></h3>
<p><code>hash_filter_keys</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = hash_filter_keys $x
# or in a pipeline:
@list |> map hash_filter_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-filter-values">
<h3><a class="doc-anchor" href="#doc-hash-filter-values">#</a> <code>hash_filter_values</code></h3>
<p><code>hash_filter_values</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = hash_filter_values $x
# or in a pipeline:
@list |> map hash_filter_values |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-from-list">
<h3><a class="doc-anchor" href="#doc-hash-from-list">#</a> <code>hash_from_list</code></h3>
<p><code>hash_from_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_from_list $x
# or in a pipeline:
@list |> map hash_from_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-from-pairs">
<h3><a class="doc-anchor" href="#doc-hash-from-pairs">#</a> <code>hash_from_pairs</code></h3>
<p><code>hash_from_pairs</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = hash_from_pairs $x
# or in a pipeline:
@list |> map hash_from_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-insert">
<h3><a class="doc-anchor" href="#doc-hash-insert">#</a> <code>hash_insert</code></h3>
<p><code>hash_insert</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hash_insert $x
# or in a pipeline:
@list |> map hash_insert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-map-values">
<h3><a class="doc-anchor" href="#doc-hash-map-values">#</a> <code>hash_map_values</code></h3>
<p><code>hash_map_values</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = hash_map_values $x
# or in a pipeline:
@list |> map hash_map_values |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-merge-deep">
<h3><a class="doc-anchor" href="#doc-hash-merge-deep">#</a> <code>hash_merge_deep</code></h3>
<p><code>hash_merge_deep</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_merge_deep $x
# or in a pipeline:
@list |> map hash_merge_deep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-size">
<h3><a class="doc-anchor" href="#doc-hash-size">#</a> <code>hash_size</code></h3>
<p><code>hash_size</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = hash_size $x
# or in a pipeline:
@list |> map hash_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-to-list">
<h3><a class="doc-anchor" href="#doc-hash-to-list">#</a> <code>hash_to_list</code></h3>
<p><code>hash_to_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_to_list $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-update">
<h3><a class="doc-anchor" href="#doc-hash-update">#</a> <code>hash_update</code></h3>
<p><code>hash_update</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hash_update $x
# or in a pipeline:
@list |> map hash_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-zip">
<h3><a class="doc-anchor" href="#doc-hash-zip">#</a> <code>hash_zip</code></h3>
<p><code>hash_zip</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_zip $x
# or in a pipeline:
@list |> map hash_zip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hausdorff-distance-2d">
<h3><a class="doc-anchor" href="#doc-hausdorff-distance-2d">#</a> <code>hausdorff_distance_2d</code></h3>
<p><code>hausdorff_distance_2d</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = hausdorff_distance_2d $x
# or in a pipeline:
@list |> map hausdorff_distance_2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hausman-test">
<h3><a class="doc-anchor" href="#doc-hausman-test">#</a> <code>hausman_test</code></h3>
<p><code>hausman_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = hausman_test $x
# or in a pipeline:
@list |> map hausman_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-havdist">
<h3><a class="doc-anchor" href="#doc-havdist">#</a> <code>havdist</code></h3>
<p><code>havdist</code> — geometry (extended) builtin. Alias for <code>haversine_distance</code>.</p>
<pre><code class="lang-perl">my $result = havdist $x
# or in a pipeline:
@list |> map havdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-haversine">
<h3><a class="doc-anchor" href="#doc-haversine">#</a> <code>haversine</code></h3>
<p><code>haversine_distance($lat1, $lon1, $lat2, $lon2)</code> (alias <code>haversine</code>) — computes the great-circle distance between two points on Earth given latitude/longitude in degrees. Returns distance in kilometers.</p>
<pre><code class="lang-perl"># NYC to LA
p haversine(40.7128, -74.0060, 34.0522, -118.2437)
# ~3940 km
</code></pre>
</article>
<article class="doc-entry" id="doc-haversine-dist">
<h3><a class="doc-anchor" href="#doc-haversine-dist">#</a> <code>haversine_dist</code></h3>
<p><code>haversine_dist</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = haversine_dist $x
# or in a pipeline:
@list |> map haversine_dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hawk-dove-payoff">
<h3><a class="doc-anchor" href="#doc-hawk-dove-payoff">#</a> <code>hawk_dove_payoff</code></h3>
<p><code>hawk_dove_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = hawk_dove_payoff $x
# or in a pipeline:
@list |> map hawk_dove_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hawking-area-increase">
<h3><a class="doc-anchor" href="#doc-hawking-area-increase">#</a> <code>hawking_area_increase</code></h3>
<p><code>hawking_area_increase</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = hawking_area_increase $x
# or in a pipeline:
@list |> map hawking_area_increase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hclust">
<h3><a class="doc-anchor" href="#doc-hclust">#</a> <code>hclust</code></h3>
<p><code>hclust</code> — hierarchical clustering (average linkage). Takes a distance matrix. Returns merge list [[i,j,height],...]. Like R's hclust().</p>
<pre><code class="lang-perl">my $merges = hclust(dist_mat([[0,0],[1,0],[10,10]]))
</code></pre>
</article>
<article class="doc-entry" id="doc-head-finding-collins">
<h3><a class="doc-anchor" href="#doc-head-finding-collins">#</a> <code>head_finding_collins</code></h3>
<p><code>head_finding_collins</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = head_finding_collins $x
# or in a pipeline:
@list |> map head_finding_collins |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-head-lines">
<h3><a class="doc-anchor" href="#doc-head-lines">#</a> <code>head_lines</code></h3>
<p><code>head_lines</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = head_lines $x
# or in a pipeline:
@list |> map head_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-head-n">
<h3><a class="doc-anchor" href="#doc-head-n">#</a> <code>head_n</code></h3>
<p><code>head_n</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = head_n $x
# or in a pipeline:
@list |> map head_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-head-str">
<h3><a class="doc-anchor" href="#doc-head-str">#</a> <code>head_str</code></h3>
<p><code>head_str</code> — string (batch 2) builtin. Alias for <code>left_str</code>.</p>
<pre><code class="lang-perl">my $result = head_str $x
# or in a pipeline:
@list |> map head_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heap-sift-down">
<h3><a class="doc-anchor" href="#doc-heap-sift-down">#</a> <code>heap_sift_down</code></h3>
<p><code>heap_sift_down</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = heap_sift_down $x
# or in a pipeline:
@list |> map heap_sift_down |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heat-capacity-q">
<h3><a class="doc-anchor" href="#doc-heat-capacity-q">#</a> <code>heat_capacity_q</code></h3>
<p><code>heat_capacity_q</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = heat_capacity_q $x
# or in a pipeline:
@list |> map heat_capacity_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heat-flow-radiogenic">
<h3><a class="doc-anchor" href="#doc-heat-flow-radiogenic">#</a> <code>heat_flow_radiogenic</code></h3>
<p><code>heat_flow_radiogenic</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = heat_flow_radiogenic $x
# or in a pipeline:
@list |> map heat_flow_radiogenic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heat-index">
<h3><a class="doc-anchor" href="#doc-heat-index">#</a> <code>heat_index</code></h3>
<p><code>heat_index</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = heat_index $x
# or in a pipeline:
@list |> map heat_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heat-index-celsius">
<h3><a class="doc-anchor" href="#doc-heat-index-celsius">#</a> <code>heat_index_celsius</code></h3>
<p><code>heat_index_celsius</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = heat_index_celsius $x
# or in a pipeline:
@list |> map heat_index_celsius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hebrew-leap-year">
<h3><a class="doc-anchor" href="#doc-hebrew-leap-year">#</a> <code>hebrew_leap_year</code></h3>
<p><code>hebrew_leap_year</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = hebrew_leap_year $x
# or in a pipeline:
@list |> map hebrew_leap_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hebrew-year-length">
<h3><a class="doc-anchor" href="#doc-hebrew-year-length">#</a> <code>hebrew_year_length</code></h3>
<p><code>hebrew_year_length</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = hebrew_year_length $x
# or in a pipeline:
@list |> map hebrew_year_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heckman-correction">
<h3><a class="doc-anchor" href="#doc-heckman-correction">#</a> <code>heckman_correction</code></h3>
<p><code>heckman_correction</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = heckman_correction $x
# or in a pipeline:
@list |> map heckman_correction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heegaard-genus-lower">
<h3><a class="doc-anchor" href="#doc-heegaard-genus-lower">#</a> <code>heegaard_genus_lower</code></h3>
<p><code>heegaard_genus_lower</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = heegaard_genus_lower $x
# or in a pipeline:
@list |> map heegaard_genus_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heisenberg-min">
<h3><a class="doc-anchor" href="#doc-heisenberg-min">#</a> <code>heisenberg_min</code></h3>
<p><code>heisenberg_min</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = heisenberg_min $x
# or in a pipeline:
@list |> map heisenberg_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hellinger-distance-step">
<h3><a class="doc-anchor" href="#doc-hellinger-distance-step">#</a> <code>hellinger_distance_step</code></h3>
<p><code>hellinger_distance_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = hellinger_distance_step $x
# or in a pipeline:
@list |> map hellinger_distance_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hellinger-kernel">
<h3><a class="doc-anchor" href="#doc-hellinger-kernel">#</a> <code>hellinger_kernel</code></h3>
<p><code>hellinger_kernel</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = hellinger_kernel $x
# or in a pipeline:
@list |> map hellinger_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-helmholtz-capacitance">
<h3><a class="doc-anchor" href="#doc-helmholtz-capacitance">#</a> <code>helmholtz_capacitance</code></h3>
<p><code>helmholtz_capacitance</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = helmholtz_capacitance $x
# or in a pipeline:
@list |> map helmholtz_capacitance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-helmholtz-decomp-step">
<h3><a class="doc-anchor" href="#doc-helmholtz-decomp-step">#</a> <code>helmholtz_decomp_step</code></h3>
<p><code>helmholtz_decomp_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = helmholtz_decomp_step $x
# or in a pipeline:
@list |> map helmholtz_decomp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-henderson-base">
<h3><a class="doc-anchor" href="#doc-henderson-base">#</a> <code>henderson_base</code></h3>
<p><code>henderson_base</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = henderson_base $x
# or in a pipeline:
@list |> map henderson_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-henderson-buffer">
<h3><a class="doc-anchor" href="#doc-henderson-buffer">#</a> <code>henderson_buffer</code></h3>
<p><code>henderson_buffer</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = henderson_buffer $x
# or in a pipeline:
@list |> map henderson_buffer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-henderson-hasselbalch-solve">
<h3><a class="doc-anchor" href="#doc-henderson-hasselbalch-solve">#</a> <code>henderson_hasselbalch_solve</code></h3>
<p><code>henderson_hasselbalch_solve</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = henderson_hasselbalch_solve $x
# or in a pipeline:
@list |> map henderson_hasselbalch_solve |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-henikoff-weight">
<h3><a class="doc-anchor" href="#doc-henikoff-weight">#</a> <code>henikoff_weight</code></h3>
<p><code>henikoff_weight</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = henikoff_weight $x
# or in a pipeline:
@list |> map henikoff_weight |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-herd-immunity-threshold">
<h3><a class="doc-anchor" href="#doc-herd-immunity-threshold">#</a> <code>herd_immunity_threshold</code></h3>
<p><code>herd_immunity_threshold</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = herd_immunity_threshold $x
# or in a pipeline:
@list |> map herd_immunity_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heron">
<h3><a class="doc-anchor" href="#doc-heron">#</a> <code>heron</code></h3>
<p><code>heron</code> — geometry / physics builtin. Alias for <code>heron_area</code>.</p>
<pre><code class="lang-perl">my $result = heron $x
# or in a pipeline:
@list |> map heron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heron-area">
<h3><a class="doc-anchor" href="#doc-heron-area">#</a> <code>heron_area</code></h3>
<p><code>heron_area</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = heron_area $x
# or in a pipeline:
@list |> map heron_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heston-price-simple">
<h3><a class="doc-anchor" href="#doc-heston-price-simple">#</a> <code>heston_price_simple</code></h3>
<p><code>heston_price_simple</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = heston_price_simple $x
# or in a pipeline:
@list |> map heston_price_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heteroskedasticity-test">
<h3><a class="doc-anchor" href="#doc-heteroskedasticity-test">#</a> <code>heteroskedasticity_test</code></h3>
<p><code>heteroskedasticity_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = heteroskedasticity_test $x
# or in a pipeline:
@list |> map heteroskedasticity_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heterozygosity">
<h3><a class="doc-anchor" href="#doc-heterozygosity">#</a> <code>heterozygosity</code></h3>
<p><code>heterozygosity</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = heterozygosity $x
# or in a pipeline:
@list |> map heterozygosity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heun-euler-step">
<h3><a class="doc-anchor" href="#doc-heun-euler-step">#</a> <code>heun_euler_step</code></h3>
<p><code>heun_euler_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = heun_euler_step $x
# or in a pipeline:
@list |> map heun_euler_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heun-method">
<h3><a class="doc-anchor" href="#doc-heun-method">#</a> <code>heun_method</code></h3>
<p><code>heun_method</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = heun_method $x
# or in a pipeline:
@list |> map heun_method |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heun-sde-step">
<h3><a class="doc-anchor" href="#doc-heun-sde-step">#</a> <code>heun_sde_step</code></h3>
<p><code>heun_sde_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = heun_sde_step $x
# or in a pipeline:
@list |> map heun_sde_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-lower">
<h3><a class="doc-anchor" href="#doc-hex-lower">#</a> <code>hex_lower</code></h3>
<p><code>hex_lower</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hex_lower $x
# or in a pipeline:
@list |> map hex_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-of">
<h3><a class="doc-anchor" href="#doc-hex-of">#</a> <code>hex_of</code></h3>
<p><code>hex_of</code> — base conversion builtin. Alias for <code>to_hex</code>.</p>
<pre><code class="lang-perl">my $result = hex_of $x
# or in a pipeline:
@list |> map hex_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-to-bytes">
<h3><a class="doc-anchor" href="#doc-hex-to-bytes">#</a> <code>hex_to_bytes</code></h3>
<p><code>hex_to_bytes</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hex_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-to-rgb">
<h3><a class="doc-anchor" href="#doc-hex-to-rgb">#</a> <code>hex_to_rgb</code></h3>
<p><code>hex_to_rgb</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = hex_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-upper">
<h3><a class="doc-anchor" href="#doc-hex-upper">#</a> <code>hex_upper</code></h3>
<p><code>hex_upper</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hex_upper $x
# or in a pipeline:
@list |> map hex_upper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hget">
<h3><a class="doc-anchor" href="#doc-hget">#</a> <code>hget</code></h3>
<p><code>hget</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = hget $x
# or in a pipeline:
@list |> map hget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hgetall">
<h3><a class="doc-anchor" href="#doc-hgetall">#</a> <code>hgetall</code></h3>
<p><code>hgetall</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = hgetall $x
# or in a pipeline:
@list |> map hgetall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hhi-concentration">
<h3><a class="doc-anchor" href="#doc-hhi-concentration">#</a> <code>hhi_concentration</code></h3>
<p><code>hhi_concentration</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = hhi_concentration $x
# or in a pipeline:
@list |> map hhi_concentration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hicksian-demand">
<h3><a class="doc-anchor" href="#doc-hicksian-demand">#</a> <code>hicksian_demand</code></h3>
<p><code>hicksian_demand</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = hicksian_demand $x
# or in a pipeline:
@list |> map hicksian_demand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hidden">
<h3><a class="doc-anchor" href="#doc-hidden">#</a> <code>hidden</code></h3>
<p><code>hidden</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = hidden $x
# or in a pipeline:
@list |> map hidden |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-highpass-filter">
<h3><a class="doc-anchor" href="#doc-highpass-filter">#</a> <code>highpass_filter</code></h3>
<p><code>highpass_filter(\@signal, $cutoff)</code> (alias <code>hpf</code>) — applies a simple high-pass filter to remove low-frequency components (DC offset, drift). Signal = original - lowpass.</p>
<pre><code class="lang-perl">my @with_dc = map { 5 + sin(_/10) } 1:100
my $ac_only = hpf(\@with_dc, 0.1)
</code></pre>
</article>
<article class="doc-entry" id="doc-highway-hash">
<h3><a class="doc-anchor" href="#doc-highway-hash">#</a> <code>highway_hash</code></h3>
<p><code>highway_hash</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = highway_hash $x
# or in a pipeline:
@list |> map highway_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hilbert-envelope">
<h3><a class="doc-anchor" href="#doc-hilbert-envelope">#</a> <code>hilbert_envelope</code></h3>
<p><code>hilbert_envelope</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = hilbert_envelope $x
# or in a pipeline:
@list |> map hilbert_envelope |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hilbert-signal">
<h3><a class="doc-anchor" href="#doc-hilbert-signal">#</a> <code>hilbert_signal</code></h3>
<p><code>hilbert_signal</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = hilbert_signal $x
# or in a pipeline:
@list |> map hilbert_signal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hill-equation">
<h3><a class="doc-anchor" href="#doc-hill-equation">#</a> <code>hill_equation</code></h3>
<p><code>hill_equation</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = hill_equation $x
# or in a pipeline:
@list |> map hill_equation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hill-radius">
<h3><a class="doc-anchor" href="#doc-hill-radius">#</a> <code>hill_radius</code></h3>
<p><code>hill_radius</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = hill_radius $x
# or in a pipeline:
@list |> map hill_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hill-sphere-radius">
<h3><a class="doc-anchor" href="#doc-hill-sphere-radius">#</a> <code>hill_sphere_radius</code></h3>
<p><code>hill_sphere_radius</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = hill_sphere_radius $x
# or in a pipeline:
@list |> map hill_sphere_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hill-velocity">
<h3><a class="doc-anchor" href="#doc-hill-velocity">#</a> <code>hill_velocity</code></h3>
<p><code>hill_velocity</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = hill_velocity $x
# or in a pipeline:
@list |> map hill_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hincrby">
<h3><a class="doc-anchor" href="#doc-hincrby">#</a> <code>hincrby</code></h3>
<p><code>hincrby</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = hincrby $x
# or in a pipeline:
@list |> map hincrby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hindley-milner-step">
<h3><a class="doc-anchor" href="#doc-hindley-milner-step">#</a> <code>hindley_milner_step</code></h3>
<p><code>hindley_milner_step</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = hindley_milner_step $x
# or in a pipeline:
@list |> map hindley_milner_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hindu-lunisolar-month">
<h3><a class="doc-anchor" href="#doc-hindu-lunisolar-month">#</a> <code>hindu_lunisolar_month</code></h3>
<p><code>hindu_lunisolar_month</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = hindu_lunisolar_month $x
# or in a pipeline:
@list |> map hindu_lunisolar_month |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hindu-solar-year">
<h3><a class="doc-anchor" href="#doc-hindu-solar-year">#</a> <code>hindu_solar_year</code></h3>
<p><code>hindu_solar_year</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = hindu_solar_year $x
# or in a pipeline:
@list |> map hindu_solar_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hinge-loss">
<h3><a class="doc-anchor" href="#doc-hinge-loss">#</a> <code>hinge_loss</code></h3>
<p><code>hinge_loss</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = hinge_loss $x
# or in a pipeline:
@list |> map hinge_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hirschberg-lcs-length">
<h3><a class="doc-anchor" href="#doc-hirschberg-lcs-length">#</a> <code>hirschberg_lcs_length</code></h3>
<p><code>hirschberg_lcs_length</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = hirschberg_lcs_length $x
# or in a pipeline:
@list |> map hirschberg_lcs_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hirzebruch-signature">
<h3><a class="doc-anchor" href="#doc-hirzebruch-signature">#</a> <code>hirzebruch_signature</code></h3>
<p><code>hirzebruch_signature</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = hirzebruch_signature $x
# or in a pipeline:
@list |> map hirzebruch_signature |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hist">
<h3><a class="doc-anchor" href="#doc-hist">#</a> <code>hist</code></h3>
<p><code>hist</code> — matrix operations (uncategorized batch) builtin. Alias for <code>histogram</code>.</p>
<pre><code class="lang-perl">my $result = hist $x
# or in a pipeline:
@list |> map hist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-histogram">
<h3><a class="doc-anchor" href="#doc-histogram">#</a> <code>histogram</code></h3>
<p><code>histogram</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = histogram $x
# or in a pipeline:
@list |> map histogram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-histogram-bin-edges">
<h3><a class="doc-anchor" href="#doc-histogram-bin-edges">#</a> <code>histogram_bin_edges</code></h3>
<p><code>histogram_bin_edges</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = histogram_bin_edges $x
# or in a pipeline:
@list |> map histogram_bin_edges |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-histogram-bins">
<h3><a class="doc-anchor" href="#doc-histogram-bins">#</a> <code>histogram_bins</code></h3>
<p><code>histogram_bins</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = histogram_bins $x
# or in a pipeline:
@list |> map histogram_bins |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hits-authority">
<h3><a class="doc-anchor" href="#doc-hits-authority">#</a> <code>hits_authority</code></h3>
<p><code>hits_authority</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = hits_authority $x
# or in a pipeline:
@list |> map hits_authority |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hits-hub">
<h3><a class="doc-anchor" href="#doc-hits-hub">#</a> <code>hits_hub</code></h3>
<p><code>hits_hub</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = hits_hub $x
# or in a pipeline:
@list |> map hits_hub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hits-simple">
<h3><a class="doc-anchor" href="#doc-hits-simple">#</a> <code>hits_simple</code></h3>
<p><code>hits_simple</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = hits_simple $x
# or in a pipeline:
@list |> map hits_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hitting-set-greedy">
<h3><a class="doc-anchor" href="#doc-hitting-set-greedy">#</a> <code>hitting_set_greedy</code></h3>
<p><code>hitting_set_greedy</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = hitting_set_greedy $x
# or in a pipeline:
@list |> map hitting_set_greedy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hk">
<h3><a class="doc-anchor" href="#doc-hk">#</a> <code>hk</code></h3>
<p><code>hk</code> — hash helpers builtin. Alias for <code>has_key</code>.</p>
<pre><code class="lang-perl">my $result = hk $x
# or in a pipeline:
@list |> map hk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hkdf-expand-step">
<h3><a class="doc-anchor" href="#doc-hkdf-expand-step">#</a> <code>hkdf_expand_step</code></h3>
<p><code>hkdf_expand_step</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = hkdf_expand_step $x
# or in a pipeline:
@list |> map hkdf_expand_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hkeys">
<h3><a class="doc-anchor" href="#doc-hkeys">#</a> <code>hkeys</code></h3>
<p><code>hkeys</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = hkeys $x
# or in a pipeline:
@list |> map hkeys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hlen">
<h3><a class="doc-anchor" href="#doc-hlen">#</a> <code>hlen</code></h3>
<p><code>hlen</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = hlen $x
# or in a pipeline:
@list |> map hlen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hlookup">
<h3><a class="doc-anchor" href="#doc-hlookup">#</a> <code>hlookup</code></h3>
<p><code>hlookup</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = hlookup $x
# or in a pipeline:
@list |> map hlookup |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-step-xor">
<h3><a class="doc-anchor" href="#doc-hmac-step-xor">#</a> <code>hmac_step_xor</code></h3>
<p><code>hmac_step_xor</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = hmac_step_xor $x
# or in a pipeline:
@list |> map hmac_step_xor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hmset">
<h3><a class="doc-anchor" href="#doc-hmset">#</a> <code>hmset</code></h3>
<p><code>hmset</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = hmset $x
# or in a pipeline:
@list |> map hmset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hochschild-zero">
<h3><a class="doc-anchor" href="#doc-hochschild-zero">#</a> <code>hochschild_zero</code></h3>
<p><code>hochschild_zero</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = hochschild_zero $x
# or in a pipeline:
@list |> map hochschild_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hodge-diamond-value">
<h3><a class="doc-anchor" href="#doc-hodge-diamond-value">#</a> <code>hodge_diamond_value</code></h3>
<p><code>hodge_diamond_value</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = hodge_diamond_value $x
# or in a pipeline:
@list |> map hodge_diamond_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hodge-inner-product-one">
<h3><a class="doc-anchor" href="#doc-hodge-inner-product-one">#</a> <code>hodge_inner_product_one</code></h3>
<p><code>hodge_inner_product_one</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = hodge_inner_product_one $x
# or in a pipeline:
@list |> map hodge_inner_product_one |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hodge-polynomial-eval">
<h3><a class="doc-anchor" href="#doc-hodge-polynomial-eval">#</a> <code>hodge_polynomial_eval</code></h3>
<p><code>hodge_polynomial_eval</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = hodge_polynomial_eval $x
# or in a pipeline:
@list |> map hodge_polynomial_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hodge-star-one-form">
<h3><a class="doc-anchor" href="#doc-hodge-star-one-form">#</a> <code>hodge_star_one_form</code></h3>
<p><code>hodge_star_one_form</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = hodge_star_one_form $x
# or in a pipeline:
@list |> map hodge_star_one_form |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hodges-lehmann">
<h3><a class="doc-anchor" href="#doc-hodges-lehmann">#</a> <code>hodges_lehmann</code></h3>
<p><code>hodges_lehmann</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = hodges_lehmann $x
# or in a pipeline:
@list |> map hodges_lehmann |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hog-features">
<h3><a class="doc-anchor" href="#doc-hog-features">#</a> <code>hog_features</code></h3>
<p><code>hog_features</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = hog_features $x
# or in a pipeline:
@list |> map hog_features |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hohmann-dv1">
<h3><a class="doc-anchor" href="#doc-hohmann-dv1">#</a> <code>hohmann_dv1</code></h3>
<p><code>hohmann_dv1</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = hohmann_dv1 $x
# or in a pipeline:
@list |> map hohmann_dv1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hohmann-dv2">
<h3><a class="doc-anchor" href="#doc-hohmann-dv2">#</a> <code>hohmann_dv2</code></h3>
<p><code>hohmann_dv2</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = hohmann_dv2 $x
# or in a pipeline:
@list |> map hohmann_dv2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hohmann-total">
<h3><a class="doc-anchor" href="#doc-hohmann-total">#</a> <code>hohmann_total</code></h3>
<p><code>hohmann_total</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = hohmann_total $x
# or in a pipeline:
@list |> map hohmann_total |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-holling-type1">
<h3><a class="doc-anchor" href="#doc-holling-type1">#</a> <code>holling_type1</code></h3>
<p><code>holling_type1</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = holling_type1 $x
# or in a pipeline:
@list |> map holling_type1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-holling-type2">
<h3><a class="doc-anchor" href="#doc-holling-type2">#</a> <code>holling_type2</code></h3>
<p><code>holling_type2</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = holling_type2 $x
# or in a pipeline:
@list |> map holling_type2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-holling-type3">
<h3><a class="doc-anchor" href="#doc-holling-type3">#</a> <code>holling_type3</code></h3>
<p><code>holling_type3</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = holling_type3 $x
# or in a pipeline:
@list |> map holling_type3 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-holographic-entanglement-step">
<h3><a class="doc-anchor" href="#doc-holographic-entanglement-step">#</a> <code>holographic_entanglement_step</code></h3>
<p><code>holographic_entanglement_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = holographic_entanglement_step $x
# or in a pipeline:
@list |> map holographic_entanglement_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-holt-winters-additive">
<h3><a class="doc-anchor" href="#doc-holt-winters-additive">#</a> <code>holt_winters_additive</code></h3>
<p><code>holt_winters_additive</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = holt_winters_additive $x
# or in a pipeline:
@list |> map holt_winters_additive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-holt-winters-multiplicative">
<h3><a class="doc-anchor" href="#doc-holt-winters-multiplicative">#</a> <code>holt_winters_multiplicative</code></h3>
<p><code>holt_winters_multiplicative</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = holt_winters_multiplicative $x
# or in a pipeline:
@list |> map holt_winters_multiplicative |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-home-dir">
<h3><a class="doc-anchor" href="#doc-home-dir">#</a> <code>home_dir</code></h3>
<p><code>home_dir</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = home_dir $x
# or in a pipeline:
@list |> map home_dir |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-homfly-evaluation">
<h3><a class="doc-anchor" href="#doc-homfly-evaluation">#</a> <code>homfly_evaluation</code></h3>
<p><code>homfly_evaluation</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = homfly_evaluation $x
# or in a pipeline:
@list |> map homfly_evaluation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-homology-rank">
<h3><a class="doc-anchor" href="#doc-homology-rank">#</a> <code>homology_rank</code></h3>
<p><code>homology_rank</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = homology_rank $x
# or in a pipeline:
@list |> map homology_rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-homotopy-group-sphere-pi">
<h3><a class="doc-anchor" href="#doc-homotopy-group-sphere-pi">#</a> <code>homotopy_group_sphere_pi</code></h3>
<p><code>homotopy_group_sphere_pi</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = homotopy_group_sphere_pi $x
# or in a pipeline:
@list |> map homotopy_group_sphere_pi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hooke">
<h3><a class="doc-anchor" href="#doc-hooke">#</a> <code>hooke</code></h3>
<p><code>hooke</code> — physics formulas builtin. Alias for <code>spring_force</code>.</p>
<pre><code class="lang-perl">my $result = hooke $x
# or in a pipeline:
@list |> map hooke |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hopcroft-karp">
<h3><a class="doc-anchor" href="#doc-hopcroft-karp">#</a> <code>hopcroft_karp</code></h3>
<p><code>hopcroft_karp</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = hopcroft_karp $x
# or in a pipeline:
@list |> map hopcroft_karp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hopcroft-karp-phase">
<h3><a class="doc-anchor" href="#doc-hopcroft-karp-phase">#</a> <code>hopcroft_karp_phase</code></h3>
<p><code>hopcroft_karp_phase</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = hopcroft_karp_phase $x
# or in a pipeline:
@list |> map hopcroft_karp_phase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hopcroft-karp-step">
<h3><a class="doc-anchor" href="#doc-hopcroft-karp-step">#</a> <code>hopcroft_karp_step</code></h3>
<p><code>hopcroft_karp_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = hopcroft_karp_step $x
# or in a pipeline:
@list |> map hopcroft_karp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-horizon-distance">
<h3><a class="doc-anchor" href="#doc-horizon-distance">#</a> <code>horizon_distance</code></h3>
<p><code>horizon_distance</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = horizon_distance $x
# or in a pipeline:
@list |> map horizon_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-horn-schunck-step">
<h3><a class="doc-anchor" href="#doc-horn-schunck-step">#</a> <code>horn_schunck_step</code></h3>
<p><code>horn_schunck_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = horn_schunck_step $x
# or in a pipeline:
@list |> map horn_schunck_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-horndeski-step">
<h3><a class="doc-anchor" href="#doc-horndeski-step">#</a> <code>horndeski_step</code></h3>
<p><code>horndeski_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = horndeski_step $x
# or in a pipeline:
@list |> map horndeski_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-horspool-search">
<h3><a class="doc-anchor" href="#doc-horspool-search">#</a> <code>horspool_search</code></h3>
<p><code>horspool_search</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = horspool_search $x
# or in a pipeline:
@list |> map horspool_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hostname-str">
<h3><a class="doc-anchor" href="#doc-hostname-str">#</a> <code>hostname_str</code></h3>
<p><code>hostname_str</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = hostname_str $x
# or in a pipeline:
@list |> map hostname_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hotelling-location-step">
<h3><a class="doc-anchor" href="#doc-hotelling-location-step">#</a> <code>hotelling_location_step</code></h3>
<p><code>hotelling_location_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = hotelling_location_step $x
# or in a pipeline:
@list |> map hotelling_location_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hotelling-price-step">
<h3><a class="doc-anchor" href="#doc-hotelling-price-step">#</a> <code>hotelling_price_step</code></h3>
<p><code>hotelling_price_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = hotelling_price_step $x
# or in a pipeline:
@list |> map hotelling_price_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hough-accumulator-step">
<h3><a class="doc-anchor" href="#doc-hough-accumulator-step">#</a> <code>hough_accumulator_step</code></h3>
<p><code>hough_accumulator_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = hough_accumulator_step $x
# or in a pipeline:
@list |> map hough_accumulator_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hough-circles">
<h3><a class="doc-anchor" href="#doc-hough-circles">#</a> <code>hough_circles</code></h3>
<p><code>hough_circles</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = hough_circles $x
# or in a pipeline:
@list |> map hough_circles |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hough-lines">
<h3><a class="doc-anchor" href="#doc-hough-lines">#</a> <code>hough_lines</code></h3>
<p><code>hough_lines</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = hough_lines $x
# or in a pipeline:
@list |> map hough_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hours-to-days">
<h3><a class="doc-anchor" href="#doc-hours-to-days">#</a> <code>hours_to_days</code></h3>
<p><code>hours_to_days</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = hours_to_days $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hours-to-minutes">
<h3><a class="doc-anchor" href="#doc-hours-to-minutes">#</a> <code>hours_to_minutes</code></h3>
<p><code>hours_to_minutes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = hours_to_minutes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hours-to-seconds">
<h3><a class="doc-anchor" href="#doc-hours-to-seconds">#</a> <code>hours_to_seconds</code></h3>
<p><code>hours_to_seconds</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = hours_to_seconds $input
</code></pre>
</article>
<article class="doc-entry" id="doc-householder-root">
<h3><a class="doc-anchor" href="#doc-householder-root">#</a> <code>householder_root</code></h3>
<p><code>householder_root</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = householder_root $x
# or in a pipeline:
@list |> map householder_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hp-to-watts">
<h3><a class="doc-anchor" href="#doc-hp-to-watts">#</a> <code>hp_to_watts</code></h3>
<p><code>hp_to_watts</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hp_to_watts $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hr">
<h3><a class="doc-anchor" href="#doc-hr">#</a> <code>hr</code></h3>
<p><code>hr</code> — data / network builtin. Alias for <code>http_request</code>.</p>
<pre><code class="lang-perl">my $result = hr $x
# or in a pipeline:
@list |> map hr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hset">
<h3><a class="doc-anchor" href="#doc-hset">#</a> <code>hset</code></h3>
<p><code>hset</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = hset $x
# or in a pipeline:
@list |> map hset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hsl2rgb">
<h3><a class="doc-anchor" href="#doc-hsl2rgb">#</a> <code>hsl2rgb</code></h3>
<p><code>hsl2rgb</code> — color operations builtin. Alias for <code>hsl_to_rgb</code>.</p>
<pre><code class="lang-perl">my $result = hsl2rgb $x
# or in a pipeline:
@list |> map hsl2rgb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hsl-to-rgb">
<h3><a class="doc-anchor" href="#doc-hsl-to-rgb">#</a> <code>hsl_to_rgb</code></h3>
<p><code>hsl_to_rgb</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = hsl_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hstore-to-array">
<h3><a class="doc-anchor" href="#doc-hstore-to-array">#</a> <code>hstore_to_array</code></h3>
<p><code>hstore_to_array</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = hstore_to_array $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hsv2rgb">
<h3><a class="doc-anchor" href="#doc-hsv2rgb">#</a> <code>hsv2rgb</code></h3>
<p><code>hsv2rgb</code> — color operations builtin. Alias for <code>hsv_to_rgb</code>.</p>
<pre><code class="lang-perl">my $result = hsv2rgb $x
# or in a pipeline:
@list |> map hsv2rgb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hsv-to-rgb">
<h3><a class="doc-anchor" href="#doc-hsv-to-rgb">#</a> <code>hsv_to_rgb</code></h3>
<p><code>hsv_to_rgb</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = hsv_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-html-decode">
<h3><a class="doc-anchor" href="#doc-html-decode">#</a> <code>html_decode</code></h3>
<p><code>html_decode</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = html_decode $x
# or in a pipeline:
@list |> map html_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-html-encode">
<h3><a class="doc-anchor" href="#doc-html-encode">#</a> <code>html_encode</code></h3>
<p><code>html_encode</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = html_encode $x
# or in a pipeline:
@list |> map html_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-htmld">
<h3><a class="doc-anchor" href="#doc-htmld">#</a> <code>htmld</code></h3>
<p><code>htmld</code> — extended stdlib builtin. Alias for <code>html_decode</code>.</p>
<pre><code class="lang-perl">my $result = htmld $x
# or in a pipeline:
@list |> map htmld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-htmle">
<h3><a class="doc-anchor" href="#doc-htmle">#</a> <code>htmle</code></h3>
<p><code>htmle</code> — extended stdlib builtin. Alias for <code>html_encode</code>.</p>
<pre><code class="lang-perl">my $result = htmle $x
# or in a pipeline:
@list |> map htmle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hubble-constant">
<h3><a class="doc-anchor" href="#doc-hubble-constant">#</a> <code>hubble_constant</code></h3>
<p><code>hubble_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = hubble_constant $x
# or in a pipeline:
@list |> map hubble_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hubble-distance-mpc">
<h3><a class="doc-anchor" href="#doc-hubble-distance-mpc">#</a> <code>hubble_distance_mpc</code></h3>
<p><code>hubble_distance_mpc</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = hubble_distance_mpc $x
# or in a pipeline:
@list |> map hubble_distance_mpc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hubble-distance-si">
<h3><a class="doc-anchor" href="#doc-hubble-distance-si">#</a> <code>hubble_distance_si</code></h3>
<p><code>hubble_distance_si</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = hubble_distance_si $x
# or in a pipeline:
@list |> map hubble_distance_si |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hubble-lcdm">
<h3><a class="doc-anchor" href="#doc-hubble-lcdm">#</a> <code>hubble_lcdm</code></h3>
<p><code>hubble_lcdm</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = hubble_lcdm $x
# or in a pipeline:
@list |> map hubble_lcdm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hubble-time">
<h3><a class="doc-anchor" href="#doc-hubble-time">#</a> <code>hubble_time</code></h3>
<p><code>hubble_time</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = hubble_time $x
# or in a pipeline:
@list |> map hubble_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-huber-m-estimator">
<h3><a class="doc-anchor" href="#doc-huber-m-estimator">#</a> <code>huber_m_estimator</code></h3>
<p><code>huber_m_estimator</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = huber_m_estimator $x
# or in a pipeline:
@list |> map huber_m_estimator |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-huffman-balanced-step">
<h3><a class="doc-anchor" href="#doc-huffman-balanced-step">#</a> <code>huffman_balanced_step</code></h3>
<p><code>huffman_balanced_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = huffman_balanced_step $x
# or in a pipeline:
@list |> map huffman_balanced_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hull-white-drift">
<h3><a class="doc-anchor" href="#doc-hull-white-drift">#</a> <code>hull_white_drift</code></h3>
<p><code>hull_white_drift</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = hull_white_drift $x
# or in a pipeline:
@list |> map hull_white_drift |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-human-bytes">
<h3><a class="doc-anchor" href="#doc-human-bytes">#</a> <code>human_bytes</code></h3>
<p><code>human_bytes</code> — file stat / path builtin. Alias for <code>format_bytes</code>.</p>
<pre><code class="lang-perl">my $result = human_bytes $x
# or in a pipeline:
@list |> map human_bytes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-human-duration">
<h3><a class="doc-anchor" href="#doc-human-duration">#</a> <code>human_duration</code></h3>
<p><code>human_duration</code> — file stat / path builtin. Alias for <code>format_duration</code>.</p>
<pre><code class="lang-perl">my $result = human_duration $x
# or in a pipeline:
@list |> map human_duration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-humidex">
<h3><a class="doc-anchor" href="#doc-humidex">#</a> <code>humidex</code></h3>
<p><code>humidex</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = humidex $x
# or in a pipeline:
@list |> map humidex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hungarian-method-step">
<h3><a class="doc-anchor" href="#doc-hungarian-method-step">#</a> <code>hungarian_method_step</code></h3>
<p><code>hungarian_method_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = hungarian_method_step $x
# or in a pipeline:
@list |> map hungarian_method_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hungarian-step">
<h3><a class="doc-anchor" href="#doc-hungarian-step">#</a> <code>hungarian_step</code></h3>
<p><code>hungarian_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = hungarian_step $x
# or in a pipeline:
@list |> map hungarian_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hurst-exponent-estimate">
<h3><a class="doc-anchor" href="#doc-hurst-exponent-estimate">#</a> <code>hurst_exponent_estimate</code></h3>
<p><code>hurst_exponent_estimate</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = hurst_exponent_estimate $x
# or in a pipeline:
@list |> map hurst_exponent_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hvals">
<h3><a class="doc-anchor" href="#doc-hvals">#</a> <code>hvals</code></h3>
<p><code>hvals</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = hvals $x
# or in a pipeline:
@list |> map hvals |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hw-expected-counts">
<h3><a class="doc-anchor" href="#doc-hw-expected-counts">#</a> <code>hw_expected_counts</code></h3>
<p><code>hw_expected_counts</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = hw_expected_counts $x
# or in a pipeline:
@list |> map hw_expected_counts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hxd">
<h3><a class="doc-anchor" href="#doc-hxd">#</a> <code>hxd</code></h3>
<p><code>hxd</code> — crypto / encoding builtin. Alias for <code>hex_decode</code>.</p>
<pre><code class="lang-perl">my $result = hxd $x
# or in a pipeline:
@list |> map hxd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hxe">
<h3><a class="doc-anchor" href="#doc-hxe">#</a> <code>hxe</code></h3>
<p><code>hxe</code> — crypto / encoding builtin. Alias for <code>hex_encode</code>.</p>
<pre><code class="lang-perl">my $result = hxe $x
# or in a pipeline:
@list |> map hxe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hydrogen-energy-n">
<h3><a class="doc-anchor" href="#doc-hydrogen-energy-n">#</a> <code>hydrogen_energy_n</code></h3>
<p><code>hydrogen_energy_n</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = hydrogen_energy_n $x
# or in a pipeline:
@list |> map hydrogen_energy_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hyp">
<h3><a class="doc-anchor" href="#doc-hyp">#</a> <code>hyp</code></h3>
<p><code>hyp</code> — geometry / physics builtin. Alias for <code>triangle_hypotenuse</code>.</p>
<pre><code class="lang-perl">my $result = hyp $x
# or in a pipeline:
@list |> map hyp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hyp1f1">
<h3><a class="doc-anchor" href="#doc-hyp1f1">#</a> <code>hyp1f1</code></h3>
<p><code>hyp1f1</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = hyp1f1 $x
# or in a pipeline:
@list |> map hyp1f1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hyp2f1">
<h3><a class="doc-anchor" href="#doc-hyp2f1">#</a> <code>hyp2f1</code></h3>
<p><code>hyp2f1</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = hyp2f1 $x
# or in a pipeline:
@list |> map hyp2f1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hyper0f1">
<h3><a class="doc-anchor" href="#doc-hyper0f1">#</a> <code>hyper0f1</code></h3>
<p><code>hyper0f1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = hyper0f1 $x
# or in a pipeline:
@list |> map hyper0f1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hyper1f1">
<h3><a class="doc-anchor" href="#doc-hyper1f1">#</a> <code>hyper1f1</code></h3>
<p><code>hyper1f1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = hyper1f1 $x
# or in a pipeline:
@list |> map hyper1f1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hyper2f1">
<h3><a class="doc-anchor" href="#doc-hyper2f1">#</a> <code>hyper2f1</code></h3>
<p><code>hyper2f1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = hyper2f1 $x
# or in a pipeline:
@list |> map hyper2f1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hypot">
<h3><a class="doc-anchor" href="#doc-hypot">#</a> <code>hypot</code></h3>
<p><code>hypot</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = hypot $x
# or in a pipeline:
@list |> map hypot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hz-to-midi">
<h3><a class="doc-anchor" href="#doc-hz-to-midi">#</a> <code>hz_to_midi</code></h3>
<p><code>hz_to_midi</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = hz_to_midi $input
</code></pre>
</article>
<article class="doc-entry" id="doc-i64-max">
<h3><a class="doc-anchor" href="#doc-i64-max">#</a> <code>i64_max</code></h3>
<p><code>i64_max</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = i64_max $x
# or in a pipeline:
@list |> map i64_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-i64-min">
<h3><a class="doc-anchor" href="#doc-i64-min">#</a> <code>i64_min</code></h3>
<p><code>i64_min</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = i64_min $x
# or in a pipeline:
@list |> map i64_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iban-check">
<h3><a class="doc-anchor" href="#doc-iban-check">#</a> <code>iban_check</code></h3>
<p><code>iban_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = iban_check $x
# or in a pipeline:
@list |> map iban_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ibnr-estimate">
<h3><a class="doc-anchor" href="#doc-ibnr-estimate">#</a> <code>ibnr_estimate</code></h3>
<p><code>ibnr_estimate</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = ibnr_estimate $x
# or in a pipeline:
@list |> map ibnr_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ical">
<h3><a class="doc-anchor" href="#doc-ical">#</a> <code>ical</code></h3>
<p><code>ical</code> — haskell list functions builtin. Alias for <code>intercalate</code>.</p>
<pre><code class="lang-perl">my $result = ical $x
# or in a pipeline:
@list |> map ical |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ice-age-milankovitch">
<h3><a class="doc-anchor" href="#doc-ice-age-milankovitch">#</a> <code>ice_age_milankovitch</code></h3>
<p><code>ice_age_milankovitch</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = ice_age_milankovitch $x
# or in a pipeline:
@list |> map ice_age_milankovitch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-icosahedral-number">
<h3><a class="doc-anchor" href="#doc-icosahedral-number">#</a> <code>icosahedral_number</code></h3>
<p><code>icosahedral_number</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = icosahedral_number $x
# or in a pipeline:
@list |> map icosahedral_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-id">
<h3><a class="doc-anchor" href="#doc-id">#</a> <code>id</code></h3>
<p><code>id</code> — trivial numeric / predicate builtins builtin. Alias for <code>identity</code>.</p>
<pre><code class="lang-perl">my $result = id $x
# or in a pipeline:
@list |> map id |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ida-star">
<h3><a class="doc-anchor" href="#doc-ida-star">#</a> <code>ida_star</code></h3>
<p><code>ida_star</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = ida_star $x
# or in a pipeline:
@list |> map ida_star |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-idamax">
<h3><a class="doc-anchor" href="#doc-idamax">#</a> <code>idamax</code></h3>
<p><code>idamax</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = idamax $x
# or in a pipeline:
@list |> map idamax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-idct">
<h3><a class="doc-anchor" href="#doc-idct">#</a> <code>idct</code></h3>
<p><code>idct</code> computes the inverse DCT (Type-III). Reconstructs a signal from DCT coefficients.</p>
<pre><code class="lang-perl">my @signal = @{idct(dct([1,2,3,4]))}
</code></pre>
</article>
<article class="doc-entry" id="doc-ideal-gas">
<h3><a class="doc-anchor" href="#doc-ideal-gas">#</a> <code>ideal_gas</code></h3>
<p><code>ideal_gas</code> (alias <code>pv_nrt</code>) solves PV=nRT for the unknown (pass 0 for the value to solve). Args: P, V, n, T.</p>
<pre><code class="lang-perl">p pv_nrt(0, 0.0224, 1, 273.15) # pressure at STP
p pv_nrt(101325, 0, 1, 273.15) # volume at STP
</code></pre>
</article>
<article class="doc-entry" id="doc-ideal-gas-n">
<h3><a class="doc-anchor" href="#doc-ideal-gas-n">#</a> <code>ideal_gas_n</code></h3>
<p><code>ideal_gas_n</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = ideal_gas_n $x
# or in a pipeline:
@list |> map ideal_gas_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ideal-gas-volume">
<h3><a class="doc-anchor" href="#doc-ideal-gas-volume">#</a> <code>ideal_gas_volume</code></h3>
<p><code>ideal_gas_volume</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = ideal_gas_volume $x
# or in a pipeline:
@list |> map ideal_gas_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-identity">
<h3><a class="doc-anchor" href="#doc-identity">#</a> <code>identity</code></h3>
<p><code>identity</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = identity $x
# or in a pipeline:
@list |> map identity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-identity-matrix">
<h3><a class="doc-anchor" href="#doc-identity-matrix">#</a> <code>identity_matrix</code></h3>
<p><code>identity_matrix</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = identity_matrix $x
# or in a pipeline:
@list |> map identity_matrix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-identity-permutation">
<h3><a class="doc-anchor" href="#doc-identity-permutation">#</a> <code>identity_permutation</code></h3>
<p><code>identity_permutation</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = identity_permutation $x
# or in a pipeline:
@list |> map identity_permutation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-idft">
<h3><a class="doc-anchor" href="#doc-idft">#</a> <code>idft</code></h3>
<p><code>idft(\@spectrum)</code> — computes the Inverse Discrete Fourier Transform. Takes arrayref of [re, im] pairs and returns the time-domain signal.</p>
<pre><code class="lang-perl">my $spectrum = dft(\@signal)
my $reconstructed = idft($spectrum)
</code></pre>
</article>
<article class="doc-entry" id="doc-idn-normalize">
<h3><a class="doc-anchor" href="#doc-idn-normalize">#</a> <code>idn_normalize</code></h3>
<p><code>idn_normalize</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = idn_normalize $x
# or in a pipeline:
@list |> map idn_normalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-idn-to-ascii">
<h3><a class="doc-anchor" href="#doc-idn-to-ascii">#</a> <code>idn_to_ascii</code></h3>
<p><code>idn_to_ascii</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = idn_to_ascii $input
</code></pre>
</article>
<article class="doc-entry" id="doc-idn-to-unicode">
<h3><a class="doc-anchor" href="#doc-idn-to-unicode">#</a> <code>idn_to_unicode</code></h3>
<p><code>idn_to_unicode</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = idn_to_unicode $input
</code></pre>
</article>
<article class="doc-entry" id="doc-idt">
<h3><a class="doc-anchor" href="#doc-idt">#</a> <code>idt</code></h3>
<p><code>idt</code> — extended stdlib builtin. Alias for <code>indent</code>.</p>
<pre><code class="lang-perl">my $result = idt $x
# or in a pipeline:
@list |> map idt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-idxb">
<h3><a class="doc-anchor" href="#doc-idxb">#</a> <code>idxb</code></h3>
<p><code>idxb</code> — go/general functional utilities builtin. Alias for <code>index_by</code>.</p>
<pre><code class="lang-perl">my $result = idxb $x
# or in a pipeline:
@list |> map idxb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-if-else">
<h3><a class="doc-anchor" href="#doc-if-else">#</a> <code>if_else</code></h3>
<p><code>if_else</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = if_else $x
# or in a pipeline:
@list |> map if_else |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-if-match-check">
<h3><a class="doc-anchor" href="#doc-if-match-check">#</a> <code>if_match_check</code></h3>
<p><code>if_match_check</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = if_match_check $x
# or in a pipeline:
@list |> map if_match_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-if-none-match-check">
<h3><a class="doc-anchor" href="#doc-if-none-match-check">#</a> <code>if_none_match_check</code></h3>
<p><code>if_none_match_check</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = if_none_match_check $x
# or in a pipeline:
@list |> map if_none_match_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ifr-infection-fatality">
<h3><a class="doc-anchor" href="#doc-ifr-infection-fatality">#</a> <code>ifr_infection_fatality</code></h3>
<p><code>ifr_infection_fatality</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = ifr_infection_fatality $x
# or in a pipeline:
@list |> map ifr_infection_fatality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-igneous-qapf">
<h3><a class="doc-anchor" href="#doc-igneous-qapf">#</a> <code>igneous_qapf</code></h3>
<p><code>igneous_qapf</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = igneous_qapf $x
# or in a pipeline:
@list |> map igneous_qapf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ilerp">
<h3><a class="doc-anchor" href="#doc-ilerp">#</a> <code>ilerp</code></h3>
<p><code>ilerp</code> — extended stdlib builtin. Alias for <code>inv_lerp</code>.</p>
<pre><code class="lang-perl">my $result = ilerp $x
# or in a pipeline:
@list |> map ilerp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-blur-box">
<h3><a class="doc-anchor" href="#doc-image-blur-box">#</a> <code>image_blur_box</code></h3>
<p><code>image_blur_box</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_blur_box $x
# or in a pipeline:
@list |> map image_blur_box |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-blur-gaussian">
<h3><a class="doc-anchor" href="#doc-image-blur-gaussian">#</a> <code>image_blur_gaussian</code></h3>
<p><code>image_blur_gaussian</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_blur_gaussian $x
# or in a pipeline:
@list |> map image_blur_gaussian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-brightness">
<h3><a class="doc-anchor" href="#doc-image-brightness">#</a> <code>image_brightness</code></h3>
<p><code>image_brightness</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_brightness $x
# or in a pipeline:
@list |> map image_brightness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-clahe">
<h3><a class="doc-anchor" href="#doc-image-clahe">#</a> <code>image_clahe</code></h3>
<p><code>image_clahe</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_clahe $x
# or in a pipeline:
@list |> map image_clahe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-contrast">
<h3><a class="doc-anchor" href="#doc-image-contrast">#</a> <code>image_contrast</code></h3>
<p><code>image_contrast</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_contrast $x
# or in a pipeline:
@list |> map image_contrast |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-dilate">
<h3><a class="doc-anchor" href="#doc-image-dilate">#</a> <code>image_dilate</code></h3>
<p><code>image_dilate</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_dilate $x
# or in a pipeline:
@list |> map image_dilate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-edge-canny">
<h3><a class="doc-anchor" href="#doc-image-edge-canny">#</a> <code>image_edge_canny</code></h3>
<p><code>image_edge_canny</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_edge_canny $x
# or in a pipeline:
@list |> map image_edge_canny |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-edge-laplacian">
<h3><a class="doc-anchor" href="#doc-image-edge-laplacian">#</a> <code>image_edge_laplacian</code></h3>
<p><code>image_edge_laplacian</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_edge_laplacian $x
# or in a pipeline:
@list |> map image_edge_laplacian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-edge-sobel">
<h3><a class="doc-anchor" href="#doc-image-edge-sobel">#</a> <code>image_edge_sobel</code></h3>
<p><code>image_edge_sobel</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_edge_sobel $x
# or in a pipeline:
@list |> map image_edge_sobel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-emboss">
<h3><a class="doc-anchor" href="#doc-image-emboss">#</a> <code>image_emboss</code></h3>
<p><code>image_emboss</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_emboss $x
# or in a pipeline:
@list |> map image_emboss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-equalize">
<h3><a class="doc-anchor" href="#doc-image-equalize">#</a> <code>image_equalize</code></h3>
<p><code>image_equalize</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_equalize $x
# or in a pipeline:
@list |> map image_equalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-erode">
<h3><a class="doc-anchor" href="#doc-image-erode">#</a> <code>image_erode</code></h3>
<p><code>image_erode</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_erode $x
# or in a pipeline:
@list |> map image_erode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-flip-h">
<h3><a class="doc-anchor" href="#doc-image-flip-h">#</a> <code>image_flip_h</code></h3>
<p><code>image_flip_h</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_flip_h $x
# or in a pipeline:
@list |> map image_flip_h |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-flip-v">
<h3><a class="doc-anchor" href="#doc-image-flip-v">#</a> <code>image_flip_v</code></h3>
<p><code>image_flip_v</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_flip_v $x
# or in a pipeline:
@list |> map image_flip_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-gamma">
<h3><a class="doc-anchor" href="#doc-image-gamma">#</a> <code>image_gamma</code></h3>
<p><code>image_gamma</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_gamma $x
# or in a pipeline:
@list |> map image_gamma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-grayscale">
<h3><a class="doc-anchor" href="#doc-image-grayscale">#</a> <code>image_grayscale</code></h3>
<p><code>image_grayscale</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_grayscale $x
# or in a pipeline:
@list |> map image_grayscale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-histogram">
<h3><a class="doc-anchor" href="#doc-image-histogram">#</a> <code>image_histogram</code></h3>
<p><code>image_histogram</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_histogram $x
# or in a pipeline:
@list |> map image_histogram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-invert">
<h3><a class="doc-anchor" href="#doc-image-invert">#</a> <code>image_invert</code></h3>
<p><code>image_invert</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_invert $x
# or in a pipeline:
@list |> map image_invert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-morphology-close">
<h3><a class="doc-anchor" href="#doc-image-morphology-close">#</a> <code>image_morphology_close</code></h3>
<p><code>image_morphology_close</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_morphology_close $x
# or in a pipeline:
@list |> map image_morphology_close |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-morphology-open">
<h3><a class="doc-anchor" href="#doc-image-morphology-open">#</a> <code>image_morphology_open</code></h3>
<p><code>image_morphology_open</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_morphology_open $x
# or in a pipeline:
@list |> map image_morphology_open |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-motion-blur">
<h3><a class="doc-anchor" href="#doc-image-motion-blur">#</a> <code>image_motion_blur</code></h3>
<p><code>image_motion_blur</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_motion_blur $x
# or in a pipeline:
@list |> map image_motion_blur |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-posterize">
<h3><a class="doc-anchor" href="#doc-image-posterize">#</a> <code>image_posterize</code></h3>
<p><code>image_posterize</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_posterize $x
# or in a pipeline:
@list |> map image_posterize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-resize">
<h3><a class="doc-anchor" href="#doc-image-resize">#</a> <code>image_resize</code></h3>
<p><code>image_resize</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_resize $x
# or in a pipeline:
@list |> map image_resize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-rotate">
<h3><a class="doc-anchor" href="#doc-image-rotate">#</a> <code>image_rotate</code></h3>
<p><code>image_rotate</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_rotate $x
# or in a pipeline:
@list |> map image_rotate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-sepia">
<h3><a class="doc-anchor" href="#doc-image-sepia">#</a> <code>image_sepia</code></h3>
<p><code>image_sepia</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_sepia $x
# or in a pipeline:
@list |> map image_sepia |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-sharpen">
<h3><a class="doc-anchor" href="#doc-image-sharpen">#</a> <code>image_sharpen</code></h3>
<p><code>image_sharpen</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_sharpen $x
# or in a pipeline:
@list |> map image_sharpen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-solarize">
<h3><a class="doc-anchor" href="#doc-image-solarize">#</a> <code>image_solarize</code></h3>
<p><code>image_solarize</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_solarize $x
# or in a pipeline:
@list |> map image_solarize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-image-threshold">
<h3><a class="doc-anchor" href="#doc-image-threshold">#</a> <code>image_threshold</code></h3>
<p><code>image_threshold</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = image_threshold $x
# or in a pipeline:
@list |> map image_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-imei-check">
<h3><a class="doc-anchor" href="#doc-imei-check">#</a> <code>imei_check</code></h3>
<p><code>imei_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = imei_check $x
# or in a pipeline:
@list |> map imei_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-imex-euler-step">
<h3><a class="doc-anchor" href="#doc-imex-euler-step">#</a> <code>imex_euler_step</code></h3>
<p><code>imex_euler_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = imex_euler_step $x
# or in a pipeline:
@list |> map imex_euler_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-imex-theta-split">
<h3><a class="doc-anchor" href="#doc-imex-theta-split">#</a> <code>imex_theta_split</code></h3>
<p><code>imex_theta_split</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = imex_theta_split $x
# or in a pipeline:
@list |> map imex_theta_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-impedance-rlc">
<h3><a class="doc-anchor" href="#doc-impedance-rlc">#</a> <code>impedance_rlc</code></h3>
<p><code>impedance_rlc</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = impedance_rlc $x
# or in a pipeline:
@list |> map impedance_rlc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-impl">
<h3><a class="doc-anchor" href="#doc-impl">#</a> <code>impl</code></h3>
<p><code>impl</code> declares which traits a class implements.</p>
<pre><code class="lang-perl">trait Printable { fn to_str }
class Item impl Printable {
name: Str
fn to_str { $self->name }
}
</code></pre>
<p>Multiple traits: <code>class X impl A, B, C { }</code></p>
</article>
<article class="doc-entry" id="doc-implicit-euler">
<h3><a class="doc-anchor" href="#doc-implicit-euler">#</a> <code>implicit_euler</code></h3>
<p><code>implicit_euler</code> — batch 19 builtin. Alias for <code>backward_euler</code>.</p>
<pre><code class="lang-perl">my $result = implicit_euler $x
# or in a pipeline:
@list |> map implicit_euler |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-impulse">
<h3><a class="doc-anchor" href="#doc-impulse">#</a> <code>impulse</code></h3>
<p><code>impulse($force, $time)</code> — compute impulse J = F×t (N⋅s). Change in momentum.</p>
<pre><code class="lang-perl">p impulse(100, 0.5) # 50 N⋅s
</code></pre>
</article>
<article class="doc-entry" id="doc-impulse-response-n">
<h3><a class="doc-anchor" href="#doc-impulse-response-n">#</a> <code>impulse_response_n</code></h3>
<p><code>impulse_response_n</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = impulse_response_n $x
# or in a pipeline:
@list |> map impulse_response_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-impulse-response-step">
<h3><a class="doc-anchor" href="#doc-impulse-response-step">#</a> <code>impulse_response_step</code></h3>
<p><code>impulse_response_step</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = impulse_response_step $x
# or in a pipeline:
@list |> map impulse_response_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-imputation-efficient-check">
<h3><a class="doc-anchor" href="#doc-imputation-efficient-check">#</a> <code>imputation_efficient_check</code></h3>
<p><code>imputation_efficient_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = imputation_efficient_check $x
# or in a pipeline:
@list |> map imputation_efficient_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-imputation-individual-rational">
<h3><a class="doc-anchor" href="#doc-imputation-individual-rational">#</a> <code>imputation_individual_rational</code></h3>
<p><code>imputation_individual_rational</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = imputation_individual_rational $x
# or in a pipeline:
@list |> map imputation_individual_rational |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-imu-madgwick-step">
<h3><a class="doc-anchor" href="#doc-imu-madgwick-step">#</a> <code>imu_madgwick_step</code></h3>
<p><code>imu_madgwick_step</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = imu_madgwick_step $x
# or in a pipeline:
@list |> map imu_madgwick_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-imu-mahony-step">
<h3><a class="doc-anchor" href="#doc-imu-mahony-step">#</a> <code>imu_mahony_step</code></h3>
<p><code>imu_mahony_step</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = imu_mahony_step $x
# or in a pipeline:
@list |> map imu_mahony_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-in-degree-directed">
<h3><a class="doc-anchor" href="#doc-in-degree-directed">#</a> <code>in_degree_directed</code></h3>
<p><code>in_degree_directed</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = in_degree_directed $x
# or in a pipeline:
@list |> map in_degree_directed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-in-range">
<h3><a class="doc-anchor" href="#doc-in-range">#</a> <code>in_range</code></h3>
<p><code>in_range</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = in_range $x
# or in a pipeline:
@list |> map in_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inc">
<h3><a class="doc-anchor" href="#doc-inc">#</a> <code>inc</code></h3>
<p><code>inc</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = inc $x
# or in a pipeline:
@list |> map inc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inc-each">
<h3><a class="doc-anchor" href="#doc-inc-each">#</a> <code>inc_each</code></h3>
<p><code>inc_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = inc_each $x
# or in a pipeline:
@list |> map inc_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-incentive-compatibility-check">
<h3><a class="doc-anchor" href="#doc-incentive-compatibility-check">#</a> <code>incentive_compatibility_check</code></h3>
<p><code>incentive_compatibility_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = incentive_compatibility_check $x
# or in a pipeline:
@list |> map incentive_compatibility_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inches-to-cm">
<h3><a class="doc-anchor" href="#doc-inches-to-cm">#</a> <code>inches_to_cm</code></h3>
<p><code>inches_to_cm</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = inches_to_cm $input
</code></pre>
</article>
<article class="doc-entry" id="doc-incidence-algebra-dim">
<h3><a class="doc-anchor" href="#doc-incidence-algebra-dim">#</a> <code>incidence_algebra_dim</code></h3>
<p><code>incidence_algebra_dim</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = incidence_algebra_dim $x
# or in a pipeline:
@list |> map incidence_algebra_dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-includes-val">
<h3><a class="doc-anchor" href="#doc-includes-val">#</a> <code>includes_val</code></h3>
<p><code>includes_val</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = includes_val $x
# or in a pipeline:
@list |> map includes_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-income-elasticity">
<h3><a class="doc-anchor" href="#doc-income-elasticity">#</a> <code>income_elasticity</code></h3>
<p><code>income_elasticity</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = income_elasticity $x
# or in a pipeline:
@list |> map income_elasticity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-incr">
<h3><a class="doc-anchor" href="#doc-incr">#</a> <code>incr</code></h3>
<p><code>incr</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = incr $x
# or in a pipeline:
@list |> map incr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-incrby">
<h3><a class="doc-anchor" href="#doc-incrby">#</a> <code>incrby</code></h3>
<p><code>incrby</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = incrby $x
# or in a pipeline:
@list |> map incrby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-incv">
<h3><a class="doc-anchor" href="#doc-incv">#</a> <code>incv</code></h3>
<p><code>incv</code> — javascript array/object methods builtin. Alias for <code>includes_val</code>.</p>
<pre><code class="lang-perl">my $result = incv $x
# or in a pipeline:
@list |> map incv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indenergy">
<h3><a class="doc-anchor" href="#doc-indenergy">#</a> <code>indenergy</code></h3>
<p><code>indenergy</code> — physics formulas builtin. Alias for <code>inductor_energy</code>.</p>
<pre><code class="lang-perl">my $result = indenergy $x
# or in a pipeline:
@list |> map indenergy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indent">
<h3><a class="doc-anchor" href="#doc-indent">#</a> <code>indent</code></h3>
<p><code>indent</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = indent $x
# or in a pipeline:
@list |> map indent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indent-text">
<h3><a class="doc-anchor" href="#doc-indent-text">#</a> <code>indent_text</code></h3>
<p><code>indent_text</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = indent_text $x
# or in a pipeline:
@list |> map indent_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-independence-number-upper">
<h3><a class="doc-anchor" href="#doc-independence-number-upper">#</a> <code>independence_number_upper</code></h3>
<p><code>independence_number_upper</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = independence_number_upper $x
# or in a pipeline:
@list |> map independence_number_upper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-by">
<h3><a class="doc-anchor" href="#doc-index-by">#</a> <code>index_by</code></h3>
<p><code>index_by</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = index_by $x
# or in a pipeline:
@list |> map index_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-calculus-naive">
<h3><a class="doc-anchor" href="#doc-index-calculus-naive">#</a> <code>index_calculus_naive</code></h3>
<p><code>index_calculus_naive</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = index_calculus_naive $x
# or in a pipeline:
@list |> map index_calculus_naive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-from-speed">
<h3><a class="doc-anchor" href="#doc-index-from-speed">#</a> <code>index_from_speed</code></h3>
<p><code>index_from_speed</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = index_from_speed $x
# or in a pipeline:
@list |> map index_from_speed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-match">
<h3><a class="doc-anchor" href="#doc-index-match">#</a> <code>index_match</code></h3>
<p><code>index_match</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = index_match $x
# or in a pipeline:
@list |> map index_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-of">
<h3><a class="doc-anchor" href="#doc-index-of">#</a> <code>index_of</code></h3>
<p><code>index_of</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = index_of $x
# or in a pipeline:
@list |> map index_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-of-coincidence">
<h3><a class="doc-anchor" href="#doc-index-of-coincidence">#</a> <code>index_of_coincidence</code></h3>
<p><code>index_of_coincidence</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = index_of_coincidence $x
# or in a pipeline:
@list |> map index_of_coincidence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-of-elem">
<h3><a class="doc-anchor" href="#doc-index-of-elem">#</a> <code>index_of_elem</code></h3>
<p><code>index_of_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = index_of_elem $x
# or in a pipeline:
@list |> map index_of_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indexes-of">
<h3><a class="doc-anchor" href="#doc-indexes-of">#</a> <code>indexes_of</code></h3>
<p><code>indexes_of</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = indexes_of $x
# or in a pipeline:
@list |> map indexes_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indian-monsoon-index">
<h3><a class="doc-anchor" href="#doc-indian-monsoon-index">#</a> <code>indian_monsoon_index</code></h3>
<p><code>indian_monsoon_index</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = indian_monsoon_index $x
# or in a pipeline:
@list |> map indian_monsoon_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indirect">
<h3><a class="doc-anchor" href="#doc-indirect">#</a> <code>indirect</code></h3>
<p><code>indirect</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = indirect $x
# or in a pipeline:
@list |> map indirect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indirect-age-adjusted">
<h3><a class="doc-anchor" href="#doc-indirect-age-adjusted">#</a> <code>indirect_age_adjusted</code></h3>
<p><code>indirect_age_adjusted</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = indirect_age_adjusted $x
# or in a pipeline:
@list |> map indirect_age_adjusted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indirect-utility">
<h3><a class="doc-anchor" href="#doc-indirect-utility">#</a> <code>indirect_utility</code></h3>
<p><code>indirect_utility</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = indirect_utility $x
# or in a pipeline:
@list |> map indirect_utility |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indivisible-envy-free-check">
<h3><a class="doc-anchor" href="#doc-indivisible-envy-free-check">#</a> <code>indivisible_envy_free_check</code></h3>
<p><code>indivisible_envy_free_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = indivisible_envy_free_check $x
# or in a pipeline:
@list |> map indivisible_envy_free_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inductance-parallel">
<h3><a class="doc-anchor" href="#doc-inductance-parallel">#</a> <code>inductance_parallel</code></h3>
<p><code>inductance_parallel</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = inductance_parallel $x
# or in a pipeline:
@list |> map inductance_parallel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inductance-series">
<h3><a class="doc-anchor" href="#doc-inductance-series">#</a> <code>inductance_series</code></h3>
<p><code>inductance_series</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = inductance_series $x
# or in a pipeline:
@list |> map inductance_series |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inductor-energy">
<h3><a class="doc-anchor" href="#doc-inductor-energy">#</a> <code>inductor_energy</code></h3>
<p><code>inductor_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = inductor_energy $x
# or in a pipeline:
@list |> map inductor_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-infinite-well-energy">
<h3><a class="doc-anchor" href="#doc-infinite-well-energy">#</a> <code>infinite_well_energy</code></h3>
<p><code>infinite_well_energy</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = infinite_well_energy $x
# or in a pipeline:
@list |> map infinite_well_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-information-bottleneck-step">
<h3><a class="doc-anchor" href="#doc-information-bottleneck-step">#</a> <code>information_bottleneck_step</code></h3>
<p><code>information_bottleneck_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = information_bottleneck_step $x
# or in a pipeline:
@list |> map information_bottleneck_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-information-gain">
<h3><a class="doc-anchor" href="#doc-information-gain">#</a> <code>information_gain</code></h3>
<p><code>information_gain</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = information_gain $x
# or in a pipeline:
@list |> map information_gain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-information-ratio">
<h3><a class="doc-anchor" href="#doc-information-ratio">#</a> <code>information_ratio</code></h3>
<p><code>information_ratio</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = information_ratio $x
# or in a pipeline:
@list |> map information_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-init-list">
<h3><a class="doc-anchor" href="#doc-init-list">#</a> <code>init_list</code></h3>
<p><code>init_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = init_list $x
# or in a pipeline:
@list |> map init_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-initial-bearing">
<h3><a class="doc-anchor" href="#doc-initial-bearing">#</a> <code>initial_bearing</code></h3>
<p><code>initial_bearing</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = initial_bearing $x
# or in a pipeline:
@list |> map initial_bearing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-initials">
<h3><a class="doc-anchor" href="#doc-initials">#</a> <code>initials</code></h3>
<p><code>initials</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = initials $x
# or in a pipeline:
@list |> map initials |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inits">
<h3><a class="doc-anchor" href="#doc-inits">#</a> <code>inits</code></h3>
<p><code>inits</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = inits $x
# or in a pipeline:
@list |> map inits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inits-str">
<h3><a class="doc-anchor" href="#doc-inits-str">#</a> <code>inits_str</code></h3>
<p><code>inits_str</code> — string processing (uncategorized batch) builtin. Alias for <code>initials</code>.</p>
<pre><code class="lang-perl">my $result = inits_str $x
# or in a pipeline:
@list |> map inits_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inject">
<h3><a class="doc-anchor" href="#doc-inject">#</a> <code>inject</code></h3>
<p><code>inject</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = inject $x
# or in a pipeline:
@list |> map inject |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inrng">
<h3><a class="doc-anchor" href="#doc-inrng">#</a> <code>inrng</code></h3>
<p><code>inrng</code> — extended stdlib builtin. Alias for <code>in_range</code>.</p>
<pre><code class="lang-perl">my $result = inrng $x
# or in a pipeline:
@list |> map inrng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insa">
<h3><a class="doc-anchor" href="#doc-insa">#</a> <code>insa</code></h3>
<p><code>insa</code> — go/general functional utilities builtin. Alias for <code>insert_at</code>.</p>
<pre><code class="lang-perl">my $result = insa $x
# or in a pipeline:
@list |> map insa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insert-at">
<h3><a class="doc-anchor" href="#doc-insert-at">#</a> <code>insert_at</code></h3>
<p><code>insert_at</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = insert_at $x
# or in a pipeline:
@list |> map insert_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insert-at-idx">
<h3><a class="doc-anchor" href="#doc-insert-at-idx">#</a> <code>insert_at_idx</code></h3>
<p><code>insert_at_idx</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = insert_at_idx $x
# or in a pipeline:
@list |> map insert_at_idx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insert-sorted">
<h3><a class="doc-anchor" href="#doc-insert-sorted">#</a> <code>insert_sorted</code></h3>
<p><code>insert_sorted</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = insert_sorted $x
# or in a pipeline:
@list |> map insert_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insert-str">
<h3><a class="doc-anchor" href="#doc-insert-str">#</a> <code>insert_str</code></h3>
<p><code>insert_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = insert_str $x
# or in a pipeline:
@list |> map insert_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insp">
<h3><a class="doc-anchor" href="#doc-insp">#</a> <code>insp</code></h3>
<p><code>insp</code> — rust iterator methods builtin. Alias for <code>inspect</code>.</p>
<pre><code class="lang-perl">my $result = insp $x
# or in a pipeline:
@list |> map insp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inspect">
<h3><a class="doc-anchor" href="#doc-inspect">#</a> <code>inspect</code></h3>
<p><code>inspect</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = inspect $x
# or in a pipeline:
@list |> map inspect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inssrt">
<h3><a class="doc-anchor" href="#doc-inssrt">#</a> <code>inssrt</code></h3>
<p><code>inssrt</code> — additional missing stdlib functions builtin. Alias for <code>insert_sorted</code>.</p>
<pre><code class="lang-perl">my $result = inssrt $x
# or in a pipeline:
@list |> map inssrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-int-bits">
<h3><a class="doc-anchor" href="#doc-int-bits">#</a> <code>int_bits</code></h3>
<p><code>int_bits</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = int_bits $x
# or in a pipeline:
@list |> map int_bits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-int-to-ipv4">
<h3><a class="doc-anchor" href="#doc-int-to-ipv4">#</a> <code>int_to_ipv4</code></h3>
<p><code>int_to_ipv4</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = int_to_ipv4 $input
</code></pre>
</article>
<article class="doc-entry" id="doc-int-to-roman">
<h3><a class="doc-anchor" href="#doc-int-to-roman">#</a> <code>int_to_roman</code></h3>
<p><code>int_to_roman</code> — roman numerals builtin.</p>
<pre><code class="lang-perl">my $result = int_to_roman $input
</code></pre>
</article>
<article class="doc-entry" id="doc-integral-length-scale">
<h3><a class="doc-anchor" href="#doc-integral-length-scale">#</a> <code>integral_length_scale</code></h3>
<p><code>integral_length_scale</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = integral_length_scale $x
# or in a pipeline:
@list |> map integral_length_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intercalate">
<h3><a class="doc-anchor" href="#doc-intercalate">#</a> <code>intercalate</code></h3>
<p><code>intercalate</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = intercalate $x
# or in a pipeline:
@list |> map intercalate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-interleave-lists">
<h3><a class="doc-anchor" href="#doc-interleave-lists">#</a> <code>interleave_lists</code></h3>
<p><code>interleave_lists</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = interleave_lists $x
# or in a pipeline:
@list |> map interleave_lists |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-internal-rate-of-return">
<h3><a class="doc-anchor" href="#doc-internal-rate-of-return">#</a> <code>internal_rate_of_return</code></h3>
<p><code>internal_rate_of_return</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = internal_rate_of_return $x
# or in a pipeline:
@list |> map internal_rate_of_return |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-interp1d">
<h3><a class="doc-anchor" href="#doc-interp1d">#</a> <code>interp1d</code></h3>
<p><code>interp1d</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = interp1d $x
# or in a pipeline:
@list |> map interp1d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-interpose">
<h3><a class="doc-anchor" href="#doc-interpose">#</a> <code>interpose</code></h3>
<p><code>interpose</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = interpose $x
# or in a pipeline:
@list |> map interpose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersect-list">
<h3><a class="doc-anchor" href="#doc-intersect-list">#</a> <code>intersect_list</code></h3>
<p><code>intersect_list</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = intersect_list $x
# or in a pipeline:
@list |> map intersect_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersperse">
<h3><a class="doc-anchor" href="#doc-intersperse">#</a> <code>intersperse</code></h3>
<p><code>intersperse</code> — collection helpers (trivial) builtin. Alias for <code>riffle</code>.</p>
<pre><code class="lang-perl">my $result = intersperse $x
# or in a pipeline:
@list |> map intersperse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersperse-char">
<h3><a class="doc-anchor" href="#doc-intersperse-char">#</a> <code>intersperse_char</code></h3>
<p><code>intersperse_char</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = intersperse_char $x
# or in a pipeline:
@list |> map intersperse_char |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersperse-val">
<h3><a class="doc-anchor" href="#doc-intersperse-val">#</a> <code>intersperse_val</code></h3>
<p><code>intersperse_val</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = intersperse_val $x
# or in a pipeline:
@list |> map intersperse_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersperse-with">
<h3><a class="doc-anchor" href="#doc-intersperse-with">#</a> <code>intersperse_with</code></h3>
<p><code>intersperse_with</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = intersperse_with $x
# or in a pipeline:
@list |> map intersperse_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-interval-quality-size">
<h3><a class="doc-anchor" href="#doc-interval-quality-size">#</a> <code>interval_quality_size</code></h3>
<p><code>interval_quality_size</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = interval_quality_size $x
# or in a pipeline:
@list |> map interval_quality_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-interval-semitones">
<h3><a class="doc-anchor" href="#doc-interval-semitones">#</a> <code>interval_semitones</code></h3>
<p><code>interval_semitones</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = interval_semitones $x
# or in a pipeline:
@list |> map interval_semitones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intl">
<h3><a class="doc-anchor" href="#doc-intl">#</a> <code>intl</code></h3>
<p><code>intl</code> — additional missing stdlib functions builtin. Alias for <code>intersect_list</code>.</p>
<pre><code class="lang-perl">my $result = intl $x
# or in a pipeline:
@list |> map intl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-into">
<h3><a class="doc-anchor" href="#doc-into">#</a> <code>into</code></h3>
<p><code>into</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = into $x
# or in a pipeline:
@list |> map into |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intrate">
<h3><a class="doc-anchor" href="#doc-intrate">#</a> <code>intrate</code></h3>
<p><code>intrate</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = intrate $x
# or in a pipeline:
@list |> map intrate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intrinsic-growth-rate">
<h3><a class="doc-anchor" href="#doc-intrinsic-growth-rate">#</a> <code>intrinsic_growth_rate</code></h3>
<p><code>intrinsic_growth_rate</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = intrinsic_growth_rate $x
# or in a pipeline:
@list |> map intrinsic_growth_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intrinsic-principal-curv">
<h3><a class="doc-anchor" href="#doc-intrinsic-principal-curv">#</a> <code>intrinsic_principal_curv</code></h3>
<p><code>intrinsic_principal_curv</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = intrinsic_principal_curv $x
# or in a pipeline:
@list |> map intrinsic_principal_curv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inv-lerp">
<h3><a class="doc-anchor" href="#doc-inv-lerp">#</a> <code>inv_lerp</code></h3>
<p><code>inv_lerp</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = inv_lerp $x
# or in a pipeline:
@list |> map inv_lerp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse">
<h3><a class="doc-anchor" href="#doc-inverse">#</a> <code>inverse</code></h3>
<p><code>inverse</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = inverse $x
# or in a pipeline:
@list |> map inverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-chi2-pdf">
<h3><a class="doc-anchor" href="#doc-inverse-chi2-pdf">#</a> <code>inverse_chi2_pdf</code></h3>
<p><code>inverse_chi2_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = inverse_chi2_pdf $x
# or in a pipeline:
@list |> map inverse_chi2_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-kinematics-2link">
<h3><a class="doc-anchor" href="#doc-inverse-kinematics-2link">#</a> <code>inverse_kinematics_2link</code></h3>
<p><code>inverse_kinematics_2link</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = inverse_kinematics_2link $x
# or in a pipeline:
@list |> map inverse_kinematics_2link |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-lerp">
<h3><a class="doc-anchor" href="#doc-inverse-lerp">#</a> <code>inverse_lerp</code></h3>
<p><code>inverse_lerp</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = inverse_lerp $x
# or in a pipeline:
@list |> map inverse_lerp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-qft">
<h3><a class="doc-anchor" href="#doc-inverse-qft">#</a> <code>inverse_qft</code></h3>
<p><code>inverse_qft</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = inverse_qft $x
# or in a pipeline:
@list |> map inverse_qft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-quad-interp">
<h3><a class="doc-anchor" href="#doc-inverse-quad-interp">#</a> <code>inverse_quad_interp</code></h3>
<p><code>inverse_quad_interp</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = inverse_quad_interp $x
# or in a pipeline:
@list |> map inverse_quad_interp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-simpson">
<h3><a class="doc-anchor" href="#doc-inverse-simpson">#</a> <code>inverse_simpson</code></h3>
<p><code>inverse_simpson</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = inverse_simpson $x
# or in a pipeline:
@list |> map inverse_simpson |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-weibull-pdf">
<h3><a class="doc-anchor" href="#doc-inverse-weibull-pdf">#</a> <code>inverse_weibull_pdf</code></h3>
<p><code>inverse_weibull_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = inverse_weibull_pdf $x
# or in a pipeline:
@list |> map inverse_weibull_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-invert">
<h3><a class="doc-anchor" href="#doc-invert">#</a> <code>invert</code></h3>
<p><code>invert</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = invert $x
# or in a pipeline:
@list |> map invert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-invert-perm">
<h3><a class="doc-anchor" href="#doc-invert-perm">#</a> <code>invert_perm</code></h3>
<p><code>invert_perm</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = invert_perm $x
# or in a pipeline:
@list |> map invert_perm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ioctl">
<h3><a class="doc-anchor" href="#doc-ioctl">#</a> <code>ioctl</code></h3>
<p><code>ioctl</code> — ipc builtin.</p>
<pre><code class="lang-perl">my $result = ioctl $x
# or in a pipeline:
@list |> map ioctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ionic-conductivity-arrhenius">
<h3><a class="doc-anchor" href="#doc-ionic-conductivity-arrhenius">#</a> <code>ionic_conductivity_arrhenius</code></h3>
<p><code>ionic_conductivity_arrhenius</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = ionic_conductivity_arrhenius $x
# or in a pipeline:
@list |> map ionic_conductivity_arrhenius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ionic-liquid-viscosity-step">
<h3><a class="doc-anchor" href="#doc-ionic-liquid-viscosity-step">#</a> <code>ionic_liquid_viscosity_step</code></h3>
<p><code>ionic_liquid_viscosity_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = ionic_liquid_viscosity_step $x
# or in a pipeline:
@list |> map ionic_liquid_viscosity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ionic-strength">
<h3><a class="doc-anchor" href="#doc-ionic-strength">#</a> <code>ionic_strength</code></h3>
<p><code>ionic_strength</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = ionic_strength $x
# or in a pipeline:
@list |> map ionic_strength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iota-n">
<h3><a class="doc-anchor" href="#doc-iota-n">#</a> <code>iota_n</code></h3>
<p><code>iota_n</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = iota_n $x
# or in a pipeline:
@list |> map iota_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iou-2d-axis-aligned">
<h3><a class="doc-anchor" href="#doc-iou-2d-axis-aligned">#</a> <code>iou_2d_axis_aligned</code></h3>
<p><code>iou_2d_axis_aligned</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = iou_2d_axis_aligned $x
# or in a pipeline:
@list |> map iou_2d_axis_aligned |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ipmt">
<h3><a class="doc-anchor" href="#doc-ipmt">#</a> <code>ipmt</code></h3>
<p><code>ipmt</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = ipmt $x
# or in a pipeline:
@list |> map ipmt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ipos">
<h3><a class="doc-anchor" href="#doc-ipos">#</a> <code>ipos</code></h3>
<p><code>ipos</code> — go/general functional utilities builtin. Alias for <code>interpose</code>.</p>
<pre><code class="lang-perl">my $result = ipos $x
# or in a pipeline:
@list |> map ipos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ipv4-to-int">
<h3><a class="doc-anchor" href="#doc-ipv4-to-int">#</a> <code>ipv4_to_int</code></h3>
<p><code>ipv4_to_int</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = ipv4_to_int $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ipv-potential-vorticity">
<h3><a class="doc-anchor" href="#doc-ipv-potential-vorticity">#</a> <code>ipv_potential_vorticity</code></h3>
<p><code>ipv_potential_vorticity</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = ipv_potential_vorticity $x
# or in a pipeline:
@list |> map ipv_potential_vorticity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iqr">
<h3><a class="doc-anchor" href="#doc-iqr">#</a> <code>iqr</code></h3>
<p><code>iqr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = iqr $x
# or in a pipeline:
@list |> map iqr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-irr">
<h3><a class="doc-anchor" href="#doc-irr">#</a> <code>irr</code></h3>
<p><code>irr(@cashflows)</code> — computes the Internal Rate of Return for a series of cash flows. First value is typically negative (initial investment). Uses Newton-Raphson iteration.</p>
<pre><code class="lang-perl">my @cf = (-1000, 300, 420, 680)
p irr(@cf) # ~0.166 (16.6%)
</code></pre>
</article>
<article class="doc-entry" id="doc-is-7-smooth">
<h3><a class="doc-anchor" href="#doc-is-7-smooth">#</a> <code>is_7_smooth</code></h3>
<p><code>is_7_smooth</code> — batch 10 builtin. Alias for <code>seven_smooth_q</code>.</p>
<pre><code class="lang-perl">my $result = is_7_smooth $x
# or in a pipeline:
@list |> map is_7_smooth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-abundant">
<h3><a class="doc-anchor" href="#doc-is-abundant">#</a> <code>is_abundant</code></h3>
<p><code>is_abundant</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_abundant $x
# or in a pipeline:
@list |> map is_abundant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-alnum">
<h3><a class="doc-anchor" href="#doc-is-alnum">#</a> <code>is_alnum</code></h3>
<p><code>is_alnum</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_alnum $x
# or in a pipeline:
@list |> map is_alnum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-alpha">
<h3><a class="doc-anchor" href="#doc-is-alpha">#</a> <code>is_alpha</code></h3>
<p><code>is_alpha</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_alpha $x
# or in a pipeline:
@list |> map is_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-anagram">
<h3><a class="doc-anchor" href="#doc-is-anagram">#</a> <code>is_anagram</code></h3>
<p><code>is_anagram</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_anagram $x
# or in a pipeline:
@list |> map is_anagram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-anagram-q">
<h3><a class="doc-anchor" href="#doc-is-anagram-q">#</a> <code>is_anagram_q</code></h3>
<p><code>is_anagram_q</code> — batch 11 builtin. Alias for <code>anagram_q</code>.</p>
<pre><code class="lang-perl">my $result = is_anagram_q $x
# or in a pipeline:
@list |> map is_anagram_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-armstrong">
<h3><a class="doc-anchor" href="#doc-is-armstrong">#</a> <code>is_armstrong</code></h3>
<p><code>is_armstrong</code> — batch 11 builtin. Alias for <code>armstrong_q</code>.</p>
<pre><code class="lang-perl">my $result = is_armstrong $x
# or in a pipeline:
@list |> map is_armstrong |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-array">
<h3><a class="doc-anchor" href="#doc-is-array">#</a> <code>is_array</code></h3>
<p><code>is_array</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_array $x
# or in a pipeline:
@list |> map is_array |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-arrayref">
<h3><a class="doc-anchor" href="#doc-is-arrayref">#</a> <code>is_arrayref</code></h3>
<p><code>is_arrayref</code> — trivial type predicates builtin. Alias for <code>is_array</code>.</p>
<pre><code class="lang-perl">my $result = is_arrayref $x
# or in a pipeline:
@list |> map is_arrayref |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-asc">
<h3><a class="doc-anchor" href="#doc-is-asc">#</a> <code>is_asc</code></h3>
<p><code>is_asc</code> — predicates (batch 2) builtin. Alias for <code>is_sorted</code>.</p>
<pre><code class="lang-perl">my $result = is_asc $x
# or in a pipeline:
@list |> map is_asc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ascii">
<h3><a class="doc-anchor" href="#doc-is-ascii">#</a> <code>is_ascii</code></h3>
<p><code>is_ascii</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_ascii $x
# or in a pipeline:
@list |> map is_ascii |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-b-smooth">
<h3><a class="doc-anchor" href="#doc-is-b-smooth">#</a> <code>is_b_smooth</code></h3>
<p><code>is_b_smooth</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = is_b_smooth $x
# or in a pipeline:
@list |> map is_b_smooth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-balanced-parens">
<h3><a class="doc-anchor" href="#doc-is-balanced-parens">#</a> <code>is_balanced_parens</code></h3>
<p><code>is_balanced_parens</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_balanced_parens $x
# or in a pipeline:
@list |> map is_balanced_parens |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-base64">
<h3><a class="doc-anchor" href="#doc-is-base64">#</a> <code>is_base64</code></h3>
<p><code>is_base64</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_base64 $x
# or in a pipeline:
@list |> map is_base64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-between">
<h3><a class="doc-anchor" href="#doc-is-between">#</a> <code>is_between</code></h3>
<p><code>is_between</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_between $x
# or in a pipeline:
@list |> map is_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-binary-str">
<h3><a class="doc-anchor" href="#doc-is-binary-str">#</a> <code>is_binary_str</code></h3>
<p><code>is_binary_str</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_binary_str $x
# or in a pipeline:
@list |> map is_binary_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-bipartite-graph">
<h3><a class="doc-anchor" href="#doc-is-bipartite-graph">#</a> <code>is_bipartite_graph</code></h3>
<p><code>is_bipartite_graph</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_bipartite_graph $x
# or in a pipeline:
@list |> map is_bipartite_graph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-blank">
<h3><a class="doc-anchor" href="#doc-is-blank">#</a> <code>is_blank</code></h3>
<p><code>is_blank</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_blank $x
# or in a pipeline:
@list |> map is_blank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-blank-or-nil">
<h3><a class="doc-anchor" href="#doc-is-blank-or-nil">#</a> <code>is_blank_or_nil</code></h3>
<p><code>is_blank_or_nil</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_blank_or_nil $x
# or in a pipeline:
@list |> map is_blank_or_nil |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-callable">
<h3><a class="doc-anchor" href="#doc-is-callable">#</a> <code>is_callable</code></h3>
<p><code>is_callable</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = is_callable $x
# or in a pipeline:
@list |> map is_callable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-carmichael">
<h3><a class="doc-anchor" href="#doc-is-carmichael">#</a> <code>is_carmichael</code></h3>
<p><code>is_carmichael</code> — batch 10 builtin. Alias for <code>carmichael_q</code>.</p>
<pre><code class="lang-perl">my $result = is_carmichael $x
# or in a pipeline:
@list |> map is_carmichael |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-code">
<h3><a class="doc-anchor" href="#doc-is-code">#</a> <code>is_code</code></h3>
<p><code>is_code</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_code $x
# or in a pipeline:
@list |> map is_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-coderef">
<h3><a class="doc-anchor" href="#doc-is-coderef">#</a> <code>is_coderef</code></h3>
<p><code>is_coderef</code> — trivial type predicates builtin. Alias for <code>is_code</code>.</p>
<pre><code class="lang-perl">my $result = is_coderef $x
# or in a pipeline:
@list |> map is_coderef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-connected">
<h3><a class="doc-anchor" href="#doc-is-connected">#</a> <code>is_connected</code></h3>
<p><code>is_connected</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = is_connected $x
# or in a pipeline:
@list |> map is_connected |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-consonant">
<h3><a class="doc-anchor" href="#doc-is-consonant">#</a> <code>is_consonant</code></h3>
<p><code>is_consonant</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_consonant $x
# or in a pipeline:
@list |> map is_consonant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-control">
<h3><a class="doc-anchor" href="#doc-is-control">#</a> <code>is_control</code></h3>
<p><code>is_control</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_control $x
# or in a pipeline:
@list |> map is_control |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-coprime">
<h3><a class="doc-anchor" href="#doc-is-coprime">#</a> <code>is_coprime</code></h3>
<p><code>is_coprime</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_coprime $x
# or in a pipeline:
@list |> map is_coprime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-credit-card">
<h3><a class="doc-anchor" href="#doc-is-credit-card">#</a> <code>is_credit_card</code></h3>
<p><code>is_credit_card</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_credit_card $x
# or in a pipeline:
@list |> map is_credit_card |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-def">
<h3><a class="doc-anchor" href="#doc-is-def">#</a> <code>is_def</code></h3>
<p><code>is_def</code> — trivial type predicates builtin. Alias for <code>is_defined</code>.</p>
<pre><code class="lang-perl">my $result = is_def $x
# or in a pipeline:
@list |> map is_def |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-deficient">
<h3><a class="doc-anchor" href="#doc-is-deficient">#</a> <code>is_deficient</code></h3>
<p><code>is_deficient</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_deficient $x
# or in a pipeline:
@list |> map is_deficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-defined">
<h3><a class="doc-anchor" href="#doc-is-defined">#</a> <code>is_defined</code></h3>
<p><code>is_defined</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_defined $x
# or in a pipeline:
@list |> map is_defined |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-desc">
<h3><a class="doc-anchor" href="#doc-is-desc">#</a> <code>is_desc</code></h3>
<p><code>is_desc</code> — predicates (batch 2) builtin. Alias for <code>is_sorted_desc</code>.</p>
<pre><code class="lang-perl">my $result = is_desc $x
# or in a pipeline:
@list |> map is_desc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-digit">
<h3><a class="doc-anchor" href="#doc-is-digit">#</a> <code>is_digit</code></h3>
<p><code>is_digit</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_digit $x
# or in a pipeline:
@list |> map is_digit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-divisible-by">
<h3><a class="doc-anchor" href="#doc-is-divisible-by">#</a> <code>is_divisible_by</code></h3>
<p><code>is_divisible_by</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_divisible_by $x
# or in a pipeline:
@list |> map is_divisible_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-email">
<h3><a class="doc-anchor" href="#doc-is-email">#</a> <code>is_email</code></h3>
<p><code>is_email</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_email $x
# or in a pipeline:
@list |> map is_email |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-empty">
<h3><a class="doc-anchor" href="#doc-is-empty">#</a> <code>is_empty</code></h3>
<p><code>is_empty</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_empty $x
# or in a pipeline:
@list |> map is_empty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-empty-arr">
<h3><a class="doc-anchor" href="#doc-is-empty-arr">#</a> <code>is_empty_arr</code></h3>
<p><code>is_empty_arr</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_empty_arr $x
# or in a pipeline:
@list |> map is_empty_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-empty-hash">
<h3><a class="doc-anchor" href="#doc-is-empty-hash">#</a> <code>is_empty_hash</code></h3>
<p><code>is_empty_hash</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_empty_hash $x
# or in a pipeline:
@list |> map is_empty_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-even">
<h3><a class="doc-anchor" href="#doc-is-even">#</a> <code>is_even</code></h3>
<p><code>is_even</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_even $x
# or in a pipeline:
@list |> map is_even |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-even-num">
<h3><a class="doc-anchor" href="#doc-is-even-num">#</a> <code>is_even_num</code></h3>
<p><code>is_even_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_even_num $x
# or in a pipeline:
@list |> map is_even_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-executable">
<h3><a class="doc-anchor" href="#doc-is-executable">#</a> <code>is_executable</code></h3>
<p><code>is_executable</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_executable $x
# or in a pipeline:
@list |> map is_executable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-falsy">
<h3><a class="doc-anchor" href="#doc-is-falsy">#</a> <code>is_falsy</code></h3>
<p><code>is_falsy</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_falsy $x
# or in a pipeline:
@list |> map is_falsy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-fibonacci">
<h3><a class="doc-anchor" href="#doc-is-fibonacci">#</a> <code>is_fibonacci</code></h3>
<p><code>is_fibonacci</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_fibonacci $x
# or in a pipeline:
@list |> map is_fibonacci |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-finite">
<h3><a class="doc-anchor" href="#doc-is-finite">#</a> <code>is_finite</code></h3>
<p><code>is_finite</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_finite $x
# or in a pipeline:
@list |> map is_finite |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-float">
<h3><a class="doc-anchor" href="#doc-is-float">#</a> <code>is_float</code></h3>
<p><code>is_float</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_float $x
# or in a pipeline:
@list |> map is_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-harshad">
<h3><a class="doc-anchor" href="#doc-is-harshad">#</a> <code>is_harshad</code></h3>
<p><code>is_harshad</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_harshad $x
# or in a pipeline:
@list |> map is_harshad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hash">
<h3><a class="doc-anchor" href="#doc-is-hash">#</a> <code>is_hash</code></h3>
<p><code>is_hash</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_hash $x
# or in a pipeline:
@list |> map is_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hashref">
<h3><a class="doc-anchor" href="#doc-is-hashref">#</a> <code>is_hashref</code></h3>
<p><code>is_hashref</code> — trivial type predicates builtin. Alias for <code>is_hash</code>.</p>
<pre><code class="lang-perl">my $result = is_hashref $x
# or in a pipeline:
@list |> map is_hashref |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-heterogram">
<h3><a class="doc-anchor" href="#doc-is-heterogram">#</a> <code>is_heterogram</code></h3>
<p><code>is_heterogram</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_heterogram $x
# or in a pipeline:
@list |> map is_heterogram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hex-color">
<h3><a class="doc-anchor" href="#doc-is-hex-color">#</a> <code>is_hex_color</code></h3>
<p><code>is_hex_color</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_hex_color $x
# or in a pipeline:
@list |> map is_hex_color |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hex-str">
<h3><a class="doc-anchor" href="#doc-is-hex-str">#</a> <code>is_hex_str</code></h3>
<p><code>is_hex_str</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_hex_str $x
# or in a pipeline:
@list |> map is_hex_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hostname-valid">
<h3><a class="doc-anchor" href="#doc-is-hostname-valid">#</a> <code>is_hostname_valid</code></h3>
<p><code>is_hostname_valid</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_hostname_valid $x
# or in a pipeline:
@list |> map is_hostname_valid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-iban">
<h3><a class="doc-anchor" href="#doc-is-iban">#</a> <code>is_iban</code></h3>
<p><code>is_iban</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_iban $x
# or in a pipeline:
@list |> map is_iban |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-in-range">
<h3><a class="doc-anchor" href="#doc-is-in-range">#</a> <code>is_in_range</code></h3>
<p><code>is_in_range</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_in_range $x
# or in a pipeline:
@list |> map is_in_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-inf">
<h3><a class="doc-anchor" href="#doc-is-inf">#</a> <code>is_inf</code></h3>
<p><code>is_inf</code> — trig / math (batch 2) builtin. Alias for <code>is_infinite</code>.</p>
<pre><code class="lang-perl">my $result = is_inf $x
# or in a pipeline:
@list |> map is_inf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-infinite">
<h3><a class="doc-anchor" href="#doc-is-infinite">#</a> <code>is_infinite</code></h3>
<p><code>is_infinite</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_infinite $x
# or in a pipeline:
@list |> map is_infinite |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-int">
<h3><a class="doc-anchor" href="#doc-is-int">#</a> <code>is_int</code></h3>
<p><code>is_int</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_int $x
# or in a pipeline:
@list |> map is_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-integer">
<h3><a class="doc-anchor" href="#doc-is-integer">#</a> <code>is_integer</code></h3>
<p><code>is_integer</code> — trivial type predicates builtin. Alias for <code>is_int</code>.</p>
<pre><code class="lang-perl">my $result = is_integer $x
# or in a pipeline:
@list |> map is_integer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ipv4">
<h3><a class="doc-anchor" href="#doc-is-ipv4">#</a> <code>is_ipv4</code></h3>
<p><code>is_ipv4</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_ipv4 $x
# or in a pipeline:
@list |> map is_ipv4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ipv4-addr">
<h3><a class="doc-anchor" href="#doc-is-ipv4-addr">#</a> <code>is_ipv4_addr</code></h3>
<p><code>is_ipv4_addr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_ipv4_addr $x
# or in a pipeline:
@list |> map is_ipv4_addr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ipv6-addr">
<h3><a class="doc-anchor" href="#doc-is-ipv6-addr">#</a> <code>is_ipv6_addr</code></h3>
<p><code>is_ipv6_addr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_ipv6_addr $x
# or in a pipeline:
@list |> map is_ipv6_addr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-isbn10">
<h3><a class="doc-anchor" href="#doc-is-isbn10">#</a> <code>is_isbn10</code></h3>
<p><code>is_isbn10</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_isbn10 $x
# or in a pipeline:
@list |> map is_isbn10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-isbn13">
<h3><a class="doc-anchor" href="#doc-is-isbn13">#</a> <code>is_isbn13</code></h3>
<p><code>is_isbn13</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_isbn13 $x
# or in a pipeline:
@list |> map is_isbn13 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-iso-date">
<h3><a class="doc-anchor" href="#doc-is-iso-date">#</a> <code>is_iso_date</code></h3>
<p><code>is_iso_date</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_iso_date $x
# or in a pipeline:
@list |> map is_iso_date |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-iso-datetime">
<h3><a class="doc-anchor" href="#doc-is-iso-datetime">#</a> <code>is_iso_datetime</code></h3>
<p><code>is_iso_datetime</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_iso_datetime $x
# or in a pipeline:
@list |> map is_iso_datetime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-iso-time">
<h3><a class="doc-anchor" href="#doc-is-iso-time">#</a> <code>is_iso_time</code></h3>
<p><code>is_iso_time</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_iso_time $x
# or in a pipeline:
@list |> map is_iso_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-isogram">
<h3><a class="doc-anchor" href="#doc-is-isogram">#</a> <code>is_isogram</code></h3>
<p><code>is_isogram</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_isogram $x
# or in a pipeline:
@list |> map is_isogram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-json">
<h3><a class="doc-anchor" href="#doc-is-json">#</a> <code>is_json</code></h3>
<p><code>is_json</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_json $x
# or in a pipeline:
@list |> map is_json |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-kaprekar">
<h3><a class="doc-anchor" href="#doc-is-kaprekar">#</a> <code>is_kaprekar</code></h3>
<p><code>is_kaprekar</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_kaprekar $x
# or in a pipeline:
@list |> map is_kaprekar |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-keith">
<h3><a class="doc-anchor" href="#doc-is-keith">#</a> <code>is_keith</code></h3>
<p><code>is_keith</code> — batch 11 builtin. Alias for <code>keith_q</code>.</p>
<pre><code class="lang-perl">my $result = is_keith $x
# or in a pipeline:
@list |> map is_keith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-leap">
<h3><a class="doc-anchor" href="#doc-is-leap">#</a> <code>is_leap</code></h3>
<p><code>is_leap</code> — date helpers builtin. Alias for <code>is_leap_year</code>.</p>
<pre><code class="lang-perl">my $result = is_leap $x
# or in a pipeline:
@list |> map is_leap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-leap-year">
<h3><a class="doc-anchor" href="#doc-is-leap-year">#</a> <code>is_leap_year</code></h3>
<p><code>is_leap_year</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = is_leap_year $x
# or in a pipeline:
@list |> map is_leap_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-lower">
<h3><a class="doc-anchor" href="#doc-is-lower">#</a> <code>is_lower</code></h3>
<p><code>is_lower</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_lower $x
# or in a pipeline:
@list |> map is_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-mac-addr">
<h3><a class="doc-anchor" href="#doc-is-mac-addr">#</a> <code>is_mac_addr</code></h3>
<p><code>is_mac_addr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_mac_addr $x
# or in a pipeline:
@list |> map is_mac_addr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-match">
<h3><a class="doc-anchor" href="#doc-is-match">#</a> <code>is_match</code></h3>
<p><code>is_match</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_match $x
# or in a pipeline:
@list |> map is_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-monotonic">
<h3><a class="doc-anchor" href="#doc-is-monotonic">#</a> <code>is_monotonic</code></h3>
<p><code>is_monotonic</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_monotonic $x
# or in a pipeline:
@list |> map is_monotonic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-multiple-of">
<h3><a class="doc-anchor" href="#doc-is-multiple-of">#</a> <code>is_multiple_of</code></h3>
<p><code>is_multiple_of</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_multiple_of $x
# or in a pipeline:
@list |> map is_multiple_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-nan">
<h3><a class="doc-anchor" href="#doc-is-nan">#</a> <code>is_nan</code></h3>
<p><code>is_nan</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_nan $x
# or in a pipeline:
@list |> map is_nan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-narcissistic">
<h3><a class="doc-anchor" href="#doc-is-narcissistic">#</a> <code>is_narcissistic</code></h3>
<p><code>is_narcissistic</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_narcissistic $x
# or in a pipeline:
@list |> map is_narcissistic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-negative">
<h3><a class="doc-anchor" href="#doc-is-negative">#</a> <code>is_negative</code></h3>
<p><code>is_negative</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_negative $x
# or in a pipeline:
@list |> map is_negative |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-negative-num">
<h3><a class="doc-anchor" href="#doc-is-negative-num">#</a> <code>is_negative_num</code></h3>
<p><code>is_negative_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_negative_num $x
# or in a pipeline:
@list |> map is_negative_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-nil">
<h3><a class="doc-anchor" href="#doc-is-nil">#</a> <code>is_nil</code></h3>
<p><code>is_nil</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_nil $x
# or in a pipeline:
@list |> map is_nil |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-nonzero">
<h3><a class="doc-anchor" href="#doc-is-nonzero">#</a> <code>is_nonzero</code></h3>
<p><code>is_nonzero</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_nonzero $x
# or in a pipeline:
@list |> map is_nonzero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-numeric">
<h3><a class="doc-anchor" href="#doc-is-numeric">#</a> <code>is_numeric</code></h3>
<p><code>is_numeric</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_numeric $x
# or in a pipeline:
@list |> map is_numeric |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-numeric-string">
<h3><a class="doc-anchor" href="#doc-is-numeric-string">#</a> <code>is_numeric_string</code></h3>
<p><code>is_numeric_string</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_numeric_string $x
# or in a pipeline:
@list |> map is_numeric_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-octal-str">
<h3><a class="doc-anchor" href="#doc-is-octal-str">#</a> <code>is_octal_str</code></h3>
<p><code>is_octal_str</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_octal_str $x
# or in a pipeline:
@list |> map is_octal_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-odd">
<h3><a class="doc-anchor" href="#doc-is-odd">#</a> <code>is_odd</code></h3>
<p><code>is_odd</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_odd $x
# or in a pipeline:
@list |> map is_odd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-odd-num">
<h3><a class="doc-anchor" href="#doc-is-odd-num">#</a> <code>is_odd_num</code></h3>
<p><code>is_odd_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_odd_num $x
# or in a pipeline:
@list |> map is_odd_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-pair">
<h3><a class="doc-anchor" href="#doc-is-pair">#</a> <code>is_pair</code></h3>
<p><code>is_pair</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_pair $x
# or in a pipeline:
@list |> map is_pair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-palindrome">
<h3><a class="doc-anchor" href="#doc-is-palindrome">#</a> <code>is_palindrome</code></h3>
<p><code>is_palindrome</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_palindrome $x
# or in a pipeline:
@list |> map is_palindrome |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-pangram">
<h3><a class="doc-anchor" href="#doc-is-pangram">#</a> <code>is_pangram</code></h3>
<p><code>is_pangram</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_pangram $x
# or in a pipeline:
@list |> map is_pangram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-pentagonal">
<h3><a class="doc-anchor" href="#doc-is-pentagonal">#</a> <code>is_pentagonal</code></h3>
<p><code>is_pentagonal</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_pentagonal $x
# or in a pipeline:
@list |> map is_pentagonal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-perfect">
<h3><a class="doc-anchor" href="#doc-is-perfect">#</a> <code>is_perfect</code></h3>
<p><code>is_perfect</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_perfect $x
# or in a pipeline:
@list |> map is_perfect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-perfect-square">
<h3><a class="doc-anchor" href="#doc-is-perfect-square">#</a> <code>is_perfect_square</code></h3>
<p><code>is_perfect_square</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_perfect_square $x
# or in a pipeline:
@list |> map is_perfect_square |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-permutation">
<h3><a class="doc-anchor" href="#doc-is-permutation">#</a> <code>is_permutation</code></h3>
<p><code>is_permutation</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_permutation $x
# or in a pipeline:
@list |> map is_permutation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-phone-num">
<h3><a class="doc-anchor" href="#doc-is-phone-num">#</a> <code>is_phone_num</code></h3>
<p><code>is_phone_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_phone_num $x
# or in a pipeline:
@list |> map is_phone_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-port-num">
<h3><a class="doc-anchor" href="#doc-is-port-num">#</a> <code>is_port_num</code></h3>
<p><code>is_port_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_port_num $x
# or in a pipeline:
@list |> map is_port_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-positive">
<h3><a class="doc-anchor" href="#doc-is-positive">#</a> <code>is_positive</code></h3>
<p><code>is_positive</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_positive $x
# or in a pipeline:
@list |> map is_positive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-positive-num">
<h3><a class="doc-anchor" href="#doc-is-positive-num">#</a> <code>is_positive_num</code></h3>
<p><code>is_positive_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_positive_num $x
# or in a pipeline:
@list |> map is_positive_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-pow2">
<h3><a class="doc-anchor" href="#doc-is-pow2">#</a> <code>is_pow2</code></h3>
<p><code>is_pow2</code> — trivial numeric / predicate builtins builtin. Alias for <code>is_power_of_two</code>.</p>
<pre><code class="lang-perl">my $result = is_pow2 $x
# or in a pipeline:
@list |> map is_pow2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-power-of">
<h3><a class="doc-anchor" href="#doc-is-power-of">#</a> <code>is_power_of</code></h3>
<p><code>is_power_of</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_power_of $x
# or in a pipeline:
@list |> map is_power_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-power-of-two">
<h3><a class="doc-anchor" href="#doc-is-power-of-two">#</a> <code>is_power_of_two</code></h3>
<p><code>is_power_of_two</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = is_power_of_two $x
# or in a pipeline:
@list |> map is_power_of_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-prefix">
<h3><a class="doc-anchor" href="#doc-is-prefix">#</a> <code>is_prefix</code></h3>
<p><code>is_prefix</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_prefix $x
# or in a pipeline:
@list |> map is_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-present">
<h3><a class="doc-anchor" href="#doc-is-present">#</a> <code>is_present</code></h3>
<p><code>is_present</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_present $x
# or in a pipeline:
@list |> map is_present |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-prime">
<h3><a class="doc-anchor" href="#doc-is-prime">#</a> <code>is_prime</code></h3>
<p><code>is_prime</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = is_prime $x
# or in a pipeline:
@list |> map is_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-printable">
<h3><a class="doc-anchor" href="#doc-is-printable">#</a> <code>is_printable</code></h3>
<p><code>is_printable</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_printable $x
# or in a pipeline:
@list |> map is_printable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-probable-prime">
<h3><a class="doc-anchor" href="#doc-is-probable-prime">#</a> <code>is_probable_prime</code></h3>
<p><code>miller_rabin</code> (aliases <code>millerrabin</code>, <code>is_probable_prime</code>) performs a probabilistic primality test with k rounds (default 20).</p>
<pre><code class="lang-perl">p millerrabin(104729) # 1 (prime)
p millerrabin(104730) # 0 (composite)
</code></pre>
</article>
<article class="doc-entry" id="doc-is-readable">
<h3><a class="doc-anchor" href="#doc-is-readable">#</a> <code>is_readable</code></h3>
<p><code>is_readable</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_readable $x
# or in a pipeline:
@list |> map is_readable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ref">
<h3><a class="doc-anchor" href="#doc-is-ref">#</a> <code>is_ref</code></h3>
<p><code>is_ref</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_ref $x
# or in a pipeline:
@list |> map is_ref |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-regex-valid">
<h3><a class="doc-anchor" href="#doc-is-regex-valid">#</a> <code>is_regex_valid</code></h3>
<p><code>is_regex_valid</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = is_regex_valid $x
# or in a pipeline:
@list |> map is_regex_valid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-root">
<h3><a class="doc-anchor" href="#doc-is-root">#</a> <code>is_root</code></h3>
<p><code>is_root</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = is_root $x
# or in a pipeline:
@list |> map is_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-semver">
<h3><a class="doc-anchor" href="#doc-is-semver">#</a> <code>is_semver</code></h3>
<p><code>is_semver</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_semver $x
# or in a pipeline:
@list |> map is_semver |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-slug">
<h3><a class="doc-anchor" href="#doc-is-slug">#</a> <code>is_slug</code></h3>
<p><code>is_slug</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_slug $x
# or in a pipeline:
@list |> map is_slug |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-smith">
<h3><a class="doc-anchor" href="#doc-is-smith">#</a> <code>is_smith</code></h3>
<p><code>is_smith</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_smith $x
# or in a pipeline:
@list |> map is_smith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-sorted">
<h3><a class="doc-anchor" href="#doc-is-sorted">#</a> <code>is_sorted</code></h3>
<p><code>is_sorted</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_sorted $x
# or in a pipeline:
@list |> map is_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-sorted-by">
<h3><a class="doc-anchor" href="#doc-is-sorted-by">#</a> <code>is_sorted_by</code></h3>
<p><code>is_sorted_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = is_sorted_by $x
# or in a pipeline:
@list |> map is_sorted_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-sorted-desc">
<h3><a class="doc-anchor" href="#doc-is-sorted-desc">#</a> <code>is_sorted_desc</code></h3>
<p><code>is_sorted_desc</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_sorted_desc $x
# or in a pipeline:
@list |> map is_sorted_desc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-space">
<h3><a class="doc-anchor" href="#doc-is-space">#</a> <code>is_space</code></h3>
<p><code>is_space</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_space $x
# or in a pipeline:
@list |> map is_space |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-sphenic">
<h3><a class="doc-anchor" href="#doc-is-sphenic">#</a> <code>is_sphenic</code></h3>
<p><code>is_sphenic</code> — batch 10 builtin. Alias for <code>sphenic_q</code>.</p>
<pre><code class="lang-perl">my $result = is_sphenic $x
# or in a pipeline:
@list |> map is_sphenic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-square">
<h3><a class="doc-anchor" href="#doc-is-square">#</a> <code>is_square</code></h3>
<p><code>is_square</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = is_square $x
# or in a pipeline:
@list |> map is_square |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-squarefree">
<h3><a class="doc-anchor" href="#doc-is-squarefree">#</a> <code>is_squarefree</code></h3>
<p><code>is_squarefree</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_squarefree $x
# or in a pipeline:
@list |> map is_squarefree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-str">
<h3><a class="doc-anchor" href="#doc-is-str">#</a> <code>is_str</code></h3>
<p><code>is_str</code> — trivial type predicates builtin. Alias for <code>is_string</code>.</p>
<pre><code class="lang-perl">my $result = is_str $x
# or in a pipeline:
@list |> map is_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-strictly-decreasing">
<h3><a class="doc-anchor" href="#doc-is-strictly-decreasing">#</a> <code>is_strictly_decreasing</code></h3>
<p><code>is_strictly_decreasing</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_strictly_decreasing $x
# or in a pipeline:
@list |> map is_strictly_decreasing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-strictly-increasing">
<h3><a class="doc-anchor" href="#doc-is-strictly-increasing">#</a> <code>is_strictly_increasing</code></h3>
<p><code>is_strictly_increasing</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_strictly_increasing $x
# or in a pipeline:
@list |> map is_strictly_increasing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-string">
<h3><a class="doc-anchor" href="#doc-is-string">#</a> <code>is_string</code></h3>
<p><code>is_string</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_string $x
# or in a pipeline:
@list |> map is_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-subset">
<h3><a class="doc-anchor" href="#doc-is-subset">#</a> <code>is_subset</code></h3>
<p><code>is_subset</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_subset $x
# or in a pipeline:
@list |> map is_subset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-suffix">
<h3><a class="doc-anchor" href="#doc-is-suffix">#</a> <code>is_suffix</code></h3>
<p><code>is_suffix</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_suffix $x
# or in a pipeline:
@list |> map is_suffix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-superset">
<h3><a class="doc-anchor" href="#doc-is-superset">#</a> <code>is_superset</code></h3>
<p><code>is_superset</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_superset $x
# or in a pipeline:
@list |> map is_superset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-symlink">
<h3><a class="doc-anchor" href="#doc-is-symlink">#</a> <code>is_symlink</code></h3>
<p><code>is_symlink</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_symlink $x
# or in a pipeline:
@list |> map is_symlink |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-tree">
<h3><a class="doc-anchor" href="#doc-is-tree">#</a> <code>is_tree</code></h3>
<p><code>is_tree</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = is_tree $x
# or in a pipeline:
@list |> map is_tree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-triangular">
<h3><a class="doc-anchor" href="#doc-is-triangular">#</a> <code>is_triangular</code></h3>
<p><code>is_triangular</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_triangular $x
# or in a pipeline:
@list |> map is_triangular |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-triple">
<h3><a class="doc-anchor" href="#doc-is-triple">#</a> <code>is_triple</code></h3>
<p><code>is_triple</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_triple $x
# or in a pipeline:
@list |> map is_triple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-truthy">
<h3><a class="doc-anchor" href="#doc-is-truthy">#</a> <code>is_truthy</code></h3>
<p><code>is_truthy</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_truthy $x
# or in a pipeline:
@list |> map is_truthy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-tty">
<h3><a class="doc-anchor" href="#doc-is-tty">#</a> <code>is_tty</code></h3>
<p><code>is_tty</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = is_tty $x
# or in a pipeline:
@list |> map is_tty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-undef">
<h3><a class="doc-anchor" href="#doc-is-undef">#</a> <code>is_undef</code></h3>
<p><code>is_undef</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_undef $x
# or in a pipeline:
@list |> map is_undef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-upper">
<h3><a class="doc-anchor" href="#doc-is-upper">#</a> <code>is_upper</code></h3>
<p><code>is_upper</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_upper $x
# or in a pipeline:
@list |> map is_upper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-url">
<h3><a class="doc-anchor" href="#doc-is-url">#</a> <code>is_url</code></h3>
<p><code>is_url</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_url $x
# or in a pipeline:
@list |> map is_url |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-us-zip">
<h3><a class="doc-anchor" href="#doc-is-us-zip">#</a> <code>is_us_zip</code></h3>
<p><code>is_us_zip</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_us_zip $x
# or in a pipeline:
@list |> map is_us_zip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-uuid">
<h3><a class="doc-anchor" href="#doc-is-uuid">#</a> <code>is_uuid</code></h3>
<p><code>is_uuid</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = is_uuid $x
# or in a pipeline:
@list |> map is_uuid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-cidr">
<h3><a class="doc-anchor" href="#doc-is-valid-cidr">#</a> <code>is_valid_cidr</code></h3>
<p><code>is_valid_cidr</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_cidr $x
# or in a pipeline:
@list |> map is_valid_cidr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-cron">
<h3><a class="doc-anchor" href="#doc-is-valid-cron">#</a> <code>is_valid_cron</code></h3>
<p><code>is_valid_cron</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_cron $x
# or in a pipeline:
@list |> map is_valid_cron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-date">
<h3><a class="doc-anchor" href="#doc-is-valid-date">#</a> <code>is_valid_date</code></h3>
<p><code>is_valid_date</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_date $x
# or in a pipeline:
@list |> map is_valid_date |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-email">
<h3><a class="doc-anchor" href="#doc-is-valid-email">#</a> <code>is_valid_email</code></h3>
<p><code>is_valid_email</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_email $x
# or in a pipeline:
@list |> map is_valid_email |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-hex">
<h3><a class="doc-anchor" href="#doc-is-valid-hex">#</a> <code>is_valid_hex</code></h3>
<p><code>is_valid_hex</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_hex $x
# or in a pipeline:
@list |> map is_valid_hex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-hex-color">
<h3><a class="doc-anchor" href="#doc-is-valid-hex-color">#</a> <code>is_valid_hex_color</code></h3>
<p><code>is_valid_hex_color</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_hex_color $x
# or in a pipeline:
@list |> map is_valid_hex_color |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-ipv4">
<h3><a class="doc-anchor" href="#doc-is-valid-ipv4">#</a> <code>is_valid_ipv4</code></h3>
<p><code>is_valid_ipv4</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_ipv4 $x
# or in a pipeline:
@list |> map is_valid_ipv4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-ipv6">
<h3><a class="doc-anchor" href="#doc-is-valid-ipv6">#</a> <code>is_valid_ipv6</code></h3>
<p><code>is_valid_ipv6</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_ipv6 $x
# or in a pipeline:
@list |> map is_valid_ipv6 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-latitude">
<h3><a class="doc-anchor" href="#doc-is-valid-latitude">#</a> <code>is_valid_latitude</code></h3>
<p><code>is_valid_latitude</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_latitude $x
# or in a pipeline:
@list |> map is_valid_latitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-longitude">
<h3><a class="doc-anchor" href="#doc-is-valid-longitude">#</a> <code>is_valid_longitude</code></h3>
<p><code>is_valid_longitude</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_longitude $x
# or in a pipeline:
@list |> map is_valid_longitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-mime">
<h3><a class="doc-anchor" href="#doc-is-valid-mime">#</a> <code>is_valid_mime</code></h3>
<p><code>is_valid_mime</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_mime $x
# or in a pipeline:
@list |> map is_valid_mime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-url">
<h3><a class="doc-anchor" href="#doc-is-valid-url">#</a> <code>is_valid_url</code></h3>
<p><code>is_valid_url</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_url $x
# or in a pipeline:
@list |> map is_valid_url |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-vowel">
<h3><a class="doc-anchor" href="#doc-is-vowel">#</a> <code>is_vowel</code></h3>
<p><code>is_vowel</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_vowel $x
# or in a pipeline:
@list |> map is_vowel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-weekday">
<h3><a class="doc-anchor" href="#doc-is-weekday">#</a> <code>is_weekday</code></h3>
<p><code>is_weekday</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_weekday $x
# or in a pipeline:
@list |> map is_weekday |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-weekend">
<h3><a class="doc-anchor" href="#doc-is-weekend">#</a> <code>is_weekend</code></h3>
<p><code>is_weekend</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_weekend $x
# or in a pipeline:
@list |> map is_weekend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-whitespace">
<h3><a class="doc-anchor" href="#doc-is-whitespace">#</a> <code>is_whitespace</code></h3>
<p><code>is_whitespace</code> — trivial string ops builtin. Alias for <code>is_space</code>.</p>
<pre><code class="lang-perl">my $result = is_whitespace $x
# or in a pipeline:
@list |> map is_whitespace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-whole">
<h3><a class="doc-anchor" href="#doc-is-whole">#</a> <code>is_whole</code></h3>
<p><code>is_whole</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_whole $x
# or in a pipeline:
@list |> map is_whole |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-whole-num">
<h3><a class="doc-anchor" href="#doc-is-whole-num">#</a> <code>is_whole_num</code></h3>
<p><code>is_whole_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_whole_num $x
# or in a pipeline:
@list |> map is_whole_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-writable">
<h3><a class="doc-anchor" href="#doc-is-writable">#</a> <code>is_writable</code></h3>
<p><code>is_writable</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_writable $x
# or in a pipeline:
@list |> map is_writable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-zero">
<h3><a class="doc-anchor" href="#doc-is-zero">#</a> <code>is_zero</code></h3>
<p><code>is_zero</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_zero $x
# or in a pipeline:
@list |> map is_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-zero-num">
<h3><a class="doc-anchor" href="#doc-is-zero-num">#</a> <code>is_zero_num</code></h3>
<p><code>is_zero_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_zero_num $x
# or in a pipeline:
@list |> map is_zero_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isabun">
<h3><a class="doc-anchor" href="#doc-isabun">#</a> <code>isabun</code></h3>
<p><code>isabun</code> — number theory / primes builtin. Alias for <code>is_abundant</code>.</p>
<pre><code class="lang-perl">my $result = isabun $x
# or in a pipeline:
@list |> map isabun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isanag">
<h3><a class="doc-anchor" href="#doc-isanag">#</a> <code>isanag</code></h3>
<p><code>isanag</code> — dsp / signal (extended) builtin. Alias for <code>is_anagram</code>.</p>
<pre><code class="lang-perl">my $result = isanag $x
# or in a pipeline:
@list |> map isanag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isasc">
<h3><a class="doc-anchor" href="#doc-isasc">#</a> <code>isasc</code></h3>
<p><code>isasc</code> — extended stdlib builtin. Alias for <code>is_ascii</code>.</p>
<pre><code class="lang-perl">my $result = isasc $x
# or in a pipeline:
@list |> map isasc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isb64">
<h3><a class="doc-anchor" href="#doc-isb64">#</a> <code>isb64</code></h3>
<p><code>isb64</code> — extended stdlib builtin. Alias for <code>is_base64</code>.</p>
<pre><code class="lang-perl">my $result = isb64 $x
# or in a pipeline:
@list |> map isb64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbalp">
<h3><a class="doc-anchor" href="#doc-isbalp">#</a> <code>isbalp</code></h3>
<p><code>isbalp</code> — dsp / signal (extended) builtin. Alias for <code>is_balanced_parens</code>.</p>
<pre><code class="lang-perl">my $result = isbalp $x
# or in a pipeline:
@list |> map isbalp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbin">
<h3><a class="doc-anchor" href="#doc-isbin">#</a> <code>isbin</code></h3>
<p><code>isbin</code> — extended stdlib builtin. Alias for <code>is_binary_str</code>.</p>
<pre><code class="lang-perl">my $result = isbin $x
# or in a pipeline:
@list |> map isbin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbip">
<h3><a class="doc-anchor" href="#doc-isbip">#</a> <code>isbip</code></h3>
<p><code>isbip</code> — extended stdlib builtin. Alias for <code>is_bipartite_graph</code>.</p>
<pre><code class="lang-perl">my $result = isbip $x
# or in a pipeline:
@list |> map isbip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbn10">
<h3><a class="doc-anchor" href="#doc-isbn10">#</a> <code>isbn10</code></h3>
<p><code>isbn10</code> — extended stdlib builtin. Alias for <code>is_isbn10</code>.</p>
<pre><code class="lang-perl">my $result = isbn10 $x
# or in a pipeline:
@list |> map isbn10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbn10-check">
<h3><a class="doc-anchor" href="#doc-isbn10-check">#</a> <code>isbn10_check</code></h3>
<p><code>isbn10_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = isbn10_check $x
# or in a pipeline:
@list |> map isbn10_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbn13">
<h3><a class="doc-anchor" href="#doc-isbn13">#</a> <code>isbn13</code></h3>
<p><code>isbn13</code> — extended stdlib builtin. Alias for <code>is_isbn13</code>.</p>
<pre><code class="lang-perl">my $result = isbn13 $x
# or in a pipeline:
@list |> map isbn13 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbn13-check">
<h3><a class="doc-anchor" href="#doc-isbn13-check">#</a> <code>isbn13_check</code></h3>
<p><code>isbn13_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = isbn13_check $x
# or in a pipeline:
@list |> map isbn13_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iscc">
<h3><a class="doc-anchor" href="#doc-iscc">#</a> <code>iscc</code></h3>
<p><code>iscc</code> — extended stdlib builtin. Alias for <code>is_credit_card</code>.</p>
<pre><code class="lang-perl">my $result = iscc $x
# or in a pipeline:
@list |> map iscc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iscidr">
<h3><a class="doc-anchor" href="#doc-iscidr">#</a> <code>iscidr</code></h3>
<p><code>iscidr</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_cidr</code>.</p>
<pre><code class="lang-perl">my $result = iscidr $x
# or in a pipeline:
@list |> map iscidr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isco-radius-kerr-step">
<h3><a class="doc-anchor" href="#doc-isco-radius-kerr-step">#</a> <code>isco_radius_kerr_step</code></h3>
<p><code>isco_radius_kerr_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = isco_radius_kerr_step $x
# or in a pipeline:
@list |> map isco_radius_kerr_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iscopr">
<h3><a class="doc-anchor" href="#doc-iscopr">#</a> <code>iscopr</code></h3>
<p><code>iscopr</code> — extended stdlib batch 3 builtin. Alias for <code>is_coprime</code>.</p>
<pre><code class="lang-perl">my $result = iscopr $x
# or in a pipeline:
@list |> map iscopr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iscron">
<h3><a class="doc-anchor" href="#doc-iscron">#</a> <code>iscron</code></h3>
<p><code>iscron</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_cron</code>.</p>
<pre><code class="lang-perl">my $result = iscron $x
# or in a pipeline:
@list |> map iscron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isctrl">
<h3><a class="doc-anchor" href="#doc-isctrl">#</a> <code>isctrl</code></h3>
<p><code>isctrl</code> — dsp / signal (extended) builtin. Alias for <code>is_control</code>.</p>
<pre><code class="lang-perl">my $result = isctrl $x
# or in a pipeline:
@list |> map isctrl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isdefi">
<h3><a class="doc-anchor" href="#doc-isdefi">#</a> <code>isdefi</code></h3>
<p><code>isdefi</code> — number theory / primes builtin. Alias for <code>is_deficient</code>.</p>
<pre><code class="lang-perl">my $result = isdefi $x
# or in a pipeline:
@list |> map isdefi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iseven">
<h3><a class="doc-anchor" href="#doc-iseven">#</a> <code>iseven</code></h3>
<p><code>iseven</code> — extended stdlib builtin. Alias for <code>is_even_num</code>.</p>
<pre><code class="lang-perl">my $result = iseven $x
# or in a pipeline:
@list |> map iseven |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isharsh">
<h3><a class="doc-anchor" href="#doc-isharsh">#</a> <code>isharsh</code></h3>
<p><code>isharsh</code> — extended stdlib batch 3 builtin. Alias for <code>is_harshad</code>.</p>
<pre><code class="lang-perl">my $result = isharsh $x
# or in a pipeline:
@list |> map isharsh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ishet">
<h3><a class="doc-anchor" href="#doc-ishet">#</a> <code>ishet</code></h3>
<p><code>ishet</code> — extended stdlib batch 3 builtin. Alias for <code>is_heterogram</code>.</p>
<pre><code class="lang-perl">my $result = ishet $x
# or in a pipeline:
@list |> map ishet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ishex">
<h3><a class="doc-anchor" href="#doc-ishex">#</a> <code>ishex</code></h3>
<p><code>ishex</code> — extended stdlib builtin. Alias for <code>is_hex_str</code>.</p>
<pre><code class="lang-perl">my $result = ishex $x
# or in a pipeline:
@list |> map ishex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ishexc">
<h3><a class="doc-anchor" href="#doc-ishexc">#</a> <code>ishexc</code></h3>
<p><code>ishexc</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_hex_color</code>.</p>
<pre><code class="lang-perl">my $result = ishexc $x
# or in a pipeline:
@list |> map ishexc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ishost">
<h3><a class="doc-anchor" href="#doc-ishost">#</a> <code>ishost</code></h3>
<p><code>ishost</code> — extended stdlib builtin. Alias for <code>is_hostname_valid</code>.</p>
<pre><code class="lang-perl">my $result = ishost $x
# or in a pipeline:
@list |> map ishost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isiban">
<h3><a class="doc-anchor" href="#doc-isiban">#</a> <code>isiban</code></h3>
<p><code>isiban</code> — extended stdlib builtin. Alias for <code>is_iban</code>.</p>
<pre><code class="lang-perl">my $result = isiban $x
# or in a pipeline:
@list |> map isiban |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isip4">
<h3><a class="doc-anchor" href="#doc-isip4">#</a> <code>isip4</code></h3>
<p><code>isip4</code> — extended stdlib builtin. Alias for <code>is_ipv4_addr</code>.</p>
<pre><code class="lang-perl">my $result = isip4 $x
# or in a pipeline:
@list |> map isip4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isip6">
<h3><a class="doc-anchor" href="#doc-isip6">#</a> <code>isip6</code></h3>
<p><code>isip6</code> — extended stdlib builtin. Alias for <code>is_ipv6_addr</code>.</p>
<pre><code class="lang-perl">my $result = isip6 $x
# or in a pipeline:
@list |> map isip6 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isiso">
<h3><a class="doc-anchor" href="#doc-isiso">#</a> <code>isiso</code></h3>
<p><code>isiso</code> — extended stdlib batch 3 builtin. Alias for <code>is_isogram</code>.</p>
<pre><code class="lang-perl">my $result = isiso $x
# or in a pipeline:
@list |> map isiso |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isisodt">
<h3><a class="doc-anchor" href="#doc-isisodt">#</a> <code>isisodt</code></h3>
<p><code>isisodt</code> — extended stdlib builtin. Alias for <code>is_iso_date</code>.</p>
<pre><code class="lang-perl">my $result = isisodt $x
# or in a pipeline:
@list |> map isisodt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isisodtm">
<h3><a class="doc-anchor" href="#doc-isisodtm">#</a> <code>isisodtm</code></h3>
<p><code>isisodtm</code> — extended stdlib builtin. Alias for <code>is_iso_datetime</code>.</p>
<pre><code class="lang-perl">my $result = isisodtm $x
# or in a pipeline:
@list |> map isisodtm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isisotm">
<h3><a class="doc-anchor" href="#doc-isisotm">#</a> <code>isisotm</code></h3>
<p><code>isisotm</code> — extended stdlib builtin. Alias for <code>is_iso_time</code>.</p>
<pre><code class="lang-perl">my $result = isisotm $x
# or in a pipeline:
@list |> map isisotm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isjson">
<h3><a class="doc-anchor" href="#doc-isjson">#</a> <code>isjson</code></h3>
<p><code>isjson</code> — extended stdlib builtin. Alias for <code>is_json</code>.</p>
<pre><code class="lang-perl">my $result = isjson $x
# or in a pipeline:
@list |> map isjson |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iskap">
<h3><a class="doc-anchor" href="#doc-iskap">#</a> <code>iskap</code></h3>
<p><code>iskap</code> — extended stdlib batch 3 builtin. Alias for <code>is_kaprekar</code>.</p>
<pre><code class="lang-perl">my $result = iskap $x
# or in a pipeline:
@list |> map iskap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isl">
<h3><a class="doc-anchor" href="#doc-isl">#</a> <code>isl</code></h3>
<p><code>isl</code> — python/ruby stdlib builtin. Alias for <code>islice</code>.</p>
<pre><code class="lang-perl">my $result = isl $x
# or in a pipeline:
@list |> map isl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-islamic-leap-year">
<h3><a class="doc-anchor" href="#doc-islamic-leap-year">#</a> <code>islamic_leap_year</code></h3>
<p><code>islamic_leap_year</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = islamic_leap_year $x
# or in a pipeline:
@list |> map islamic_leap_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-island-equilibrium">
<h3><a class="doc-anchor" href="#doc-island-equilibrium">#</a> <code>island_equilibrium</code></h3>
<p><code>island_equilibrium</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = island_equilibrium $x
# or in a pipeline:
@list |> map island_equilibrium |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-islat">
<h3><a class="doc-anchor" href="#doc-islat">#</a> <code>islat</code></h3>
<p><code>islat</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_latitude</code>.</p>
<pre><code class="lang-perl">my $result = islat $x
# or in a pipeline:
@list |> map islat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-islice">
<h3><a class="doc-anchor" href="#doc-islice">#</a> <code>islice</code></h3>
<p><code>islice</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = islice $x
# or in a pipeline:
@list |> map islice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-islon">
<h3><a class="doc-anchor" href="#doc-islon">#</a> <code>islon</code></h3>
<p><code>islon</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_longitude</code>.</p>
<pre><code class="lang-perl">my $result = islon $x
# or in a pipeline:
@list |> map islon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ism">
<h3><a class="doc-anchor" href="#doc-ism">#</a> <code>ism</code></h3>
<p><code>ism</code> — extended stdlib builtin. Alias for <code>is_match</code>.</p>
<pre><code class="lang-perl">my $result = ism $x
# or in a pipeline:
@list |> map ism |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ismac">
<h3><a class="doc-anchor" href="#doc-ismac">#</a> <code>ismac</code></h3>
<p><code>ismac</code> — extended stdlib builtin. Alias for <code>is_mac_addr</code>.</p>
<pre><code class="lang-perl">my $result = ismac $x
# or in a pipeline:
@list |> map ismac |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ismime">
<h3><a class="doc-anchor" href="#doc-ismime">#</a> <code>ismime</code></h3>
<p><code>ismime</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_mime</code>.</p>
<pre><code class="lang-perl">my $result = ismime $x
# or in a pipeline:
@list |> map ismime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ismono">
<h3><a class="doc-anchor" href="#doc-ismono">#</a> <code>ismono</code></h3>
<p><code>ismono</code> — extended stdlib batch 3 builtin. Alias for <code>is_monotonic</code>.</p>
<pre><code class="lang-perl">my $result = ismono $x
# or in a pipeline:
@list |> map ismono |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isnarc">
<h3><a class="doc-anchor" href="#doc-isnarc">#</a> <code>isnarc</code></h3>
<p><code>isnarc</code> — extended stdlib batch 3 builtin. Alias for <code>is_narcissistic</code>.</p>
<pre><code class="lang-perl">my $result = isnarc $x
# or in a pipeline:
@list |> map isnarc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isneg">
<h3><a class="doc-anchor" href="#doc-isneg">#</a> <code>isneg</code></h3>
<p><code>isneg</code> — extended stdlib builtin. Alias for <code>is_negative_num</code>.</p>
<pre><code class="lang-perl">my $result = isneg $x
# or in a pipeline:
@list |> map isneg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isnumstr">
<h3><a class="doc-anchor" href="#doc-isnumstr">#</a> <code>isnumstr</code></h3>
<p><code>isnumstr</code> — dsp / signal (extended) builtin. Alias for <code>is_numeric_string</code>.</p>
<pre><code class="lang-perl">my $result = isnumstr $x
# or in a pipeline:
@list |> map isnumstr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iso226-phon-adjustment">
<h3><a class="doc-anchor" href="#doc-iso226-phon-adjustment">#</a> <code>iso226_phon_adjustment</code></h3>
<p><code>iso226_phon_adjustment</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = iso226_phon_adjustment $x
# or in a pipeline:
@list |> map iso226_phon_adjustment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iso8601-duration-parse">
<h3><a class="doc-anchor" href="#doc-iso8601-duration-parse">#</a> <code>iso8601_duration_parse</code></h3>
<p><code>iso8601_duration_parse</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = iso8601_duration_parse $x
# or in a pipeline:
@list |> map iso8601_duration_parse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iso8601-duration-to-seconds">
<h3><a class="doc-anchor" href="#doc-iso8601-duration-to-seconds">#</a> <code>iso8601_duration_to_seconds</code></h3>
<p><code>iso8601_duration_to_seconds</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = iso8601_duration_to_seconds $input
</code></pre>
</article>
<article class="doc-entry" id="doc-iso-day-number">
<h3><a class="doc-anchor" href="#doc-iso-day-number">#</a> <code>iso_day_number</code></h3>
<p><code>iso_day_number</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = iso_day_number $x
# or in a pipeline:
@list |> map iso_day_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iso-dow">
<h3><a class="doc-anchor" href="#doc-iso-dow">#</a> <code>iso_dow</code></h3>
<p><code>iso_dow</code> — batch 9 builtin. Alias for <code>day_of_week_iso</code>.</p>
<pre><code class="lang-perl">my $result = iso_dow $x
# or in a pipeline:
@list |> map iso_dow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iso-ordinal-date">
<h3><a class="doc-anchor" href="#doc-iso-ordinal-date">#</a> <code>iso_ordinal_date</code></h3>
<p><code>iso_ordinal_date</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = iso_ordinal_date $x
# or in a pipeline:
@list |> map iso_ordinal_date |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iso-week">
<h3><a class="doc-anchor" href="#doc-iso-week">#</a> <code>iso_week</code></h3>
<p><code>iso_week</code> — batch 9 builtin. Alias for <code>iso_week_number</code>.</p>
<pre><code class="lang-perl">my $result = iso_week $x
# or in a pipeline:
@list |> map iso_week |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iso-week-date">
<h3><a class="doc-anchor" href="#doc-iso-week-date">#</a> <code>iso_week_date</code></h3>
<p><code>iso_week_date</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = iso_week_date $x
# or in a pipeline:
@list |> map iso_week_date |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iso-week-number">
<h3><a class="doc-anchor" href="#doc-iso-week-number">#</a> <code>iso_week_number</code></h3>
<p><code>iso_week_number</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = iso_week_number $x
# or in a pipeline:
@list |> map iso_week_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isoct">
<h3><a class="doc-anchor" href="#doc-isoct">#</a> <code>isoct</code></h3>
<p><code>isoct</code> — extended stdlib builtin. Alias for <code>is_octal_str</code>.</p>
<pre><code class="lang-perl">my $result = isoct $x
# or in a pipeline:
@list |> map isoct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isodd">
<h3><a class="doc-anchor" href="#doc-isodd">#</a> <code>isodd</code></h3>
<p><code>isodd</code> — extended stdlib builtin. Alias for <code>is_odd_num</code>.</p>
<pre><code class="lang-perl">my $result = isodd $x
# or in a pipeline:
@list |> map isodd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isoelectric-point-protein">
<h3><a class="doc-anchor" href="#doc-isoelectric-point-protein">#</a> <code>isoelectric_point_protein</code></h3>
<p><code>isoelectric_point_protein</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = isoelectric_point_protein $x
# or in a pipeline:
@list |> map isoelectric_point_protein |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isolated-horizon-charge">
<h3><a class="doc-anchor" href="#doc-isolated-horizon-charge">#</a> <code>isolated_horizon_charge</code></h3>
<p><code>isolated_horizon_charge</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = isolated_horizon_charge $x
# or in a pipeline:
@list |> map isolated_horizon_charge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isotropic-relation-check">
<h3><a class="doc-anchor" href="#doc-isotropic-relation-check">#</a> <code>isotropic_relation_check</code></h3>
<p><code>isotropic_relation_check</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = isotropic_relation_check $x
# or in a pipeline:
@list |> map isotropic_relation_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isp">
<h3><a class="doc-anchor" href="#doc-isp">#</a> <code>isp</code></h3>
<p><code>isp</code> — haskell list functions builtin. Alias for <code>intersperse_val</code>.</p>
<pre><code class="lang-perl">my $result = isp $x
# or in a pipeline:
@list |> map isp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ispang">
<h3><a class="doc-anchor" href="#doc-ispang">#</a> <code>ispang</code></h3>
<p><code>ispang</code> — dsp / signal (extended) builtin. Alias for <code>is_pangram</code>.</p>
<pre><code class="lang-perl">my $result = ispang $x
# or in a pipeline:
@list |> map ispang |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ispent">
<h3><a class="doc-anchor" href="#doc-ispent">#</a> <code>ispent</code></h3>
<p><code>ispent</code> — number theory / primes builtin. Alias for <code>is_pentagonal</code>.</p>
<pre><code class="lang-perl">my $result = ispent $x
# or in a pipeline:
@list |> map ispent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isperf">
<h3><a class="doc-anchor" href="#doc-isperf">#</a> <code>isperf</code></h3>
<p><code>isperf</code> — number theory / primes builtin. Alias for <code>is_perfect</code>.</p>
<pre><code class="lang-perl">my $result = isperf $x
# or in a pipeline:
@list |> map isperf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isphone">
<h3><a class="doc-anchor" href="#doc-isphone">#</a> <code>isphone</code></h3>
<p><code>isphone</code> — extended stdlib builtin. Alias for <code>is_phone_num</code>.</p>
<pre><code class="lang-perl">my $result = isphone $x
# or in a pipeline:
@list |> map isphone |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isport">
<h3><a class="doc-anchor" href="#doc-isport">#</a> <code>isport</code></h3>
<p><code>isport</code> — extended stdlib builtin. Alias for <code>is_port_num</code>.</p>
<pre><code class="lang-perl">my $result = isport $x
# or in a pipeline:
@list |> map isport |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ispos">
<h3><a class="doc-anchor" href="#doc-ispos">#</a> <code>ispos</code></h3>
<p><code>ispos</code> — extended stdlib builtin. Alias for <code>is_positive_num</code>.</p>
<pre><code class="lang-perl">my $result = ispos $x
# or in a pipeline:
@list |> map ispos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isprint">
<h3><a class="doc-anchor" href="#doc-isprint">#</a> <code>isprint</code></h3>
<p><code>isprint</code> — dsp / signal (extended) builtin. Alias for <code>is_printable</code>.</p>
<pre><code class="lang-perl">my $result = isprint $x
# or in a pipeline:
@list |> map isprint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ispw">
<h3><a class="doc-anchor" href="#doc-ispw">#</a> <code>ispw</code></h3>
<p><code>ispw</code> — additional missing stdlib functions builtin. Alias for <code>intersperse_with</code>.</p>
<pre><code class="lang-perl">my $result = ispw $x
# or in a pipeline:
@list |> map ispw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isslug">
<h3><a class="doc-anchor" href="#doc-isslug">#</a> <code>isslug</code></h3>
<p><code>isslug</code> — extended stdlib builtin. Alias for <code>is_slug</code>.</p>
<pre><code class="lang-perl">my $result = isslug $x
# or in a pipeline:
@list |> map isslug |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-issmith">
<h3><a class="doc-anchor" href="#doc-issmith">#</a> <code>issmith</code></h3>
<p><code>issmith</code> — number theory / primes builtin. Alias for <code>is_smith</code>.</p>
<pre><code class="lang-perl">my $result = issmith $x
# or in a pipeline:
@list |> map issmith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-issqfr">
<h3><a class="doc-anchor" href="#doc-issqfr">#</a> <code>issqfr</code></h3>
<p><code>issqfr</code> — extended stdlib batch 3 builtin. Alias for <code>is_squarefree</code>.</p>
<pre><code class="lang-perl">my $result = issqfr $x
# or in a pipeline:
@list |> map issqfr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-issrtb">
<h3><a class="doc-anchor" href="#doc-issrtb">#</a> <code>issrtb</code></h3>
<p><code>issrtb</code> — additional missing stdlib functions builtin. Alias for <code>is_sorted_by</code>.</p>
<pre><code class="lang-perl">my $result = issrtb $x
# or in a pipeline:
@list |> map issrtb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-issv">
<h3><a class="doc-anchor" href="#doc-issv">#</a> <code>issv</code></h3>
<p><code>issv</code> — extended stdlib builtin. Alias for <code>is_semver</code>.</p>
<pre><code class="lang-perl">my $result = issv $x
# or in a pipeline:
@list |> map issv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ista-step">
<h3><a class="doc-anchor" href="#doc-ista-step">#</a> <code>ista_step</code></h3>
<p><code>ista_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = ista_step $x
# or in a pipeline:
@list |> map ista_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-istft-step">
<h3><a class="doc-anchor" href="#doc-istft-step">#</a> <code>istft_step</code></h3>
<p><code>istft_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = istft_step $x
# or in a pipeline:
@list |> map istft_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isvdate">
<h3><a class="doc-anchor" href="#doc-isvdate">#</a> <code>isvdate</code></h3>
<p><code>isvdate</code> — extended stdlib batch 3 builtin. Alias for <code>is_valid_date</code>.</p>
<pre><code class="lang-perl">my $result = isvdate $x
# or in a pipeline:
@list |> map isvdate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iswap-gate">
<h3><a class="doc-anchor" href="#doc-iswap-gate">#</a> <code>iswap_gate</code></h3>
<p><code>iswap_gate</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = iswap_gate $x
# or in a pipeline:
@list |> map iswap_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isweak">
<h3><a class="doc-anchor" href="#doc-isweak">#</a> <code>isweak</code></h3>
<p><code>isweak</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = isweak $x
# or in a pipeline:
@list |> map isweak |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iswhole">
<h3><a class="doc-anchor" href="#doc-iswhole">#</a> <code>iswhole</code></h3>
<p><code>iswhole</code> — extended stdlib builtin. Alias for <code>is_whole_num</code>.</p>
<pre><code class="lang-perl">my $result = iswhole $x
# or in a pipeline:
@list |> map iswhole |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iszero">
<h3><a class="doc-anchor" href="#doc-iszero">#</a> <code>iszero</code></h3>
<p><code>iszero</code> — extended stdlib builtin. Alias for <code>is_zero_num</code>.</p>
<pre><code class="lang-perl">my $result = iszero $x
# or in a pipeline:
@list |> map iszero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iszip">
<h3><a class="doc-anchor" href="#doc-iszip">#</a> <code>iszip</code></h3>
<p><code>iszip</code> — extended stdlib builtin. Alias for <code>is_us_zip</code>.</p>
<pre><code class="lang-perl">my $result = iszip $x
# or in a pipeline:
@list |> map iszip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-italic">
<h3><a class="doc-anchor" href="#doc-italic">#</a> <code>italic</code></h3>
<p><code>italic</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = italic $x
# or in a pipeline:
@list |> map italic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-itcz-position-lat">
<h3><a class="doc-anchor" href="#doc-itcz-position-lat">#</a> <code>itcz_position_lat</code></h3>
<p><code>itcz_position_lat</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = itcz_position_lat $x
# or in a pipeline:
@list |> map itcz_position_lat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iter">
<h3><a class="doc-anchor" href="#doc-iter">#</a> <code>iter</code></h3>
<p><code>iter</code> — algebraic match builtin. Alias for <code>iterate</code>.</p>
<pre><code class="lang-perl">my $result = iter $x
# or in a pipeline:
@list |> map iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iterate">
<h3><a class="doc-anchor" href="#doc-iterate">#</a> <code>iterate</code></h3>
<p><code>iterate</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = iterate $x
# or in a pipeline:
@list |> map iterate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iterate-n">
<h3><a class="doc-anchor" href="#doc-iterate-n">#</a> <code>iterate_n</code></h3>
<p><code>iterate_n</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = iterate_n $x
# or in a pipeline:
@list |> map iterate_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iv">
<h3><a class="doc-anchor" href="#doc-iv">#</a> <code>iv</code></h3>
<p><code>iv</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = iv $x
# or in a pipeline:
@list |> map iv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iv-estimator">
<h3><a class="doc-anchor" href="#doc-iv-estimator">#</a> <code>iv_estimator</code></h3>
<p><code>iv_estimator</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = iv_estimator $x
# or in a pipeline:
@list |> map iv_estimator |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jaccard">
<h3><a class="doc-anchor" href="#doc-jaccard">#</a> <code>jaccard</code></h3>
<p><code>jaccard</code> — extended stdlib batch 3 builtin. Alias for <code>jaccard_index</code>.</p>
<pre><code class="lang-perl">my $result = jaccard $x
# or in a pipeline:
@list |> map jaccard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jaccard-index">
<h3><a class="doc-anchor" href="#doc-jaccard-index">#</a> <code>jaccard_index</code></h3>
<p><code>jaccard_index</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = jaccard_index $x
# or in a pipeline:
@list |> map jaccard_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jaccard-similarity">
<h3><a class="doc-anchor" href="#doc-jaccard-similarity">#</a> <code>jaccard_similarity</code></h3>
<p><code>jaccard_similarity</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = jaccard_similarity $x
# or in a pipeline:
@list |> map jaccard_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jacobi-cn-small-q">
<h3><a class="doc-anchor" href="#doc-jacobi-cn-small-q">#</a> <code>jacobi_cn_small_q</code></h3>
<p><code>jacobi_cn_small_q</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = jacobi_cn_small_q $x
# or in a pipeline:
@list |> map jacobi_cn_small_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jacobi-dn-small-q">
<h3><a class="doc-anchor" href="#doc-jacobi-dn-small-q">#</a> <code>jacobi_dn_small_q</code></h3>
<p><code>jacobi_dn_small_q</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = jacobi_dn_small_q $x
# or in a pipeline:
@list |> map jacobi_dn_small_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jacobi-sn-small-q">
<h3><a class="doc-anchor" href="#doc-jacobi-sn-small-q">#</a> <code>jacobi_sn_small_q</code></h3>
<p><code>jacobi_sn_small_q</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = jacobi_sn_small_q $x
# or in a pipeline:
@list |> map jacobi_sn_small_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jacobian-2dof">
<h3><a class="doc-anchor" href="#doc-jacobian-2dof">#</a> <code>jacobian_2dof</code></h3>
<p><code>jacobian_2dof</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = jacobian_2dof $x
# or in a pipeline:
@list |> map jacobian_2dof |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jahn-teller-check">
<h3><a class="doc-anchor" href="#doc-jahn-teller-check">#</a> <code>jahn_teller_check</code></h3>
<p><code>jahn_teller_check</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = jahn_teller_check $x
# or in a pipeline:
@list |> map jahn_teller_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jaro-similarity">
<h3><a class="doc-anchor" href="#doc-jaro-similarity">#</a> <code>jaro_similarity</code></h3>
<p><code>jaro_similarity</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = jaro_similarity $x
# or in a pipeline:
@list |> map jaro_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jarosim">
<h3><a class="doc-anchor" href="#doc-jarosim">#</a> <code>jarosim</code></h3>
<p><code>jarosim</code> — extended stdlib batch 3 builtin. Alias for <code>jaro_similarity</code>.</p>
<pre><code class="lang-perl">my $result = jarosim $x
# or in a pipeline:
@list |> map jarosim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jd">
<h3><a class="doc-anchor" href="#doc-jd">#</a> <code>jd</code></h3>
<p><code>jd</code> — data / network builtin. Alias for <code>json_decode</code>.</p>
<pre><code class="lang-perl">my $result = jd $x
# or in a pipeline:
@list |> map jd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jd-to-calendar">
<h3><a class="doc-anchor" href="#doc-jd-to-calendar">#</a> <code>jd_to_calendar</code></h3>
<p><code>jd_to_calendar</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = jd_to_calendar $input
</code></pre>
</article>
<article class="doc-entry" id="doc-je">
<h3><a class="doc-anchor" href="#doc-je">#</a> <code>je</code></h3>
<p><code>je</code> — data / network builtin. Alias for <code>json_encode</code>.</p>
<pre><code class="lang-perl">my $result = je $x
# or in a pipeline:
@list |> map je |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jeans-length">
<h3><a class="doc-anchor" href="#doc-jeans-length">#</a> <code>jeans_length</code></h3>
<p><code>jeans_length</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = jeans_length $x
# or in a pipeline:
@list |> map jeans_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jenkins-oat">
<h3><a class="doc-anchor" href="#doc-jenkins-oat">#</a> <code>jenkins_oat</code></h3>
<p><code>jenkins_oat</code> — batch 11 builtin. Alias for <code>jenkins_one_at_a_time</code>.</p>
<pre><code class="lang-perl">my $result = jenkins_oat $x
# or in a pipeline:
@list |> map jenkins_oat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jenkins-one-at-a-time">
<h3><a class="doc-anchor" href="#doc-jenkins-one-at-a-time">#</a> <code>jenkins_one_at_a_time</code></h3>
<p><code>jenkins_one_at_a_time</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = jenkins_one_at_a_time $x
# or in a pipeline:
@list |> map jenkins_one_at_a_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jensen-alpha">
<h3><a class="doc-anchor" href="#doc-jensen-alpha">#</a> <code>jensen_alpha</code></h3>
<p><code>jensen_alpha</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = jensen_alpha $x
# or in a pipeline:
@list |> map jensen_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jensen-shannon-div">
<h3><a class="doc-anchor" href="#doc-jensen-shannon-div">#</a> <code>jensen_shannon_div</code></h3>
<p><code>jensen_shannon_div</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = jensen_shannon_div $x
# or in a pipeline:
@list |> map jensen_shannon_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jensens-alpha">
<h3><a class="doc-anchor" href="#doc-jensens-alpha">#</a> <code>jensens_alpha</code></h3>
<p><code>jensens_alpha</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = jensens_alpha $x
# or in a pipeline:
@list |> map jensens_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-job-shop-makespan-lower">
<h3><a class="doc-anchor" href="#doc-job-shop-makespan-lower">#</a> <code>job_shop_makespan_lower</code></h3>
<p><code>job_shop_makespan_lower</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = job_shop_makespan_lower $x
# or in a pipeline:
@list |> map job_shop_makespan_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-johansen-test">
<h3><a class="doc-anchor" href="#doc-johansen-test">#</a> <code>johansen_test</code></h3>
<p><code>johansen_test</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = johansen_test $x
# or in a pipeline:
@list |> map johansen_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-johansen-trace-step">
<h3><a class="doc-anchor" href="#doc-johansen-trace-step">#</a> <code>johansen_trace_step</code></h3>
<p><code>johansen_trace_step</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = johansen_trace_step $x
# or in a pipeline:
@list |> map johansen_trace_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-johnson-2m">
<h3><a class="doc-anchor" href="#doc-johnson-2m">#</a> <code>johnson_2m</code></h3>
<p><code>johnson_2m</code> — batch 10 builtin. Alias for <code>johnsons_rule</code>.</p>
<pre><code class="lang-perl">my $result = johnson_2m $x
# or in a pipeline:
@list |> map johnson_2m |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-johnson-reweight">
<h3><a class="doc-anchor" href="#doc-johnson-reweight">#</a> <code>johnson_reweight</code></h3>
<p><code>johnson_reweight</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = johnson_reweight $x
# or in a pipeline:
@list |> map johnson_reweight |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-johnsons-rule">
<h3><a class="doc-anchor" href="#doc-johnsons-rule">#</a> <code>johnsons_rule</code></h3>
<p><code>johnsons_rule</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = johnsons_rule $x
# or in a pipeline:
@list |> map johnsons_rule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-colons">
<h3><a class="doc-anchor" href="#doc-join-colons">#</a> <code>join_colons</code></h3>
<p><code>join_colons</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_colons $x
# or in a pipeline:
@list |> map join_colons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-commas">
<h3><a class="doc-anchor" href="#doc-join-commas">#</a> <code>join_commas</code></h3>
<p><code>join_commas</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_commas $x
# or in a pipeline:
@list |> map join_commas |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-dashes">
<h3><a class="doc-anchor" href="#doc-join-dashes">#</a> <code>join_dashes</code></h3>
<p><code>join_dashes</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_dashes $x
# or in a pipeline:
@list |> map join_dashes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-dots">
<h3><a class="doc-anchor" href="#doc-join-dots">#</a> <code>join_dots</code></h3>
<p><code>join_dots</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_dots $x
# or in a pipeline:
@list |> map join_dots |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-lines">
<h3><a class="doc-anchor" href="#doc-join-lines">#</a> <code>join_lines</code></h3>
<p><code>join_lines</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_lines $x
# or in a pipeline:
@list |> map join_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-pipes">
<h3><a class="doc-anchor" href="#doc-join-pipes">#</a> <code>join_pipes</code></h3>
<p><code>join_pipes</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_pipes $x
# or in a pipeline:
@list |> map join_pipes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-slashes">
<h3><a class="doc-anchor" href="#doc-join-slashes">#</a> <code>join_slashes</code></h3>
<p><code>join_slashes</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_slashes $x
# or in a pipeline:
@list |> map join_slashes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-spaces">
<h3><a class="doc-anchor" href="#doc-join-spaces">#</a> <code>join_spaces</code></h3>
<p><code>join_spaces</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_spaces $x
# or in a pipeline:
@list |> map join_spaces |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-tabs">
<h3><a class="doc-anchor" href="#doc-join-tabs">#</a> <code>join_tabs</code></h3>
<p><code>join_tabs</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_tabs $x
# or in a pipeline:
@list |> map join_tabs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-joint-entropy-step">
<h3><a class="doc-anchor" href="#doc-joint-entropy-step">#</a> <code>joint_entropy_step</code></h3>
<p><code>joint_entropy_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = joint_entropy_step $x
# or in a pipeline:
@list |> map joint_entropy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jones-polynomial-at-i">
<h3><a class="doc-anchor" href="#doc-jones-polynomial-at-i">#</a> <code>jones_polynomial_at_i</code></h3>
<p><code>jones_polynomial_at_i</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = jones_polynomial_at_i $x
# or in a pipeline:
@list |> map jones_polynomial_at_i |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jones-polynomial-at-minus-one">
<h3><a class="doc-anchor" href="#doc-jones-polynomial-at-minus-one">#</a> <code>jones_polynomial_at_minus_one</code></h3>
<p><code>jones_polynomial_at_minus_one</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = jones_polynomial_at_minus_one $x
# or in a pipeline:
@list |> map jones_polynomial_at_minus_one |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-joule-heating-battery">
<h3><a class="doc-anchor" href="#doc-joule-heating-battery">#</a> <code>joule_heating_battery</code></h3>
<p><code>joule_heating_battery</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = joule_heating_battery $x
# or in a pipeline:
@list |> map joule_heating_battery |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-joules-to-cal">
<h3><a class="doc-anchor" href="#doc-joules-to-cal">#</a> <code>joules_to_cal</code></h3>
<p><code>joules_to_cal</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = joules_to_cal $input
</code></pre>
</article>
<article class="doc-entry" id="doc-joules-to-ev">
<h3><a class="doc-anchor" href="#doc-joules-to-ev">#</a> <code>joules_to_ev</code></h3>
<p><code>joules_to_ev</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = joules_to_ev $input
</code></pre>
</article>
<article class="doc-entry" id="doc-jpeg-dct-8x8-quant">
<h3><a class="doc-anchor" href="#doc-jpeg-dct-8x8-quant">#</a> <code>jpeg_dct_8x8_quant</code></h3>
<p><code>jpeg_dct_8x8_quant</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = jpeg_dct_8x8_quant $x
# or in a pipeline:
@list |> map jpeg_dct_8x8_quant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jpeg-zig-zag-index">
<h3><a class="doc-anchor" href="#doc-jpeg-zig-zag-index">#</a> <code>jpeg_zig_zag_index</code></h3>
<p><code>jpeg_zig_zag_index</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = jpeg_zig_zag_index $x
# or in a pipeline:
@list |> map jpeg_zig_zag_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jr-european-call">
<h3><a class="doc-anchor" href="#doc-jr-european-call">#</a> <code>jr_european_call</code></h3>
<p><code>jr_european_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = jr_european_call $x
# or in a pipeline:
@list |> map jr_european_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-array-length">
<h3><a class="doc-anchor" href="#doc-json-array-length">#</a> <code>json_array_length</code></h3>
<p><code>json_array_length</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = json_array_length $x
# or in a pipeline:
@list |> map json_array_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-build-object">
<h3><a class="doc-anchor" href="#doc-json-build-object">#</a> <code>json_build_object</code></h3>
<p><code>json_build_object</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = json_build_object $x
# or in a pipeline:
@list |> map json_build_object |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-each">
<h3><a class="doc-anchor" href="#doc-json-each">#</a> <code>json_each</code></h3>
<p><code>json_each</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = json_each $x
# or in a pipeline:
@list |> map json_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-escape">
<h3><a class="doc-anchor" href="#doc-json-escape">#</a> <code>json_escape</code></h3>
<p><code>json_escape</code> — json helpers builtin. Alias for <code>escape_json</code>.</p>
<pre><code class="lang-perl">my $result = json_escape $x
# or in a pipeline:
@list |> map json_escape |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-extract-path">
<h3><a class="doc-anchor" href="#doc-json-extract-path">#</a> <code>json_extract_path</code></h3>
<p><code>json_extract_path</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = json_extract_path $x
# or in a pipeline:
@list |> map json_extract_path |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-minify">
<h3><a class="doc-anchor" href="#doc-json-minify">#</a> <code>json_minify</code></h3>
<p><code>json_minify</code> — json helpers builtin.</p>
<pre><code class="lang-perl">my $result = json_minify $x
# or in a pipeline:
@list |> map json_minify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-pretty">
<h3><a class="doc-anchor" href="#doc-json-pretty">#</a> <code>json_pretty</code></h3>
<p><code>json_pretty</code> — json helpers builtin.</p>
<pre><code class="lang-perl">my $result = json_pretty $x
# or in a pipeline:
@list |> map json_pretty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-strip-nulls">
<h3><a class="doc-anchor" href="#doc-json-strip-nulls">#</a> <code>json_strip_nulls</code></h3>
<p><code>json_strip_nulls</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = json_strip_nulls $x
# or in a pipeline:
@list |> map json_strip_nulls |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jsonb-array-length">
<h3><a class="doc-anchor" href="#doc-jsonb-array-length">#</a> <code>jsonb_array_length</code></h3>
<p><code>jsonb_array_length</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = jsonb_array_length $x
# or in a pipeline:
@list |> map jsonb_array_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jsonb-object-keys">
<h3><a class="doc-anchor" href="#doc-jsonb-object-keys">#</a> <code>jsonb_object_keys</code></h3>
<p><code>jsonb_object_keys</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = jsonb_object_keys $x
# or in a pipeline:
@list |> map jsonb_object_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jsonb-path-query">
<h3><a class="doc-anchor" href="#doc-jsonb-path-query">#</a> <code>jsonb_path_query</code></h3>
<p><code>jsonb_path_query</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = jsonb_path_query $x
# or in a pipeline:
@list |> map jsonb_path_query |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jsonb-pretty">
<h3><a class="doc-anchor" href="#doc-jsonb-pretty">#</a> <code>jsonb_pretty</code></h3>
<p><code>jsonb_pretty</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = jsonb_pretty $x
# or in a pipeline:
@list |> map jsonb_pretty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jsonb-set">
<h3><a class="doc-anchor" href="#doc-jsonb-set">#</a> <code>jsonb_set</code></h3>
<p><code>jsonb_set</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = jsonb_set $x
# or in a pipeline:
@list |> map jsonb_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jsonb-typeof">
<h3><a class="doc-anchor" href="#doc-jsonb-typeof">#</a> <code>jsonb_typeof</code></h3>
<p><code>jsonb_typeof</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = jsonb_typeof $x
# or in a pipeline:
@list |> map jsonb_typeof |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jukes-cantor-distance">
<h3><a class="doc-anchor" href="#doc-jukes-cantor-distance">#</a> <code>jukes_cantor_distance</code></h3>
<p><code>jukes_cantor_distance</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = jukes_cantor_distance $x
# or in a pipeline:
@list |> map jukes_cantor_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-julian-centuries-j2000">
<h3><a class="doc-anchor" href="#doc-julian-centuries-j2000">#</a> <code>julian_centuries_j2000</code></h3>
<p><code>julian_centuries_j2000</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = julian_centuries_j2000 $x
# or in a pipeline:
@list |> map julian_centuries_j2000 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-julian-day">
<h3><a class="doc-anchor" href="#doc-julian-day">#</a> <code>julian_day</code></h3>
<p><code>julian_day</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = julian_day $x
# or in a pipeline:
@list |> map julian_day |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-julian-from-fixed">
<h3><a class="doc-anchor" href="#doc-julian-from-fixed">#</a> <code>julian_from_fixed</code></h3>
<p><code>julian_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = julian_from_fixed $x
# or in a pipeline:
@list |> map julian_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-just-intonation-freq">
<h3><a class="doc-anchor" href="#doc-just-intonation-freq">#</a> <code>just_intonation_freq</code></h3>
<p><code>just_intonation_freq</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = just_intonation_freq $x
# or in a pipeline:
@list |> map just_intonation_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-just-intonation-ratio">
<h3><a class="doc-anchor" href="#doc-just-intonation-ratio">#</a> <code>just_intonation_ratio</code></h3>
<p><code>just_intonation_ratio</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = just_intonation_ratio $x
# or in a pipeline:
@list |> map just_intonation_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-juxt2">
<h3><a class="doc-anchor" href="#doc-juxt2">#</a> <code>juxt2</code></h3>
<p><code>juxt2</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = juxt2 $x
# or in a pipeline:
@list |> map juxt2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-juxt3">
<h3><a class="doc-anchor" href="#doc-juxt3">#</a> <code>juxt3</code></h3>
<p><code>juxt3</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = juxt3 $x
# or in a pipeline:
@list |> map juxt3 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jv">
<h3><a class="doc-anchor" href="#doc-jv">#</a> <code>jv</code></h3>
<p><code>jv</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = jv $x
# or in a pipeline:
@list |> map jv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-k-coreness">
<h3><a class="doc-anchor" href="#doc-k-coreness">#</a> <code>k_coreness</code></h3>
<p><code>k_coreness</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = k_coreness $x
# or in a pipeline:
@list |> map k_coreness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-k-from-dg">
<h3><a class="doc-anchor" href="#doc-k-from-dg">#</a> <code>k_from_dg</code></h3>
<p><code>k_from_dg</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = k_from_dg $x
# or in a pipeline:
@list |> map k_from_dg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-k-shortest-spanning">
<h3><a class="doc-anchor" href="#doc-k-shortest-spanning">#</a> <code>k_shortest_spanning</code></h3>
<p><code>k_shortest_spanning</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = k_shortest_spanning $x
# or in a pipeline:
@list |> map k_shortest_spanning |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-k-to-c">
<h3><a class="doc-anchor" href="#doc-k-to-c">#</a> <code>k_to_c</code></h3>
<p><code>k_to_c</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = k_to_c $input
</code></pre>
</article>
<article class="doc-entry" id="doc-k-to-f">
<h3><a class="doc-anchor" href="#doc-k-to-f">#</a> <code>k_to_f</code></h3>
<p><code>k_to_f</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = k_to_f $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ka-to-pka">
<h3><a class="doc-anchor" href="#doc-ka-to-pka">#</a> <code>ka_to_pka</code></h3>
<p><code>ka_to_pka</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = ka_to_pka $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kaiser">
<h3><a class="doc-anchor" href="#doc-kaiser">#</a> <code>kaiser</code></h3>
<p><code>window_kaiser($n, $beta)</code> (alias <code>kaiser</code>) — generates a Kaiser window with parameter beta controlling the tradeoff between main lobe width and sidelobe level. Beta=0 is rectangular, beta~5 is similar to Hamming.</p>
<pre><code class="lang-perl">my $w = kaiser(1024, 5.0)
</code></pre>
</article>
<article class="doc-entry" id="doc-kaiser-window">
<h3><a class="doc-anchor" href="#doc-kaiser-window">#</a> <code>kaiser_window</code></h3>
<p><code>kaiser_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = kaiser_window $x
# or in a pipeline:
@list |> map kaiser_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kaiserord-step">
<h3><a class="doc-anchor" href="#doc-kaiserord-step">#</a> <code>kaiserord_step</code></h3>
<p><code>kaiserord_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = kaiserord_step $x
# or in a pipeline:
@list |> map kaiserord_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kalai-smorodinsky-step">
<h3><a class="doc-anchor" href="#doc-kalai-smorodinsky-step">#</a> <code>kalai_smorodinsky_step</code></h3>
<p><code>kalai_smorodinsky_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = kalai_smorodinsky_step $x
# or in a pipeline:
@list |> map kalai_smorodinsky_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kalman-filter-step">
<h3><a class="doc-anchor" href="#doc-kalman-filter-step">#</a> <code>kalman_filter_step</code></h3>
<p><code>kalman_filter_step</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = kalman_filter_step $x
# or in a pipeline:
@list |> map kalman_filter_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kalman-predict-state">
<h3><a class="doc-anchor" href="#doc-kalman-predict-state">#</a> <code>kalman_predict_state</code></h3>
<p><code>kalman_predict_state</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = kalman_predict_state $x
# or in a pipeline:
@list |> map kalman_predict_state |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kalman-smoother-step">
<h3><a class="doc-anchor" href="#doc-kalman-smoother-step">#</a> <code>kalman_smoother_step</code></h3>
<p><code>kalman_smoother_step</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = kalman_smoother_step $x
# or in a pipeline:
@list |> map kalman_smoother_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kalman-update-state">
<h3><a class="doc-anchor" href="#doc-kalman-update-state">#</a> <code>kalman_update_state</code></h3>
<p><code>kalman_update_state</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = kalman_update_state $x
# or in a pipeline:
@list |> map kalman_update_state |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kaluza-klein-step">
<h3><a class="doc-anchor" href="#doc-kaluza-klein-step">#</a> <code>kaluza_klein_step</code></h3>
<p><code>kaluza_klein_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = kaluza_klein_step $x
# or in a pipeline:
@list |> map kaluza_klein_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kaprekar-routine-step">
<h3><a class="doc-anchor" href="#doc-kaprekar-routine-step">#</a> <code>kaprekar_routine_step</code></h3>
<p><code>kaprekar_routine_step</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = kaprekar_routine_step $x
# or in a pipeline:
@list |> map kaprekar_routine_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-karger-contract-edge">
<h3><a class="doc-anchor" href="#doc-karger-contract-edge">#</a> <code>karger_contract_edge</code></h3>
<p><code>karger_contract_edge</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = karger_contract_edge $x
# or in a pipeline:
@list |> map karger_contract_edge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-karger-min-cut-count">
<h3><a class="doc-anchor" href="#doc-karger-min-cut-count">#</a> <code>karger_min_cut_count</code></h3>
<p><code>karger_min_cut_count</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = karger_min_cut_count $x
# or in a pipeline:
@list |> map karger_min_cut_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-karger-step">
<h3><a class="doc-anchor" href="#doc-karger-step">#</a> <code>karger_step</code></h3>
<p><code>karger_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = karger_step $x
# or in a pipeline:
@list |> map karger_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-karhunen-loeve-step">
<h3><a class="doc-anchor" href="#doc-karhunen-loeve-step">#</a> <code>karhunen_loeve_step</code></h3>
<p><code>karhunen_loeve_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = karhunen_loeve_step $x
# or in a pipeline:
@list |> map karhunen_loeve_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kasiski-repeats">
<h3><a class="doc-anchor" href="#doc-kasiski-repeats">#</a> <code>kasiski_repeats</code></h3>
<p><code>kasiski_repeats</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = kasiski_repeats $x
# or in a pipeline:
@list |> map kasiski_repeats |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-katz-centrality">
<h3><a class="doc-anchor" href="#doc-katz-centrality">#</a> <code>katz_centrality</code></h3>
<p><code>katz_centrality</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = katz_centrality $x
# or in a pipeline:
@list |> map katz_centrality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kauffman-bracket-eval">
<h3><a class="doc-anchor" href="#doc-kauffman-bracket-eval">#</a> <code>kauffman_bracket_eval</code></h3>
<p><code>kauffman_bracket_eval</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = kauffman_bracket_eval $x
# or in a pipeline:
@list |> map kauffman_bracket_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kb-to-b">
<h3><a class="doc-anchor" href="#doc-kb-to-b">#</a> <code>kb_to_b</code></h3>
<p><code>kb_to_b</code> — unit conversions builtin. Alias for <code>kb_to_bytes</code>.</p>
<pre><code class="lang-perl">my $result = kb_to_b $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kb-to-bytes">
<h3><a class="doc-anchor" href="#doc-kb-to-bytes">#</a> <code>kb_to_bytes</code></h3>
<p><code>kb_to_bytes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = kb_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kb-to-mb">
<h3><a class="doc-anchor" href="#doc-kb-to-mb">#</a> <code>kb_to_mb</code></h3>
<p><code>kb_to_mb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = kb_to_mb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kc-from-rates">
<h3><a class="doc-anchor" href="#doc-kc-from-rates">#</a> <code>kc_from_rates</code></h3>
<p><code>kc_from_rates</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = kc_from_rates $x
# or in a pipeline:
@list |> map kc_from_rates |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kcoulomb">
<h3><a class="doc-anchor" href="#doc-kcoulomb">#</a> <code>kcoulomb</code></h3>
<p><code>kcoulomb</code> — physics constants builtin. Alias for <code>coulomb_constant</code>.</p>
<pre><code class="lang-perl">my $result = kcoulomb $x
# or in a pipeline:
@list |> map kcoulomb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-bandwidth-lscv">
<h3><a class="doc-anchor" href="#doc-kde-bandwidth-lscv">#</a> <code>kde_bandwidth_lscv</code></h3>
<p><code>kde_bandwidth_lscv</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_bandwidth_lscv $x
# or in a pipeline:
@list |> map kde_bandwidth_lscv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-biweight">
<h3><a class="doc-anchor" href="#doc-kde-biweight">#</a> <code>kde_biweight</code></h3>
<p><code>kde_biweight</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_biweight $x
# or in a pipeline:
@list |> map kde_biweight |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-cosine">
<h3><a class="doc-anchor" href="#doc-kde-cosine">#</a> <code>kde_cosine</code></h3>
<p><code>kde_cosine</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_cosine $x
# or in a pipeline:
@list |> map kde_cosine |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-epanechnikov">
<h3><a class="doc-anchor" href="#doc-kde-epanechnikov">#</a> <code>kde_epanechnikov</code></h3>
<p><code>kde_epanechnikov</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_epanechnikov $x
# or in a pipeline:
@list |> map kde_epanechnikov |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-gaussian-2d">
<h3><a class="doc-anchor" href="#doc-kde-gaussian-2d">#</a> <code>kde_gaussian_2d</code></h3>
<p><code>kde_gaussian_2d</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_gaussian_2d $x
# or in a pipeline:
@list |> map kde_gaussian_2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-logistic-kernel">
<h3><a class="doc-anchor" href="#doc-kde-logistic-kernel">#</a> <code>kde_logistic_kernel</code></h3>
<p><code>kde_logistic_kernel</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_logistic_kernel $x
# or in a pipeline:
@list |> map kde_logistic_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-scott-bw">
<h3><a class="doc-anchor" href="#doc-kde-scott-bw">#</a> <code>kde_scott_bw</code></h3>
<p><code>kde_scott_bw</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_scott_bw $x
# or in a pipeline:
@list |> map kde_scott_bw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-silverman-bw">
<h3><a class="doc-anchor" href="#doc-kde-silverman-bw">#</a> <code>kde_silverman_bw</code></h3>
<p><code>kde_silverman_bw</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_silverman_bw $x
# or in a pipeline:
@list |> map kde_silverman_bw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-triangular">
<h3><a class="doc-anchor" href="#doc-kde-triangular">#</a> <code>kde_triangular</code></h3>
<p><code>kde_triangular</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_triangular $x
# or in a pipeline:
@list |> map kde_triangular |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-triweight">
<h3><a class="doc-anchor" href="#doc-kde-triweight">#</a> <code>kde_triweight</code></h3>
<p><code>kde_triweight</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_triweight $x
# or in a pipeline:
@list |> map kde_triweight |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kde-uniform">
<h3><a class="doc-anchor" href="#doc-kde-uniform">#</a> <code>kde_uniform</code></h3>
<p><code>kde_uniform</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = kde_uniform $x
# or in a pipeline:
@list |> map kde_uniform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-keep">
<h3><a class="doc-anchor" href="#doc-keep">#</a> <code>keep</code></h3>
<p><code>keep</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = keep $x
# or in a pipeline:
@list |> map keep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-keep-if">
<h3><a class="doc-anchor" href="#doc-keep-if">#</a> <code>keep_if</code></h3>
<p><code>keep_if</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = keep_if $x
# or in a pipeline:
@list |> map keep_if |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-keith-q">
<h3><a class="doc-anchor" href="#doc-keith-q">#</a> <code>keith_q</code></h3>
<p><code>keith_q</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = keith_q $x
# or in a pipeline:
@list |> map keith_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kelly-criterion">
<h3><a class="doc-anchor" href="#doc-kelly-criterion">#</a> <code>kelly_criterion</code></h3>
<p><code>kelly_criterion</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = kelly_criterion $x
# or in a pipeline:
@list |> map kelly_criterion |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kemeny-score-step">
<h3><a class="doc-anchor" href="#doc-kemeny-score-step">#</a> <code>kemeny_score_step</code></h3>
<p><code>kemeny_score_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = kemeny_score_step $x
# or in a pipeline:
@list |> map kemeny_score_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kendall">
<h3><a class="doc-anchor" href="#doc-kendall">#</a> <code>kendall</code></h3>
<p><code>kendall_tau</code> (aliases <code>kendall</code>, <code>ktau</code>) computes Kendall's rank correlation coefficient (tau-b).</p>
<pre><code class="lang-perl">p ktau([1,2,3,4], [1,2,4,3]) # 0.67
</code></pre>
</article>
<article class="doc-entry" id="doc-kendalltau">
<h3><a class="doc-anchor" href="#doc-kendalltau">#</a> <code>kendalltau</code></h3>
<p><code>kendalltau</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = kendalltau $x
# or in a pipeline:
@list |> map kendalltau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kepler-hyperbolic">
<h3><a class="doc-anchor" href="#doc-kepler-hyperbolic">#</a> <code>kepler_hyperbolic</code></h3>
<p><code>kepler_hyperbolic</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = kepler_hyperbolic $x
# or in a pipeline:
@list |> map kepler_hyperbolic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kepler-period-au">
<h3><a class="doc-anchor" href="#doc-kepler-period-au">#</a> <code>kepler_period_au</code></h3>
<p><code>kepler_period_au</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = kepler_period_au $x
# or in a pipeline:
@list |> map kepler_period_au |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kerr-ergosphere-eq">
<h3><a class="doc-anchor" href="#doc-kerr-ergosphere-eq">#</a> <code>kerr_ergosphere_eq</code></h3>
<p><code>kerr_ergosphere_eq</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = kerr_ergosphere_eq $x
# or in a pipeline:
@list |> map kerr_ergosphere_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kerr-horizon">
<h3><a class="doc-anchor" href="#doc-kerr-horizon">#</a> <code>kerr_horizon</code></h3>
<p><code>kerr_horizon</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = kerr_horizon $x
# or in a pipeline:
@list |> map kerr_horizon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kerr-newman-charge-term">
<h3><a class="doc-anchor" href="#doc-kerr-newman-charge-term">#</a> <code>kerr_newman_charge_term</code></h3>
<p><code>kerr_newman_charge_term</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = kerr_newman_charge_term $x
# or in a pipeline:
@list |> map kerr_newman_charge_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-key-signature-flats">
<h3><a class="doc-anchor" href="#doc-key-signature-flats">#</a> <code>key_signature_flats</code></h3>
<p><code>key_signature_flats</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = key_signature_flats $x
# or in a pipeline:
@list |> map key_signature_flats |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-key-signature-for">
<h3><a class="doc-anchor" href="#doc-key-signature-for">#</a> <code>key_signature_for</code></h3>
<p><code>key_signature_for</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = key_signature_for $x
# or in a pipeline:
@list |> map key_signature_for |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-key-signature-sharps">
<h3><a class="doc-anchor" href="#doc-key-signature-sharps">#</a> <code>key_signature_sharps</code></h3>
<p><code>key_signature_sharps</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = key_signature_sharps $x
# or in a pipeline:
@list |> map key_signature_sharps |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-keys-sorted">
<h3><a class="doc-anchor" href="#doc-keys-sorted">#</a> <code>keys_sorted</code></h3>
<p><code>keys_sorted</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = keys_sorted $x
# or in a pipeline:
@list |> map keys_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kg-to-lb">
<h3><a class="doc-anchor" href="#doc-kg-to-lb">#</a> <code>kg_to_lb</code></h3>
<p><code>kg_to_lb</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = kg_to_lb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kg-to-lbs">
<h3><a class="doc-anchor" href="#doc-kg-to-lbs">#</a> <code>kg_to_lbs</code></h3>
<p><code>kg_to_lbs</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = kg_to_lbs $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kg-to-stone">
<h3><a class="doc-anchor" href="#doc-kg-to-stone">#</a> <code>kg_to_stone</code></h3>
<p><code>kg_to_stone</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = kg_to_stone $input
</code></pre>
</article>
<article class="doc-entry" id="doc-khinchin">
<h3><a class="doc-anchor" href="#doc-khinchin">#</a> <code>khinchin</code></h3>
<p><code>khinchin</code> — math constants builtin. Alias for <code>khinchin_constant</code>.</p>
<pre><code class="lang-perl">my $result = khinchin $x
# or in a pipeline:
@list |> map khinchin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-khinchin-constant">
<h3><a class="doc-anchor" href="#doc-khinchin-constant">#</a> <code>khinchin_constant</code></h3>
<p><code>khinchin_constant</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = khinchin_constant $x
# or in a pipeline:
@list |> map khinchin_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-khovanov-q-grading">
<h3><a class="doc-anchor" href="#doc-khovanov-q-grading">#</a> <code>khovanov_q_grading</code></h3>
<p><code>khovanov_q_grading</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = khovanov_q_grading $x
# or in a pipeline:
@list |> map khovanov_q_grading |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-khovanov-rasmussen-s">
<h3><a class="doc-anchor" href="#doc-khovanov-rasmussen-s">#</a> <code>khovanov_rasmussen_s</code></h3>
<p><code>khovanov_rasmussen_s</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = khovanov_rasmussen_s $x
# or in a pipeline:
@list |> map khovanov_rasmussen_s |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-killing-form-su2">
<h3><a class="doc-anchor" href="#doc-killing-form-su2">#</a> <code>killing_form_su2</code></h3>
<p><code>killing_form_su2</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = killing_form_su2 $x
# or in a pipeline:
@list |> map killing_form_su2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-killing-vector-lie-step">
<h3><a class="doc-anchor" href="#doc-killing-vector-lie-step">#</a> <code>killing_vector_lie_step</code></h3>
<p><code>killing_vector_lie_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = killing_vector_lie_step $x
# or in a pipeline:
@list |> map killing_vector_lie_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kimura-2p-distance">
<h3><a class="doc-anchor" href="#doc-kimura-2p-distance">#</a> <code>kimura_2p_distance</code></h3>
<p><code>kimura_2p_distance</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = kimura_2p_distance $x
# or in a pipeline:
@list |> map kimura_2p_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kinetic-energy">
<h3><a class="doc-anchor" href="#doc-kinetic-energy">#</a> <code>kinetic_energy</code></h3>
<p><code>kinetic_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = kinetic_energy $x
# or in a pipeline:
@list |> map kinetic_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kirnberger-iii">
<h3><a class="doc-anchor" href="#doc-kirnberger-iii">#</a> <code>kirnberger_iii</code></h3>
<p><code>kirnberger_iii</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = kirnberger_iii $x
# or in a pipeline:
@list |> map kirnberger_iii |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kleibers-law">
<h3><a class="doc-anchor" href="#doc-kleibers-law">#</a> <code>kleibers_law</code></h3>
<p><code>kleibers_law</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = kleibers_law $x
# or in a pipeline:
@list |> map kleibers_law |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-km-to-miles">
<h3><a class="doc-anchor" href="#doc-km-to-miles">#</a> <code>km_to_miles</code></h3>
<p><code>km_to_miles</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = km_to_miles $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kmeans">
<h3><a class="doc-anchor" href="#doc-kmeans">#</a> <code>kmeans</code></h3>
<p><code>kmeans</code> — k-means clustering (Lloyd's algorithm). Takes array of points and k. Returns cluster assignments. Like R's kmeans().</p>
<pre><code class="lang-perl">my @clusters = @{kmeans([[0,0],[1,0],[10,10],[11,10]], 2)}
# [0,0,1,1] — two clusters
</code></pre>
</article>
<article class="doc-entry" id="doc-kmer-jaccard">
<h3><a class="doc-anchor" href="#doc-kmer-jaccard">#</a> <code>kmer_jaccard</code></h3>
<p><code>kmer_jaccard</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = kmer_jaccard $x
# or in a pipeline:
@list |> map kmer_jaccard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kmh-to-mph">
<h3><a class="doc-anchor" href="#doc-kmh-to-mph">#</a> <code>kmh_to_mph</code></h3>
<p><code>kmh_to_mph</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = kmh_to_mph $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kmh-to-mps">
<h3><a class="doc-anchor" href="#doc-kmh-to-mps">#</a> <code>kmh_to_mps</code></h3>
<p><code>kmh_to_mps</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = kmh_to_mps $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kmp">
<h3><a class="doc-anchor" href="#doc-kmp">#</a> <code>kmp</code></h3>
<p><code>kmp</code> — batch 10 builtin. Alias for <code>kmp_failure</code>.</p>
<pre><code class="lang-perl">my $result = kmp $x
# or in a pipeline:
@list |> map kmp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kmp-failure">
<h3><a class="doc-anchor" href="#doc-kmp-failure">#</a> <code>kmp_failure</code></h3>
<p><code>kmp_failure</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = kmp_failure $x
# or in a pipeline:
@list |> map kmp_failure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-knapsack-01-dp-value">
<h3><a class="doc-anchor" href="#doc-knapsack-01-dp-value">#</a> <code>knapsack_01_dp_value</code></h3>
<p><code>knapsack_01_dp_value</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = knapsack_01_dp_value $x
# or in a pipeline:
@list |> map knapsack_01_dp_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-knapsack-branch-bound">
<h3><a class="doc-anchor" href="#doc-knapsack-branch-bound">#</a> <code>knapsack_branch_bound</code></h3>
<p><code>knapsack_branch_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = knapsack_branch_bound $x
# or in a pipeline:
@list |> map knapsack_branch_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-knapsack-fractional-step">
<h3><a class="doc-anchor" href="#doc-knapsack-fractional-step">#</a> <code>knapsack_fractional_step</code></h3>
<p><code>knapsack_fractional_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = knapsack_fractional_step $x
# or in a pipeline:
@list |> map knapsack_fractional_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-knapsack-lp-relaxation">
<h3><a class="doc-anchor" href="#doc-knapsack-lp-relaxation">#</a> <code>knapsack_lp_relaxation</code></h3>
<p><code>knapsack_lp_relaxation</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = knapsack_lp_relaxation $x
# or in a pipeline:
@list |> map knapsack_lp_relaxation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-knapsack-unbounded-dp">
<h3><a class="doc-anchor" href="#doc-knapsack-unbounded-dp">#</a> <code>knapsack_unbounded_dp</code></h3>
<p><code>knapsack_unbounded_dp</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = knapsack_unbounded_dp $x
# or in a pipeline:
@list |> map knapsack_unbounded_dp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-knots-to-kmh">
<h3><a class="doc-anchor" href="#doc-knots-to-kmh">#</a> <code>knots_to_kmh</code></h3>
<p><code>knots_to_kmh</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = knots_to_kmh $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kohlrausch-law">
<h3><a class="doc-anchor" href="#doc-kohlrausch-law">#</a> <code>kohlrausch_law</code></h3>
<p><code>kohlrausch_law</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = kohlrausch_law $x
# or in a pipeline:
@list |> map kohlrausch_law |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kolmogorov-microscale">
<h3><a class="doc-anchor" href="#doc-kolmogorov-microscale">#</a> <code>kolmogorov_microscale</code></h3>
<p><code>kolmogorov_microscale</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = kolmogorov_microscale $x
# or in a pipeline:
@list |> map kolmogorov_microscale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kolmogorov-smirnov">
<h3><a class="doc-anchor" href="#doc-kolmogorov-smirnov">#</a> <code>kolmogorov_smirnov</code></h3>
<p><code>kolmogorov_smirnov</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = kolmogorov_smirnov $x
# or in a pipeline:
@list |> map kolmogorov_smirnov |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-komar-mass-step">
<h3><a class="doc-anchor" href="#doc-komar-mass-step">#</a> <code>komar_mass_step</code></h3>
<p><code>komar_mass_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = komar_mass_step $x
# or in a pipeline:
@list |> map komar_mass_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kosaraju-scc">
<h3><a class="doc-anchor" href="#doc-kosaraju-scc">#</a> <code>kosaraju_scc</code></h3>
<p><code>kosaraju_scc</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = kosaraju_scc $x
# or in a pipeline:
@list |> map kosaraju_scc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kosaraju-step">
<h3><a class="doc-anchor" href="#doc-kosaraju-step">#</a> <code>kosaraju_step</code></h3>
<p><code>kosaraju_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = kosaraju_step $x
# or in a pipeline:
@list |> map kosaraju_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-koutecky-levich-intercept">
<h3><a class="doc-anchor" href="#doc-koutecky-levich-intercept">#</a> <code>koutecky_levich_intercept</code></h3>
<p><code>koutecky_levich_intercept</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = koutecky_levich_intercept $x
# or in a pipeline:
@list |> map koutecky_levich_intercept |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kp">
<h3><a class="doc-anchor" href="#doc-kp">#</a> <code>kp</code></h3>
<p><code>kp</code> — algebraic match builtin. Alias for <code>keep</code>.</p>
<pre><code class="lang-perl">my $result = kp $x
# or in a pipeline:
@list |> map kp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kp-from-kc">
<h3><a class="doc-anchor" href="#doc-kp-from-kc">#</a> <code>kp_from_kc</code></h3>
<p><code>kp_from_kc</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = kp_from_kc $x
# or in a pipeline:
@list |> map kp_from_kc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kpss-test">
<h3><a class="doc-anchor" href="#doc-kpss-test">#</a> <code>kpss_test</code></h3>
<p><code>kpss_test</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = kpss_test $x
# or in a pipeline:
@list |> map kpss_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kpss-test-stat">
<h3><a class="doc-anchor" href="#doc-kpss-test-stat">#</a> <code>kpss_test_stat</code></h3>
<p><code>kpss_test_stat</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = kpss_test_stat $x
# or in a pipeline:
@list |> map kpss_test_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kraus-apply">
<h3><a class="doc-anchor" href="#doc-kraus-apply">#</a> <code>kraus_apply</code></h3>
<p><code>kraus_apply</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = kraus_apply $x
# or in a pipeline:
@list |> map kraus_apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kretschmann-schwarzschild">
<h3><a class="doc-anchor" href="#doc-kretschmann-schwarzschild">#</a> <code>kretschmann_schwarzschild</code></h3>
<p><code>kretschmann_schwarzschild</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = kretschmann_schwarzschild $x
# or in a pipeline:
@list |> map kretschmann_schwarzschild |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kron-product">
<h3><a class="doc-anchor" href="#doc-kron-product">#</a> <code>kron_product</code></h3>
<p><code>kron_product</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = kron_product $x
# or in a pipeline:
@list |> map kron_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kronecker-four">
<h3><a class="doc-anchor" href="#doc-kronecker-four">#</a> <code>kronecker_four</code></h3>
<p><code>kronecker_four</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = kronecker_four $x
# or in a pipeline:
@list |> map kronecker_four |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kronecker-three">
<h3><a class="doc-anchor" href="#doc-kronecker-three">#</a> <code>kronecker_three</code></h3>
<p><code>kronecker_three</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = kronecker_three $x
# or in a pipeline:
@list |> map kronecker_three |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kruskal-h">
<h3><a class="doc-anchor" href="#doc-kruskal-h">#</a> <code>kruskal_h</code></h3>
<p><code>kruskal_h</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = kruskal_h $x
# or in a pipeline:
@list |> map kruskal_h |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kruskal-step">
<h3><a class="doc-anchor" href="#doc-kruskal-step">#</a> <code>kruskal_step</code></h3>
<p><code>kruskal_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = kruskal_step $x
# or in a pipeline:
@list |> map kruskal_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ks">
<h3><a class="doc-anchor" href="#doc-ks">#</a> <code>ks</code></h3>
<p><code>ks_test</code> (alias <code>ks</code>) — two-sample Kolmogorov-Smirnov test. Returns D statistic (max CDF difference). Like R's ks.test().</p>
<pre><code class="lang-perl">my $D = ks([1,2,3,4,5], [2,3,4,5,6]) # small D = similar
</code></pre>
</article>
<article class="doc-entry" id="doc-ksp-from-concs">
<h3><a class="doc-anchor" href="#doc-ksp-from-concs">#</a> <code>ksp_from_concs</code></h3>
<p><code>ksp_from_concs</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = ksp_from_concs $x
# or in a pipeline:
@list |> map ksp_from_concs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kth-largest">
<h3><a class="doc-anchor" href="#doc-kth-largest">#</a> <code>kth_largest</code></h3>
<p><code>kth_largest</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = kth_largest $x
# or in a pipeline:
@list |> map kth_largest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kth-smallest">
<h3><a class="doc-anchor" href="#doc-kth-smallest">#</a> <code>kth_smallest</code></h3>
<p><code>kth_smallest</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = kth_smallest $x
# or in a pipeline:
@list |> map kth_smallest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kthl">
<h3><a class="doc-anchor" href="#doc-kthl">#</a> <code>kthl</code></h3>
<p><code>kthl</code> — extended stdlib batch 3 builtin. Alias for <code>kth_largest</code>.</p>
<pre><code class="lang-perl">my $result = kthl $x
# or in a pipeline:
@list |> map kthl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kths">
<h3><a class="doc-anchor" href="#doc-kths">#</a> <code>kths</code></h3>
<p><code>kths</code> — extended stdlib batch 3 builtin. Alias for <code>kth_smallest</code>.</p>
<pre><code class="lang-perl">my $result = kths $x
# or in a pipeline:
@list |> map kths |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kullback-jensen-div">
<h3><a class="doc-anchor" href="#doc-kullback-jensen-div">#</a> <code>kullback_jensen_div</code></h3>
<p><code>kullback_jensen_div</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = kullback_jensen_div $x
# or in a pipeline:
@list |> map kullback_jensen_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kurt">
<h3><a class="doc-anchor" href="#doc-kurt">#</a> <code>kurt</code></h3>
<p><code>kurt</code> — math / numeric (uncategorized batch) builtin. Alias for <code>kurtosis</code>.</p>
<pre><code class="lang-perl">my $result = kurt $x
# or in a pipeline:
@list |> map kurt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kurtosis">
<h3><a class="doc-anchor" href="#doc-kurtosis">#</a> <code>kurtosis</code></h3>
<p><code>kurtosis</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = kurtosis $x
# or in a pipeline:
@list |> map kurtosis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kv">
<h3><a class="doc-anchor" href="#doc-kv">#</a> <code>kv</code></h3>
<p><code>kv</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = kv $x
# or in a pipeline:
@list |> map kv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kwh-to-joules">
<h3><a class="doc-anchor" href="#doc-kwh-to-joules">#</a> <code>kwh_to_joules</code></h3>
<p><code>kwh_to_joules</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = kwh_to_joules $input
</code></pre>
</article>
<article class="doc-entry" id="doc-l1-coherence">
<h3><a class="doc-anchor" href="#doc-l1-coherence">#</a> <code>l1_coherence</code></h3>
<p><code>l1_coherence</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = l1_coherence $x
# or in a pipeline:
@list |> map l1_coherence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-l1-norm">
<h3><a class="doc-anchor" href="#doc-l1-norm">#</a> <code>l1_norm</code></h3>
<p><code>l1_norm</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = l1_norm $x
# or in a pipeline:
@list |> map l1_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-l2-norm">
<h3><a class="doc-anchor" href="#doc-l2-norm">#</a> <code>l2_norm</code></h3>
<p><code>l2_norm</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = l2_norm $x
# or in a pipeline:
@list |> map l2_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-l-parallel">
<h3><a class="doc-anchor" href="#doc-l-parallel">#</a> <code>l_parallel</code></h3>
<p><code>l_parallel</code> — batch 12 builtin. Alias for <code>inductance_parallel</code>.</p>
<pre><code class="lang-perl">my $result = l_parallel $x
# or in a pipeline:
@list |> map l_parallel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-l-series">
<h3><a class="doc-anchor" href="#doc-l-series">#</a> <code>l_series</code></h3>
<p><code>l_series</code> — batch 12 builtin. Alias for <code>inductance_series</code>.</p>
<pre><code class="lang-perl">my $result = l_series $x
# or in a pipeline:
@list |> map l_series |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-label-propagation">
<h3><a class="doc-anchor" href="#doc-label-propagation">#</a> <code>label_propagation</code></h3>
<p><code>label_propagation</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = label_propagation $x
# or in a pipeline:
@list |> map label_propagation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-label-propagation-step">
<h3><a class="doc-anchor" href="#doc-label-propagation-step">#</a> <code>label_propagation_step</code></h3>
<p><code>label_propagation_step</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = label_propagation_step $x
# or in a pipeline:
@list |> map label_propagation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lagrange">
<h3><a class="doc-anchor" href="#doc-lagrange">#</a> <code>lagrange</code></h3>
<p><code>lagrange_interp</code> (aliases <code>lagrange</code>, <code>linterp</code>) performs Lagrange polynomial interpolation. Takes xs, ys, and a query point x.</p>
<pre><code class="lang-perl">p lagrange([0,1,2], [0,1,4], 1.5) # 2.25
</code></pre>
</article>
<article class="doc-entry" id="doc-lagrange-l1">
<h3><a class="doc-anchor" href="#doc-lagrange-l1">#</a> <code>lagrange_l1</code></h3>
<p><code>lagrange_l1</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = lagrange_l1 $x
# or in a pipeline:
@list |> map lagrange_l1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lagrangian-dual-step">
<h3><a class="doc-anchor" href="#doc-lagrangian-dual-step">#</a> <code>lagrangian_dual_step</code></h3>
<p><code>lagrangian_dual_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = lagrangian_dual_step $x
# or in a pipeline:
@list |> map lagrangian_dual_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lagrangian-relax-step">
<h3><a class="doc-anchor" href="#doc-lagrangian-relax-step">#</a> <code>lagrangian_relax_step</code></h3>
<p><code>lagrangian_relax_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = lagrangian_relax_step $x
# or in a pipeline:
@list |> map lagrangian_relax_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lalr-lookahead-compute">
<h3><a class="doc-anchor" href="#doc-lalr-lookahead-compute">#</a> <code>lalr_lookahead_compute</code></h3>
<p><code>lalr_lookahead_compute</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = lalr_lookahead_compute $x
# or in a pipeline:
@list |> map lalr_lookahead_compute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lambert-azimuthal-project">
<h3><a class="doc-anchor" href="#doc-lambert-azimuthal-project">#</a> <code>lambert_azimuthal_project</code></h3>
<p><code>lambert_azimuthal_project</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = lambert_azimuthal_project $x
# or in a pipeline:
@list |> map lambert_azimuthal_project |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lambert-simple">
<h3><a class="doc-anchor" href="#doc-lambert-simple">#</a> <code>lambert_simple</code></h3>
<p><code>lambert_simple</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = lambert_simple $x
# or in a pipeline:
@list |> map lambert_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lambert-w">
<h3><a class="doc-anchor" href="#doc-lambert-w">#</a> <code>lambert_w</code></h3>
<p><code>lambert_w</code> (aliases <code>lambertw</code>, <code>productlog</code>) computes the Lambert W function (principal branch): the inverse of f(w) = w·e^w.</p>
<pre><code class="lang-perl">p lambertw(1) # 0.5671 (Omega constant)
p lambertw(exp(1)) # 1.0
</code></pre>
</article>
<article class="doc-entry" id="doc-lambert-w0">
<h3><a class="doc-anchor" href="#doc-lambert-w0">#</a> <code>lambert_w0</code></h3>
<p><code>lambert_w0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = lambert_w0 $x
# or in a pipeline:
@list |> map lambert_w0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lander-waterman-gaps">
<h3><a class="doc-anchor" href="#doc-lander-waterman-gaps">#</a> <code>lander_waterman_gaps</code></h3>
<p><code>lander_waterman_gaps</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = lander_waterman_gaps $x
# or in a pipeline:
@list |> map lander_waterman_gaps |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-laplace-de-rham-step">
<h3><a class="doc-anchor" href="#doc-laplace-de-rham-step">#</a> <code>laplace_de_rham_step</code></h3>
<p><code>laplace_de_rham_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = laplace_de_rham_step $x
# or in a pipeline:
@list |> map laplace_de_rham_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-laplace-pdf">
<h3><a class="doc-anchor" href="#doc-laplace-pdf">#</a> <code>laplace_pdf</code></h3>
<p><code>laplace_pdf</code> (alias <code>laplacepdf</code>) evaluates the Laplace distribution PDF at x with location mu and scale b.</p>
<pre><code class="lang-perl">p laplacepdf(0, 0, 1) # 0.5 (peak)
</code></pre>
</article>
<article class="doc-entry" id="doc-laplacian-kernel-value">
<h3><a class="doc-anchor" href="#doc-laplacian-kernel-value">#</a> <code>laplacian_kernel_value</code></h3>
<p><code>laplacian_kernel_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = laplacian_kernel_value $x
# or in a pipeline:
@list |> map laplacian_kernel_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-larmor-frequency">
<h3><a class="doc-anchor" href="#doc-larmor-frequency">#</a> <code>larmor_frequency</code></h3>
<p><code>larmor_frequency</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = larmor_frequency $x
# or in a pipeline:
@list |> map larmor_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-arg">
<h3><a class="doc-anchor" href="#doc-last-arg">#</a> <code>last_arg</code></h3>
<p><code>last_arg</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = last_arg $x
# or in a pipeline:
@list |> map last_arg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-clj">
<h3><a class="doc-anchor" href="#doc-last-clj">#</a> <code>last_clj</code></h3>
<p><code>last_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = last_clj $x
# or in a pipeline:
@list |> map last_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-elem">
<h3><a class="doc-anchor" href="#doc-last-elem">#</a> <code>last_elem</code></h3>
<p><code>last_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = last_elem $x
# or in a pipeline:
@list |> map last_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-eq">
<h3><a class="doc-anchor" href="#doc-last-eq">#</a> <code>last_eq</code></h3>
<p><code>last_eq</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = last_eq $x
# or in a pipeline:
@list |> map last_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-index-of">
<h3><a class="doc-anchor" href="#doc-last-index-of">#</a> <code>last_index_of</code></h3>
<p><code>last_index_of</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = last_index_of $x
# or in a pipeline:
@list |> map last_index_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-of-month">
<h3><a class="doc-anchor" href="#doc-last-of-month">#</a> <code>last_of_month</code></h3>
<p><code>last_of_month</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = last_of_month $x
# or in a pipeline:
@list |> map last_of_month |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-word">
<h3><a class="doc-anchor" href="#doc-last-word">#</a> <code>last_word</code></h3>
<p><code>last_word</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = last_word $x
# or in a pipeline:
@list |> map last_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lastc">
<h3><a class="doc-anchor" href="#doc-lastc">#</a> <code>lastc</code></h3>
<p><code>lastc</code> — algebraic match builtin. Alias for <code>last_clj</code>.</p>
<pre><code class="lang-perl">my $result = lastc $x
# or in a pipeline:
@list |> map lastc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lat-lng-to-tile-xyz">
<h3><a class="doc-anchor" href="#doc-lat-lng-to-tile-xyz">#</a> <code>lat_lng_to_tile_xyz</code></h3>
<p><code>lat_lng_to_tile_xyz</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = lat_lng_to_tile_xyz $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lat-lng-to-xy-lambert">
<h3><a class="doc-anchor" href="#doc-lat-lng-to-xy-lambert">#</a> <code>lat_lng_to_xy_lambert</code></h3>
<p><code>lat_lng_to_xy_lambert</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = lat_lng_to_xy_lambert $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lat-lng-to-xy-mercator">
<h3><a class="doc-anchor" href="#doc-lat-lng-to-xy-mercator">#</a> <code>lat_lng_to_xy_mercator</code></h3>
<p><code>lat_lng_to_xy_mercator</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = lat_lng_to_xy_mercator $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lax-friedrichs-flux">
<h3><a class="doc-anchor" href="#doc-lax-friedrichs-flux">#</a> <code>lax_friedrichs_flux</code></h3>
<p><code>lax_friedrichs_flux</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = lax_friedrichs_flux $x
# or in a pipeline:
@list |> map lax_friedrichs_flux |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lax-wendroff-flux">
<h3><a class="doc-anchor" href="#doc-lax-wendroff-flux">#</a> <code>lax_wendroff_flux</code></h3>
<p><code>lax_wendroff_flux</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = lax_wendroff_flux $x
# or in a pipeline:
@list |> map lax_wendroff_flux |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lazy-caterer">
<h3><a class="doc-anchor" href="#doc-lazy-caterer">#</a> <code>lazy_caterer</code></h3>
<p><code>lazy_caterer</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = lazy_caterer $x
# or in a pipeline:
@list |> map lazy_caterer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lb-to-kg">
<h3><a class="doc-anchor" href="#doc-lb-to-kg">#</a> <code>lb_to_kg</code></h3>
<p><code>lb_to_kg</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = lb_to_kg $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lbf-to-newtons">
<h3><a class="doc-anchor" href="#doc-lbf-to-newtons">#</a> <code>lbf_to_newtons</code></h3>
<p><code>lbf_to_newtons</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = lbf_to_newtons $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lbound">
<h3><a class="doc-anchor" href="#doc-lbound">#</a> <code>lbound</code></h3>
<p><code>lbound</code> — extended stdlib builtin. Alias for <code>lower_bound</code>.</p>
<pre><code class="lang-perl">my $result = lbound $x
# or in a pipeline:
@list |> map lbound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lbs-to-kg">
<h3><a class="doc-anchor" href="#doc-lbs-to-kg">#</a> <code>lbs_to_kg</code></h3>
<p><code>lbs_to_kg</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = lbs_to_kg $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lc-frequency">
<h3><a class="doc-anchor" href="#doc-lc-frequency">#</a> <code>lc_frequency</code></h3>
<p><code>lc_frequency</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = lc_frequency $x
# or in a pipeline:
@list |> map lc_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lc-lines">
<h3><a class="doc-anchor" href="#doc-lc-lines">#</a> <code>lc_lines</code></h3>
<p><code>lc_lines</code> — trivial string ops builtin. Alias for <code>line_count</code>.</p>
<pre><code class="lang-perl">my $result = lc_lines $x
# or in a pipeline:
@list |> map lc_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lc-omega">
<h3><a class="doc-anchor" href="#doc-lc-omega">#</a> <code>lc_omega</code></h3>
<p><code>lc_omega</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = lc_omega $x
# or in a pipeline:
@list |> map lc_omega |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lc-resonant">
<h3><a class="doc-anchor" href="#doc-lc-resonant">#</a> <code>lc_resonant</code></h3>
<p><code>lc_resonant</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = lc_resonant $x
# or in a pipeline:
@list |> map lc_resonant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcdm-eos">
<h3><a class="doc-anchor" href="#doc-lcdm-eos">#</a> <code>lcdm_eos</code></h3>
<p><code>lcdm_eos</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = lcdm_eos $x
# or in a pipeline:
@list |> map lcdm_eos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcg-next-u32">
<h3><a class="doc-anchor" href="#doc-lcg-next-u32">#</a> <code>lcg_next_u32</code></h3>
<p><code>lcg_next_u32</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = lcg_next_u32 $x
# or in a pipeline:
@list |> map lcg_next_u32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcg-numrec-step">
<h3><a class="doc-anchor" href="#doc-lcg-numrec-step">#</a> <code>lcg_numrec_step</code></h3>
<p><code>lcg_numrec_step</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = lcg_numrec_step $x
# or in a pipeline:
@list |> map lcg_numrec_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcm">
<h3><a class="doc-anchor" href="#doc-lcm">#</a> <code>lcm</code></h3>
<p><code>lcm</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = lcm $x
# or in a pipeline:
@list |> map lcm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcontract">
<h3><a class="doc-anchor" href="#doc-lcontract">#</a> <code>lcontract</code></h3>
<p><code>length_contraction($proper_length, $velocity)</code> (alias <code>lcontract</code>) — contracted length L = L₀ × √(1-v²/c²).</p>
<pre><code class="lang-perl">p lcontract(1, 0.99 * 3e8) # ~0.14 m (1m at 99% c)
</code></pre>
</article>
<article class="doc-entry" id="doc-lcount">
<h3><a class="doc-anchor" href="#doc-lcount">#</a> <code>lcount</code></h3>
<p><code>lcount</code> — extended stdlib batch 3 builtin. Alias for <code>count_lines</code>.</p>
<pre><code class="lang-perl">my $result = lcount $x
# or in a pipeline:
@list |> map lcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcp">
<h3><a class="doc-anchor" href="#doc-lcp">#</a> <code>lcp</code></h3>
<p><code>lcp</code> — string (batch 2) builtin. Alias for <code>longest_common_prefix</code>.</p>
<pre><code class="lang-perl">my $result = lcp $x
# or in a pipeline:
@list |> map lcp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcp-array">
<h3><a class="doc-anchor" href="#doc-lcp-array">#</a> <code>lcp_array</code></h3>
<p><code>lcp_array</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = lcp_array $x
# or in a pipeline:
@list |> map lcp_array |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcs-length">
<h3><a class="doc-anchor" href="#doc-lcs-length">#</a> <code>lcs_length</code></h3>
<p><code>lcs_length</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = lcs_length $x
# or in a pipeline:
@list |> map lcs_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcseq">
<h3><a class="doc-anchor" href="#doc-lcseq">#</a> <code>lcseq</code></h3>
<p><code>lcseq</code> — extended stdlib batch 3 builtin. Alias for <code>longest_common_subsequence</code>.</p>
<pre><code class="lang-perl">my $result = lcseq $x
# or in a pipeline:
@list |> map lcseq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcsub">
<h3><a class="doc-anchor" href="#doc-lcsub">#</a> <code>lcsub</code></h3>
<p><code>lcsub</code> — extended stdlib batch 3 builtin. Alias for <code>longest_common_substring</code>.</p>
<pre><code class="lang-perl">my $result = lcsub $x
# or in a pipeline:
@list |> map lcsub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ld-d">
<h3><a class="doc-anchor" href="#doc-ld-d">#</a> <code>ld_d</code></h3>
<p><code>ld_d</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = ld_d $x
# or in a pipeline:
@list |> map ld_d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ld-r-squared">
<h3><a class="doc-anchor" href="#doc-ld-r-squared">#</a> <code>ld_r_squared</code></h3>
<p><code>ld_r_squared</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = ld_r_squared $x
# or in a pipeline:
@list |> map ld_r_squared |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ldec">
<h3><a class="doc-anchor" href="#doc-ldec">#</a> <code>ldec</code></h3>
<p><code>ldec</code> — extended stdlib batch 3 builtin. Alias for <code>longest_decreasing</code>.</p>
<pre><code class="lang-perl">my $result = ldec $x
# or in a pipeline:
@list |> map ldec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-le-chatelier-dir">
<h3><a class="doc-anchor" href="#doc-le-chatelier-dir">#</a> <code>le_chatelier_dir</code></h3>
<p><code>le_chatelier_dir</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = le_chatelier_dir $x
# or in a pipeline:
@list |> map le_chatelier_dir |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leading-zeros">
<h3><a class="doc-anchor" href="#doc-leading-zeros">#</a> <code>leading_zeros</code></h3>
<p><code>leading_zeros</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = leading_zeros $x
# or in a pipeline:
@list |> map leading_zeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leaky-relu">
<h3><a class="doc-anchor" href="#doc-leaky-relu">#</a> <code>leaky_relu</code></h3>
<p><code>leaky_relu</code> (alias <code>lrelu</code>) applies Leaky ReLU: x if x≥0, alpha*x otherwise (default alpha=0.01).</p>
<pre><code class="lang-perl">p lrelu(5) # 5
p lrelu(-5) # -0.05
p lrelu(-5, 0.1) # -0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-leap-year-gregorian">
<h3><a class="doc-anchor" href="#doc-leap-year-gregorian">#</a> <code>leap_year_gregorian</code></h3>
<p><code>leap_year_gregorian</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = leap_year_gregorian $x
# or in a pipeline:
@list |> map leap_year_gregorian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leapfrog-step">
<h3><a class="doc-anchor" href="#doc-leapfrog-step">#</a> <code>leapfrog_step</code></h3>
<p><code>leapfrog_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = leapfrog_step $x
# or in a pipeline:
@list |> map leapfrog_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-least-common">
<h3><a class="doc-anchor" href="#doc-least-common">#</a> <code>least_common</code></h3>
<p><code>least_common</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = least_common $x
# or in a pipeline:
@list |> map least_common |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leet">
<h3><a class="doc-anchor" href="#doc-leet">#</a> <code>leet</code></h3>
<p><code>leet</code> — string processing (uncategorized batch) builtin. Alias for <code>leetspeak</code>.</p>
<pre><code class="lang-perl">my $result = leet $x
# or in a pipeline:
@list |> map leet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leetspeak">
<h3><a class="doc-anchor" href="#doc-leetspeak">#</a> <code>leetspeak</code></h3>
<p><code>leetspeak</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = leetspeak $x
# or in a pipeline:
@list |> map leetspeak |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-left-str">
<h3><a class="doc-anchor" href="#doc-left-str">#</a> <code>left_str</code></h3>
<p><code>left_str</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = left_str $x
# or in a pipeline:
@list |> map left_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lehmer-mean">
<h3><a class="doc-anchor" href="#doc-lehmer-mean">#</a> <code>lehmer_mean</code></h3>
<p><code>lehmer_mean</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = lehmer_mean $x
# or in a pipeline:
@list |> map lehmer_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lemmatize-lemmy">
<h3><a class="doc-anchor" href="#doc-lemmatize-lemmy">#</a> <code>lemmatize_lemmy</code></h3>
<p><code>lemmatize_lemmy</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = lemmatize_lemmy $x
# or in a pipeline:
@list |> map lemmatize_lemmy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lemmatize-wordnet">
<h3><a class="doc-anchor" href="#doc-lemmatize-wordnet">#</a> <code>lemmatize_wordnet</code></h3>
<p><code>lemmatize_wordnet</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = lemmatize_wordnet $x
# or in a pipeline:
@list |> map lemmatize_wordnet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-length-each">
<h3><a class="doc-anchor" href="#doc-length-each">#</a> <code>length_each</code></h3>
<p><code>length_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = length_each $x
# or in a pipeline:
@list |> map length_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lens-focal-length">
<h3><a class="doc-anchor" href="#doc-lens-focal-length">#</a> <code>lens_focal_length</code></h3>
<p><code>lens_focal_length</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = lens_focal_length $x
# or in a pipeline:
@list |> map lens_focal_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lens-magnification">
<h3><a class="doc-anchor" href="#doc-lens-magnification">#</a> <code>lens_magnification</code></h3>
<p><code>lens_magnification</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = lens_magnification $x
# or in a pipeline:
@list |> map lens_magnification |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lens-power">
<h3><a class="doc-anchor" href="#doc-lens-power">#</a> <code>lens_power</code></h3>
<p><code>lens_power</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = lens_power $x
# or in a pipeline:
@list |> map lens_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lense-thirring-omega">
<h3><a class="doc-anchor" href="#doc-lense-thirring-omega">#</a> <code>lense_thirring_omega</code></h3>
<p><code>lense_thirring_omega</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = lense_thirring_omega $x
# or in a pipeline:
@list |> map lense_thirring_omega |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lensing-convergence">
<h3><a class="doc-anchor" href="#doc-lensing-convergence">#</a> <code>lensing_convergence</code></h3>
<p><code>lensing_convergence</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = lensing_convergence $x
# or in a pipeline:
@list |> map lensing_convergence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lensmaker">
<h3><a class="doc-anchor" href="#doc-lensmaker">#</a> <code>lensmaker</code></h3>
<p><code>lensmaker</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = lensmaker $x
# or in a pipeline:
@list |> map lensmaker |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leontief-input">
<h3><a class="doc-anchor" href="#doc-leontief-input">#</a> <code>leontief_input</code></h3>
<p><code>leontief_input</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = leontief_input $x
# or in a pipeline:
@list |> map leontief_input |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leontief-output">
<h3><a class="doc-anchor" href="#doc-leontief-output">#</a> <code>leontief_output</code></h3>
<p><code>leontief_output</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = leontief_output $x
# or in a pipeline:
@list |> map leontief_output |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lerner-index">
<h3><a class="doc-anchor" href="#doc-lerner-index">#</a> <code>lerner_index</code></h3>
<p><code>lerner_index</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = lerner_index $x
# or in a pipeline:
@list |> map lerner_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lerp">
<h3><a class="doc-anchor" href="#doc-lerp">#</a> <code>lerp</code></h3>
<p><code>lerp($a, $b, $t)</code> — linear interpolation between a and b. When t=0 returns a, t=1 returns b, t=0.5 returns midpoint.</p>
<pre><code class="lang-perl">p lerp(0, 100, 0.5) # 50
p lerp(10, 20, 0.25) # 12.5
# Animation: smoothly transition between values
for my $t (0:10) { p lerp($start, $end, $t/10) }
</code></pre>
</article>
<article class="doc-entry" id="doc-lerp-color">
<h3><a class="doc-anchor" href="#doc-lerp-color">#</a> <code>lerp_color</code></h3>
<p><code>lerp_color</code> — batch 9 builtin. Alias for <code>color_blend_t</code>.</p>
<pre><code class="lang-perl">my $result = lerp_color $x
# or in a pipeline:
@list |> map lerp_color |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leslie-step">
<h3><a class="doc-anchor" href="#doc-leslie-step">#</a> <code>leslie_step</code></h3>
<p><code>leslie_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = leslie_step $x
# or in a pipeline:
@list |> map leslie_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-less">
<h3><a class="doc-anchor" href="#doc-less">#</a> <code>less</code></h3>
<p><code>LIST |> pager</code> / <code>pager LIST</code> — pipe each element (one per line) into the user's <code>$PAGER</code> (default <code>less -R</code>; falls back to <code>more</code>, then plain stdout). Bypasses the pager when stdout isn't a TTY so pipelines like <code>stryke '... |> pager' | grep</code> still compose.</p>
<p>Blocks until the user quits the pager; returns <code>undef</code>.</p>
<p>Aliases: <code>pager</code>, <code>pg</code>, <code>less</code>.</p>
<pre><code class="lang-perl"># browse every callable spelling interactively
keys %all |> sort |> pager
# filter the reference for parallel ops
keys %b |> grep { $b{_} eq "parallel" } |> pager
# whole file, one screen at a time
slurp("README.md") |> pager
</code></pre>
</article>
<article class="doc-entry" id="doc-letter-frequency">
<h3><a class="doc-anchor" href="#doc-letter-frequency">#</a> <code>letter_frequency</code></h3>
<p><code>letter_frequency</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = letter_frequency $x
# or in a pipeline:
@list |> map letter_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-letters-lc">
<h3><a class="doc-anchor" href="#doc-letters-lc">#</a> <code>letters_lc</code></h3>
<p><code>letters_lc</code> extracts only lowercase letters from a string.</p>
<pre><code class="lang-perl">p join "", letters_lc("Hello World 123") # elloorld
</code></pre>
</article>
<article class="doc-entry" id="doc-letters-uc">
<h3><a class="doc-anchor" href="#doc-letters-uc">#</a> <code>letters_uc</code></h3>
<p><code>letters_uc</code> extracts only uppercase letters from a string.</p>
<pre><code class="lang-perl">p join "", letters_uc("Hello World 123") # HW
</code></pre>
</article>
<article class="doc-entry" id="doc-lev">
<h3><a class="doc-anchor" href="#doc-lev">#</a> <code>lev</code></h3>
<p><code>lev</code> — extended stdlib builtin. Alias for <code>levenshtein</code>.</p>
<pre><code class="lang-perl">my $result = lev $x
# or in a pipeline:
@list |> map lev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-level-k-step">
<h3><a class="doc-anchor" href="#doc-level-k-step">#</a> <code>level_k_step</code></h3>
<p><code>level_k_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = level_k_step $x
# or in a pipeline:
@list |> map level_k_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-level-premium">
<h3><a class="doc-anchor" href="#doc-level-premium">#</a> <code>level_premium</code></h3>
<p><code>level_premium</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = level_premium $x
# or in a pipeline:
@list |> map level_premium |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-levenshtein">
<h3><a class="doc-anchor" href="#doc-levenshtein">#</a> <code>levenshtein</code></h3>
<p><code>levenshtein</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = levenshtein $x
# or in a pipeline:
@list |> map levenshtein |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-levenshtein-dist">
<h3><a class="doc-anchor" href="#doc-levenshtein-dist">#</a> <code>levenshtein_dist</code></h3>
<p><code>levenshtein_dist</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = levenshtein_dist $x
# or in a pipeline:
@list |> map levenshtein_dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leverage-index">
<h3><a class="doc-anchor" href="#doc-leverage-index">#</a> <code>leverage_index</code></h3>
<p><code>leverage_index</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = leverage_index $x
# or in a pipeline:
@list |> map leverage_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-levi-civita-four">
<h3><a class="doc-anchor" href="#doc-levi-civita-four">#</a> <code>levi_civita_four</code></h3>
<p><code>levi_civita_four</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = levi_civita_four $x
# or in a pipeline:
@list |> map levi_civita_four |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-levi-civita-three">
<h3><a class="doc-anchor" href="#doc-levi-civita-three">#</a> <code>levi_civita_three</code></h3>
<p><code>levi_civita_three</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = levi_civita_three $x
# or in a pipeline:
@list |> map levi_civita_three |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-levich-current-rde">
<h3><a class="doc-anchor" href="#doc-levich-current-rde">#</a> <code>levich_current_rde</code></h3>
<p><code>levich_current_rde</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = levich_current_rde $x
# or in a pipeline:
@list |> map levich_current_rde |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-levin-t-transform">
<h3><a class="doc-anchor" href="#doc-levin-t-transform">#</a> <code>levin_t_transform</code></h3>
<p><code>levin_t_transform</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = levin_t_transform $x
# or in a pipeline:
@list |> map levin_t_transform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-levy-pdf">
<h3><a class="doc-anchor" href="#doc-levy-pdf">#</a> <code>levy_pdf</code></h3>
<p><code>levy_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = levy_pdf $x
# or in a pipeline:
@list |> map levy_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lewis-dot-count">
<h3><a class="doc-anchor" href="#doc-lewis-dot-count">#</a> <code>lewis_dot_count</code></h3>
<p><code>lewis_dot_count</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = lewis_dot_count $x
# or in a pipeline:
@list |> map lewis_dot_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lex-keyword-classify">
<h3><a class="doc-anchor" href="#doc-lex-keyword-classify">#</a> <code>lex_keyword_classify</code></h3>
<p><code>lex_keyword_classify</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = lex_keyword_classify $x
# or in a pipeline:
@list |> map lex_keyword_classify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lexicalized-parse">
<h3><a class="doc-anchor" href="#doc-lexicalized-parse">#</a> <code>lexicalized_parse</code></h3>
<p><code>lexicalized_parse</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = lexicalized_parse $x
# or in a pipeline:
@list |> map lexicalized_parse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lfilter-zi-init">
<h3><a class="doc-anchor" href="#doc-lfilter-zi-init">#</a> <code>lfilter_zi_init</code></h3>
<p><code>lfilter_zi_init</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = lfilter_zi_init $x
# or in a pipeline:
@list |> map lfilter_zi_init |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lfrm">
<h3><a class="doc-anchor" href="#doc-lfrm">#</a> <code>lfrm</code></h3>
<p><code>lfrm</code> — go/general functional utilities builtin. Alias for <code>lines_from</code>.</p>
<pre><code class="lang-perl">my $result = lfrm $x
# or in a pipeline:
@list |> map lfrm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lfsr-galois-step">
<h3><a class="doc-anchor" href="#doc-lfsr-galois-step">#</a> <code>lfsr_galois_step</code></h3>
<p><code>lfsr_galois_step</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = lfsr_galois_step $x
# or in a pipeline:
@list |> map lfsr_galois_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lie-derivative-scalar-step">
<h3><a class="doc-anchor" href="#doc-lie-derivative-scalar-step">#</a> <code>lie_derivative_scalar_step</code></h3>
<p><code>lie_derivative_scalar_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = lie_derivative_scalar_step $x
# or in a pipeline:
@list |> map lie_derivative_scalar_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lie-derivative-vector-step">
<h3><a class="doc-anchor" href="#doc-lie-derivative-vector-step">#</a> <code>lie_derivative_vector_step</code></h3>
<p><code>lie_derivative_vector_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = lie_derivative_vector_step $x
# or in a pipeline:
@list |> map lie_derivative_vector_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lie-split">
<h3><a class="doc-anchor" href="#doc-lie-split">#</a> <code>lie_split</code></h3>
<p><code>lie_split</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = lie_split $x
# or in a pipeline:
@list |> map lie_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-life-expectancy-e0">
<h3><a class="doc-anchor" href="#doc-life-expectancy-e0">#</a> <code>life_expectancy_e0</code></h3>
<p><code>life_expectancy_e0</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = life_expectancy_e0 $x
# or in a pipeline:
@list |> map life_expectancy_e0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-light-deflection-angle">
<h3><a class="doc-anchor" href="#doc-light-deflection-angle">#</a> <code>light_deflection_angle</code></h3>
<p><code>light_deflection_angle</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = light_deflection_angle $x
# or in a pipeline:
@list |> map light_deflection_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-light-year">
<h3><a class="doc-anchor" href="#doc-light-year">#</a> <code>light_year</code></h3>
<p><code>light_year</code> (alias <code>ly</code>) — ly ≈ 9.461×10¹⁵ m. Distance light travels in one year.</p>
<pre><code class="lang-perl">p ly # 9.4607304725808e15 m
p ly / au # ~63241 AU
</code></pre>
</article>
<article class="doc-entry" id="doc-likelihood-ratio-test">
<h3><a class="doc-anchor" href="#doc-likelihood-ratio-test">#</a> <code>likelihood_ratio_test</code></h3>
<p><code>likelihood_ratio_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = likelihood_ratio_test $x
# or in a pipeline:
@list |> map likelihood_ratio_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-limiting-current-density">
<h3><a class="doc-anchor" href="#doc-limiting-current-density">#</a> <code>limiting_current_density</code></h3>
<p><code>limiting_current_density</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = limiting_current_density $x
# or in a pipeline:
@list |> map limiting_current_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lin-bairstow-step">
<h3><a class="doc-anchor" href="#doc-lin-bairstow-step">#</a> <code>lin_bairstow_step</code></h3>
<p><code>lin_bairstow_step</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = lin_bairstow_step $x
# or in a pipeline:
@list |> map lin_bairstow_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lin-kernighan-step">
<h3><a class="doc-anchor" href="#doc-lin-kernighan-step">#</a> <code>lin_kernighan_step</code></h3>
<p><code>lin_kernighan_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = lin_kernighan_step $x
# or in a pipeline:
@list |> map lin_kernighan_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linc">
<h3><a class="doc-anchor" href="#doc-linc">#</a> <code>linc</code></h3>
<p><code>linc</code> — extended stdlib batch 3 builtin. Alias for <code>longest_increasing</code>.</p>
<pre><code class="lang-perl">my $result = linc $x
# or in a pipeline:
@list |> map linc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-line-count">
<h3><a class="doc-anchor" href="#doc-line-count">#</a> <code>line_count</code></h3>
<p><code>line_count</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = line_count $x
# or in a pipeline:
@list |> map line_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-line-count-simple">
<h3><a class="doc-anchor" href="#doc-line-count-simple">#</a> <code>line_count_simple</code></h3>
<p><code>line_count_simple</code> — batch 11 builtin. Alias for <code>string_lines_count</code>.</p>
<pre><code class="lang-perl">my $result = line_count_simple $x
# or in a pipeline:
@list |> map line_count_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-line-intersection">
<h3><a class="doc-anchor" href="#doc-line-intersection">#</a> <code>line_intersection</code></h3>
<p><code>line_intersection($x1, $y1, $x2, $y2, $x3, $y3, $x4, $y4)</code> — finds the intersection point of two lines defined by points (x1,y1)-(x2,y2) and (x3,y3)-(x4,y4). Returns [$x, $y] or undef if parallel.</p>
<pre><code class="lang-perl">my $pt = line_intersection(0, 0, 1, 1, 0, 1, 1, 0)
p @$pt # (0.5, 0.5)
</code></pre>
</article>
<article class="doc-entry" id="doc-linear-entropy">
<h3><a class="doc-anchor" href="#doc-linear-entropy">#</a> <code>linear_entropy</code></h3>
<p><code>linear_entropy</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = linear_entropy $x
# or in a pipeline:
@list |> map linear_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linear-regression">
<h3><a class="doc-anchor" href="#doc-linear-regression">#</a> <code>linear_regression</code></h3>
<p><code>linear_regression</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = linear_regression $x
# or in a pipeline:
@list |> map linear_regression |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linear-search">
<h3><a class="doc-anchor" href="#doc-linear-search">#</a> <code>linear_search</code></h3>
<p><code>linear_search</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = linear_search $x
# or in a pipeline:
@list |> map linear_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linearized-pb-step">
<h3><a class="doc-anchor" href="#doc-linearized-pb-step">#</a> <code>linearized_pb_step</code></h3>
<p><code>linearized_pb_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = linearized_pb_step $x
# or in a pipeline:
@list |> map linearized_pb_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lineintr">
<h3><a class="doc-anchor" href="#doc-lineintr">#</a> <code>lineintr</code></h3>
<p><code>lineintr</code> — geometry (extended) builtin. Alias for <code>line_intersection</code>.</p>
<pre><code class="lang-perl">my $result = lineintr $x
# or in a pipeline:
@list |> map lineintr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lines-from">
<h3><a class="doc-anchor" href="#doc-lines-from">#</a> <code>lines_from</code></h3>
<p><code>lines_from</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = lines_from $x
# or in a pipeline:
@list |> map lines_from |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lineweaver-burk">
<h3><a class="doc-anchor" href="#doc-lineweaver-burk">#</a> <code>lineweaver_burk</code></h3>
<p><code>lineweaver_burk</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = lineweaver_burk $x
# or in a pipeline:
@list |> map lineweaver_burk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linf-norm">
<h3><a class="doc-anchor" href="#doc-linf-norm">#</a> <code>linf_norm</code></h3>
<p><code>linf_norm</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = linf_norm $x
# or in a pipeline:
@list |> map linf_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linking-number-two">
<h3><a class="doc-anchor" href="#doc-linking-number-two">#</a> <code>linking_number_two</code></h3>
<p><code>linking_number_two</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = linking_number_two $x
# or in a pipeline:
@list |> map linking_number_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linreg">
<h3><a class="doc-anchor" href="#doc-linreg">#</a> <code>linreg</code></h3>
<p><code>linreg</code> — math / numeric (uncategorized batch) builtin. Alias for <code>linear_regression</code>.</p>
<pre><code class="lang-perl">my $result = linreg $x
# or in a pipeline:
@list |> map linreg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linspace">
<h3><a class="doc-anchor" href="#doc-linspace">#</a> <code>linspace</code></h3>
<p><code>linspace</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = linspace $x
# or in a pipeline:
@list |> map linspace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-liouville">
<h3><a class="doc-anchor" href="#doc-liouville">#</a> <code>liouville</code></h3>
<p><code>liouville</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = liouville $x
# or in a pipeline:
@list |> map liouville |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-liquefaction-potential-index">
<h3><a class="doc-anchor" href="#doc-liquefaction-potential-index">#</a> <code>liquefaction_potential_index</code></h3>
<p><code>liquefaction_potential_index</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = liquefaction_potential_index $x
# or in a pipeline:
@list |> map liquefaction_potential_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-coloring-step">
<h3><a class="doc-anchor" href="#doc-list-coloring-step">#</a> <code>list_coloring_step</code></h3>
<p><code>list_coloring_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = list_coloring_step $x
# or in a pipeline:
@list |> map list_coloring_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-compact">
<h3><a class="doc-anchor" href="#doc-list-compact">#</a> <code>list_compact</code></h3>
<p><code>list_compact</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = list_compact $x
# or in a pipeline:
@list |> map list_compact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-count">
<h3><a class="doc-anchor" href="#doc-list-count">#</a> <code>list_count</code></h3>
<p><code>list_count</code> (alias <code>list_size</code>) returns the total number of elements after flattening a nested list structure. Unlike <code>count</code> which returns the top-level element count, <code>list_count</code> recursively descends into array references and counts only leaf values. This is useful when you have a list of lists and need to know the total number of individual items rather than the number of sublists.</p>
<pre><code class="lang-perl">my @nested = ([1, 2], [3, 4, 5], [6])
p list_count @nested # 6
my @deep = ([1, [2, 3]], [4])
p list_size @deep # 4
p list_count 1, 2, 3 # 3 (flat list works too)
</code></pre>
</article>
<article class="doc-entry" id="doc-list-difference">
<h3><a class="doc-anchor" href="#doc-list-difference">#</a> <code>list_difference</code></h3>
<p><code>list_difference</code> — collection (batch 2) builtin. Alias for <code>array_difference</code>.</p>
<pre><code class="lang-perl">my $result = list_difference $x
# or in a pipeline:
@list |> map list_difference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-eq">
<h3><a class="doc-anchor" href="#doc-list-eq">#</a> <code>list_eq</code></h3>
<p><code>list_eq</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = list_eq $x
# or in a pipeline:
@list |> map list_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-flatten-deep">
<h3><a class="doc-anchor" href="#doc-list-flatten-deep">#</a> <code>list_flatten_deep</code></h3>
<p><code>list_flatten_deep</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = list_flatten_deep $x
# or in a pipeline:
@list |> map list_flatten_deep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-intersection">
<h3><a class="doc-anchor" href="#doc-list-intersection">#</a> <code>list_intersection</code></h3>
<p><code>list_intersection</code> — collection (batch 2) builtin. Alias for <code>array_intersection</code>.</p>
<pre><code class="lang-perl">my $result = list_intersection $x
# or in a pipeline:
@list |> map list_intersection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-reverse">
<h3><a class="doc-anchor" href="#doc-list-reverse">#</a> <code>list_reverse</code></h3>
<p><code>list_reverse</code> — file stat / path builtin. Alias for <code>reverse_list</code>.</p>
<pre><code class="lang-perl">my $result = list_reverse $x
# or in a pipeline:
@list |> map list_reverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-scheduling-step">
<h3><a class="doc-anchor" href="#doc-list-scheduling-step">#</a> <code>list_scheduling_step</code></h3>
<p><code>list_scheduling_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = list_scheduling_step $x
# or in a pipeline:
@list |> map list_scheduling_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-union">
<h3><a class="doc-anchor" href="#doc-list-union">#</a> <code>list_union</code></h3>
<p><code>list_union</code> — collection (batch 2) builtin. Alias for <code>array_union</code>.</p>
<pre><code class="lang-perl">my $result = list_union $x
# or in a pipeline:
@list |> map list_union |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-liters-to-gallons">
<h3><a class="doc-anchor" href="#doc-liters-to-gallons">#</a> <code>liters_to_gallons</code></h3>
<p><code>liters_to_gallons</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = liters_to_gallons $input
</code></pre>
</article>
<article class="doc-entry" id="doc-liters-to-ml">
<h3><a class="doc-anchor" href="#doc-liters-to-ml">#</a> <code>liters_to_ml</code></h3>
<p><code>liters_to_ml</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = liters_to_ml $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lithium-ion-diffusivity">
<h3><a class="doc-anchor" href="#doc-lithium-ion-diffusivity">#</a> <code>lithium_ion_diffusivity</code></h3>
<p><code>lithium_ion_diffusivity</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = lithium_ion_diffusivity $x
# or in a pipeline:
@list |> map lithium_ion_diffusivity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lix">
<h3><a class="doc-anchor" href="#doc-lix">#</a> <code>lix</code></h3>
<p><code>lix</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = lix $x
# or in a pipeline:
@list |> map lix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ljt">
<h3><a class="doc-anchor" href="#doc-ljt">#</a> <code>ljt</code></h3>
<p><code>ljt</code> — extended stdlib builtin. Alias for <code>ljust_text</code>.</p>
<pre><code class="lang-perl">my $result = ljt $x
# or in a pipeline:
@list |> map ljt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ljung-box-q">
<h3><a class="doc-anchor" href="#doc-ljung-box-q">#</a> <code>ljung_box_q</code></h3>
<p><code>ljung_box_q</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = ljung_box_q $x
# or in a pipeline:
@list |> map ljung_box_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ljust">
<h3><a class="doc-anchor" href="#doc-ljust">#</a> <code>ljust</code></h3>
<p><code>ljust</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = ljust $x
# or in a pipeline:
@list |> map ljust |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ljust-text">
<h3><a class="doc-anchor" href="#doc-ljust-text">#</a> <code>ljust_text</code></h3>
<p><code>ljust_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = ljust_text $x
# or in a pipeline:
@list |> map ljust_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lkpa">
<h3><a class="doc-anchor" href="#doc-lkpa">#</a> <code>lkpa</code></h3>
<p><code>lkpa</code> — haskell list functions builtin. Alias for <code>lookup_assoc</code>.</p>
<pre><code class="lang-perl">my $result = lkpa $x
# or in a pipeline:
@list |> map lkpa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ll1-first-set">
<h3><a class="doc-anchor" href="#doc-ll1-first-set">#</a> <code>ll1_first_set</code></h3>
<p><code>ll1_first_set</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = ll1_first_set $x
# or in a pipeline:
@list |> map ll1_first_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ll1-follow-set">
<h3><a class="doc-anchor" href="#doc-ll1-follow-set">#</a> <code>ll1_follow_set</code></h3>
<p><code>ll1_follow_set</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = ll1_follow_set $x
# or in a pipeline:
@list |> map ll1_follow_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ll1-predict-table">
<h3><a class="doc-anchor" href="#doc-ll1-predict-table">#</a> <code>ll1_predict_table</code></h3>
<p><code>ll1_predict_table</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = ll1_predict_table $x
# or in a pipeline:
@list |> map ll1_predict_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lll-2x2-step">
<h3><a class="doc-anchor" href="#doc-lll-2x2-step">#</a> <code>lll_2x2_step</code></h3>
<p><code>lll_2x2_step</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = lll_2x2_step $x
# or in a pipeline:
@list |> map lll_2x2_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lm">
<h3><a class="doc-anchor" href="#doc-lm">#</a> <code>lm</code></h3>
<p><code>lm_fit</code> (alias <code>lm</code>) — simple linear regression. Returns hash with intercept, slope, r_squared, residuals, fitted. Like R's lm().</p>
<pre><code class="lang-perl">my %m = %{lm([1,2,3,4,5], [2,4,5,4,5])}
p $m{slope} # slope
p $m{r_squared} # R²
</code></pre>
</article>
<article class="doc-entry" id="doc-lm-step">
<h3><a class="doc-anchor" href="#doc-lm-step">#</a> <code>lm_step</code></h3>
<p><code>lm_step</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = lm_step $x
# or in a pipeline:
@list |> map lm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ln10">
<h3><a class="doc-anchor" href="#doc-ln10">#</a> <code>ln10</code></h3>
<p><code>ln10</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = ln10 $x
# or in a pipeline:
@list |> map ln10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ln2">
<h3><a class="doc-anchor" href="#doc-ln2">#</a> <code>ln2</code></h3>
<p><code>ln2</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = ln2 $x
# or in a pipeline:
@list |> map ln2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lnormpdf">
<h3><a class="doc-anchor" href="#doc-lnormpdf">#</a> <code>lnormpdf</code></h3>
<p><code>lognormal_pdf</code> (alias <code>lnormpdf</code>) evaluates the log-normal distribution PDF at x with parameters mu and sigma.</p>
<pre><code class="lang-perl">p lnormpdf(1.0, 0, 1) # LogN(0,1) at x=1
</code></pre>
</article>
<article class="doc-entry" id="doc-lns">
<h3><a class="doc-anchor" href="#doc-lns">#</a> <code>lns</code></h3>
<p><code>lns</code> — math / numeric (uncategorized batch) builtin. Alias for <code>look_and_say</code>.</p>
<pre><code class="lang-perl">my $result = lns $x
# or in a pipeline:
@list |> map lns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-load-avg">
<h3><a class="doc-anchor" href="#doc-load-avg">#</a> <code>load_avg</code></h3>
<p><code>load_avg</code> — system load averages as a 3-element arrayref <code>[1min, 5min, 15min]</code>. Uses <code>getloadavg()</code> on unix. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">my $la = load_avg
p "1m=$la->[0] 5m=$la->[1] 15m=$la->[2]"
load_avg |> spark |> p # sparkline of load
</code></pre>
</article>
<article class="doc-entry" id="doc-load-centrality">
<h3><a class="doc-anchor" href="#doc-load-centrality">#</a> <code>load_centrality</code></h3>
<p><code>load_centrality</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = load_centrality $x
# or in a pipeline:
@list |> map load_centrality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-loan-balance">
<h3><a class="doc-anchor" href="#doc-loan-balance">#</a> <code>loan_balance</code></h3>
<p><code>loan_balance</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = loan_balance $x
# or in a pipeline:
@list |> map loan_balance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-loan-payment-pmt">
<h3><a class="doc-anchor" href="#doc-loan-payment-pmt">#</a> <code>loan_payment_pmt</code></h3>
<p><code>loan_payment_pmt</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = loan_payment_pmt $x
# or in a pipeline:
@list |> map loan_payment_pmt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lobatto-iiia-2">
<h3><a class="doc-anchor" href="#doc-lobatto-iiia-2">#</a> <code>lobatto_iiia_2</code></h3>
<p><code>lobatto_iiia_2</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = lobatto_iiia_2 $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lobatto-iiic-3">
<h3><a class="doc-anchor" href="#doc-lobatto-iiic-3">#</a> <code>lobatto_iiic_3</code></h3>
<p><code>lobatto_iiic_3</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = lobatto_iiic_3 $input
</code></pre>
</article>
<article class="doc-entry" id="doc-local-efficiency">
<h3><a class="doc-anchor" href="#doc-local-efficiency">#</a> <code>local_efficiency</code></h3>
<p><code>local_efficiency</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = local_efficiency $x
# or in a pipeline:
@list |> map local_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-local-search-swap-step">
<h3><a class="doc-anchor" href="#doc-local-search-swap-step">#</a> <code>local_search_swap_step</code></h3>
<p><code>local_search_swap_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = local_search_swap_step $x
# or in a pipeline:
@list |> map local_search_swap_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-loess">
<h3><a class="doc-anchor" href="#doc-loess">#</a> <code>loess</code></h3>
<p><code>lowess</code> (alias <code>loess</code>) — locally-weighted scatterplot smoothing (LOWESS/LOESS). Returns smoothed Y values with tricube weighting.</p>
<pre><code class="lang-perl">my @smooth = @{lowess([1,2,3,4,5], [2,1,4,3,5])}
</code></pre>
</article>
<article class="doc-entry" id="doc-log10">
<h3><a class="doc-anchor" href="#doc-log10">#</a> <code>log10</code></h3>
<p><code>log10</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = log10 $x
# or in a pipeline:
@list |> map log10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log1p-exp">
<h3><a class="doc-anchor" href="#doc-log1p-exp">#</a> <code>log1p_exp</code></h3>
<p><code>log1p_exp</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = log1p_exp $x
# or in a pipeline:
@list |> map log1p_exp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log2">
<h3><a class="doc-anchor" href="#doc-log2">#</a> <code>log2</code></h3>
<p><code>log2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = log2 $x
# or in a pipeline:
@list |> map log2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-base">
<h3><a class="doc-anchor" href="#doc-log-base">#</a> <code>log_base</code></h3>
<p><code>log_base</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = log_base $x
# or in a pipeline:
@list |> map log_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-gamma-simple">
<h3><a class="doc-anchor" href="#doc-log-gamma-simple">#</a> <code>log_gamma_simple</code></h3>
<p><code>log_gamma_simple</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = log_gamma_simple $x
# or in a pipeline:
@list |> map log_gamma_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-law-wind-profile">
<h3><a class="doc-anchor" href="#doc-log-law-wind-profile">#</a> <code>log_law_wind_profile</code></h3>
<p><code>log_law_wind_profile</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = log_law_wind_profile $x
# or in a pipeline:
@list |> map log_law_wind_profile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-loss">
<h3><a class="doc-anchor" href="#doc-log-loss">#</a> <code>log_loss</code></h3>
<p><code>log_loss</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = log_loss $x
# or in a pipeline:
@list |> map log_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-sigmoid">
<h3><a class="doc-anchor" href="#doc-log-sigmoid">#</a> <code>log_sigmoid</code></h3>
<p><code>log_sigmoid</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = log_sigmoid $x
# or in a pipeline:
@list |> map log_sigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-softmax">
<h3><a class="doc-anchor" href="#doc-log-softmax">#</a> <code>log_softmax</code></h3>
<p><code>log_softmax</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = log_softmax $x
# or in a pipeline:
@list |> map log_softmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-sum-exp">
<h3><a class="doc-anchor" href="#doc-log-sum-exp">#</a> <code>log_sum_exp</code></h3>
<p><code>log_sum_exp</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = log_sum_exp $x
# or in a pipeline:
@list |> map log_sum_exp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-with-base">
<h3><a class="doc-anchor" href="#doc-log-with-base">#</a> <code>log_with_base</code></h3>
<p><code>log_with_base</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = log_with_base $x
# or in a pipeline:
@list |> map log_with_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-logb">
<h3><a class="doc-anchor" href="#doc-logb">#</a> <code>logb</code></h3>
<p><code>logb</code> — extended stdlib builtin. Alias for <code>log_with_base</code>.</p>
<pre><code class="lang-perl">my $result = logb $x
# or in a pipeline:
@list |> map logb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-loggamma">
<h3><a class="doc-anchor" href="#doc-loggamma">#</a> <code>loggamma</code></h3>
<p><code>loggamma</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = loggamma $x
# or in a pipeline:
@list |> map loggamma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-logistic-growth-analytic">
<h3><a class="doc-anchor" href="#doc-logistic-growth-analytic">#</a> <code>logistic_growth_analytic</code></h3>
<p><code>logistic_growth_analytic</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = logistic_growth_analytic $x
# or in a pipeline:
@list |> map logistic_growth_analytic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-logistic-growth-step">
<h3><a class="doc-anchor" href="#doc-logistic-growth-step">#</a> <code>logistic_growth_step</code></h3>
<p><code>logistic_growth_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = logistic_growth_step $x
# or in a pipeline:
@list |> map logistic_growth_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-logistic-loss">
<h3><a class="doc-anchor" href="#doc-logistic-loss">#</a> <code>logistic_loss</code></h3>
<p><code>logistic_loss</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = logistic_loss $x
# or in a pipeline:
@list |> map logistic_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-logit-log-likelihood">
<h3><a class="doc-anchor" href="#doc-logit-log-likelihood">#</a> <code>logit_log_likelihood</code></h3>
<p><code>logit_log_likelihood</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = logit_log_likelihood $x
# or in a pipeline:
@list |> map logit_log_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lomax-pdf">
<h3><a class="doc-anchor" href="#doc-lomax-pdf">#</a> <code>lomax_pdf</code></h3>
<p><code>lomax_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = lomax_pdf $x
# or in a pipeline:
@list |> map lomax_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lombscargle-freq">
<h3><a class="doc-anchor" href="#doc-lombscargle-freq">#</a> <code>lombscargle_freq</code></h3>
<p><code>lombscargle_freq</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = lombscargle_freq $x
# or in a pipeline:
@list |> map lombscargle_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest">
<h3><a class="doc-anchor" href="#doc-longest">#</a> <code>longest</code></h3>
<p><code>longest</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = longest $x
# or in a pipeline:
@list |> map longest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-common-prefix">
<h3><a class="doc-anchor" href="#doc-longest-common-prefix">#</a> <code>longest_common_prefix</code></h3>
<p><code>longest_common_prefix</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = longest_common_prefix $x
# or in a pipeline:
@list |> map longest_common_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-common-subsequence">
<h3><a class="doc-anchor" href="#doc-longest-common-subsequence">#</a> <code>longest_common_subsequence</code></h3>
<p><code>longest_common_subsequence</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_common_subsequence $x
# or in a pipeline:
@list |> map longest_common_subsequence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-common-substring">
<h3><a class="doc-anchor" href="#doc-longest-common-substring">#</a> <code>longest_common_substring</code></h3>
<p><code>longest_common_substring</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_common_substring $x
# or in a pipeline:
@list |> map longest_common_substring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-decreasing">
<h3><a class="doc-anchor" href="#doc-longest-decreasing">#</a> <code>longest_decreasing</code></h3>
<p><code>longest_decreasing</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_decreasing $x
# or in a pipeline:
@list |> map longest_decreasing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-increasing">
<h3><a class="doc-anchor" href="#doc-longest-increasing">#</a> <code>longest_increasing</code></h3>
<p><code>longest_increasing</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_increasing $x
# or in a pipeline:
@list |> map longest_increasing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-run">
<h3><a class="doc-anchor" href="#doc-longest-run">#</a> <code>longest_run</code></h3>
<p><code>longest_run</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_run $x
# or in a pipeline:
@list |> map longest_run |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-look-and-say">
<h3><a class="doc-anchor" href="#doc-look-and-say">#</a> <code>look_and_say</code></h3>
<p><code>look_and_say</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = look_and_say $x
# or in a pipeline:
@list |> map look_and_say |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lookback-call">
<h3><a class="doc-anchor" href="#doc-lookback-call">#</a> <code>lookback_call</code></h3>
<p><code>lookback_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = lookback_call $x
# or in a pipeline:
@list |> map lookback_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lookback-time">
<h3><a class="doc-anchor" href="#doc-lookback-time">#</a> <code>lookback_time</code></h3>
<p><code>lookback_time</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = lookback_time $x
# or in a pipeline:
@list |> map lookback_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lookup-assoc">
<h3><a class="doc-anchor" href="#doc-lookup-assoc">#</a> <code>lookup_assoc</code></h3>
<p><code>lookup_assoc</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = lookup_assoc $x
# or in a pipeline:
@list |> map lookup_assoc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lorentz">
<h3><a class="doc-anchor" href="#doc-lorentz">#</a> <code>lorentz</code></h3>
<p><code>lorentz_factor($velocity)</code> (alias <code>lorentz</code>) — relativistic gamma factor γ = 1/√(1-v²/c²). Returns infinity at v ≥ c.</p>
<pre><code class="lang-perl">p lorentz(0) # 1 (at rest)
p lorentz(0.9 * 3e8) # ~2.29 (at 90% speed of light)
</code></pre>
</article>
<article class="doc-entry" id="doc-lorentz-factor-v">
<h3><a class="doc-anchor" href="#doc-lorentz-factor-v">#</a> <code>lorentz_factor_v</code></h3>
<p><code>lorentz_factor_v</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = lorentz_factor_v $x
# or in a pipeline:
@list |> map lorentz_factor_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lorentz-force-mag">
<h3><a class="doc-anchor" href="#doc-lorentz-force-mag">#</a> <code>lorentz_force_mag</code></h3>
<p><code>lorentz_force_mag</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = lorentz_force_mag $x
# or in a pipeline:
@list |> map lorentz_force_mag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lorentz-gamma">
<h3><a class="doc-anchor" href="#doc-lorentz-gamma">#</a> <code>lorentz_gamma</code></h3>
<p><code>lorentz_gamma</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = lorentz_gamma $x
# or in a pipeline:
@list |> map lorentz_gamma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lorenz">
<h3><a class="doc-anchor" href="#doc-lorenz">#</a> <code>lorenz</code></h3>
<p><code>lorenz_curve(@data)</code> (alias <code>lorenz</code>) — computes the Lorenz curve as an arrayref of [cumulative_share_of_population, cumulative_share_of_wealth] pairs. Used to visualize inequality. The diagonal represents perfect equality.</p>
<pre><code class="lang-perl">my $curve = lorenz(10, 20, 30, 40)
for my $pt (@$curve) {
p "$pt->[0], $pt->[1]"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-lose-lose">
<h3><a class="doc-anchor" href="#doc-lose-lose">#</a> <code>lose_lose</code></h3>
<p><code>lose_lose</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = lose_lose $x
# or in a pipeline:
@list |> map lose_lose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-loss-frequency-poisson">
<h3><a class="doc-anchor" href="#doc-loss-frequency-poisson">#</a> <code>loss_frequency_poisson</code></h3>
<p><code>loss_frequency_poisson</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = loss_frequency_poisson $x
# or in a pipeline:
@list |> map loss_frequency_poisson |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-loss-severity-lognormal">
<h3><a class="doc-anchor" href="#doc-loss-severity-lognormal">#</a> <code>loss_severity_lognormal</code></h3>
<p><code>loss_severity_lognormal</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = loss_severity_lognormal $x
# or in a pipeline:
@list |> map loss_severity_lognormal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lotka-volterra-step">
<h3><a class="doc-anchor" href="#doc-lotka-volterra-step">#</a> <code>lotka_volterra_step</code></h3>
<p><code>lotka_volterra_step</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = lotka_volterra_step $x
# or in a pipeline:
@list |> map lotka_volterra_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-louvain-gain">
<h3><a class="doc-anchor" href="#doc-louvain-gain">#</a> <code>louvain_gain</code></h3>
<p><code>louvain_gain</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = louvain_gain $x
# or in a pipeline:
@list |> map louvain_gain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lower-bound">
<h3><a class="doc-anchor" href="#doc-lower-bound">#</a> <code>lower_bound</code></h3>
<p><code>lower_bound</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = lower_bound $x
# or in a pipeline:
@list |> map lower_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lower-triangular-q">
<h3><a class="doc-anchor" href="#doc-lower-triangular-q">#</a> <code>lower_triangular_q</code></h3>
<p><code>lower_triangular_q</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = lower_triangular_q $x
# or in a pipeline:
@list |> map lower_triangular_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lowercase">
<h3><a class="doc-anchor" href="#doc-lowercase">#</a> <code>lowercase</code></h3>
<p><code>lowercase</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = lowercase $x
# or in a pipeline:
@list |> map lowercase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lowpass-filter">
<h3><a class="doc-anchor" href="#doc-lowpass-filter">#</a> <code>lowpass_filter</code></h3>
<p><code>lowpass_filter(\@signal, $cutoff)</code> (alias <code>lpf</code>) — applies a simple low-pass filter to remove high-frequency components. Cutoff is normalized (0-1). Uses exponential moving average.</p>
<pre><code class="lang-perl">my @noisy = map { sin(_/10) + rand(0.2) } 1:100
my $smooth = lpf(\@noisy, 0.1)
</code></pre>
</article>
<article class="doc-entry" id="doc-lp-norm">
<h3><a class="doc-anchor" href="#doc-lp-norm">#</a> <code>lp_norm</code></h3>
<p><code>lp_norm</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = lp_norm $x
# or in a pipeline:
@list |> map lp_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lp-relax-round">
<h3><a class="doc-anchor" href="#doc-lp-relax-round">#</a> <code>lp_relax_round</code></h3>
<p><code>lp_relax_round</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = lp_relax_round $x
# or in a pipeline:
@list |> map lp_relax_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lpad">
<h3><a class="doc-anchor" href="#doc-lpad">#</a> <code>lpad</code></h3>
<p><code>lpad</code> — trivial string ops builtin. Alias for <code>pad_left</code>.</p>
<pre><code class="lang-perl">my $result = lpad $x
# or in a pipeline:
@list |> map lpad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lplanck">
<h3><a class="doc-anchor" href="#doc-lplanck">#</a> <code>lplanck</code></h3>
<p><code>planck_length</code> (alias <code>lplanck</code>) — lP ≈ 1.616×10⁻³⁵ m. Smallest meaningful length in quantum mechanics.</p>
<pre><code class="lang-perl">p lplanck # 1.616255e-35 m
</code></pre>
</article>
<article class="doc-entry" id="doc-lpt">
<h3><a class="doc-anchor" href="#doc-lpt">#</a> <code>lpt</code></h3>
<p><code>lpt</code> — batch 10 builtin. Alias for <code>lpt_schedule</code>.</p>
<pre><code class="lang-perl">my $result = lpt $x
# or in a pipeline:
@list |> map lpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lpt-schedule">
<h3><a class="doc-anchor" href="#doc-lpt-schedule">#</a> <code>lpt_schedule</code></h3>
<p><code>lpt_schedule</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = lpt_schedule $x
# or in a pipeline:
@list |> map lpt_schedule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lpush">
<h3><a class="doc-anchor" href="#doc-lpush">#</a> <code>lpush</code></h3>
<p><code>lpush</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = lpush $x
# or in a pipeline:
@list |> map lpush |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lqg-step">
<h3><a class="doc-anchor" href="#doc-lqg-step">#</a> <code>lqg_step</code></h3>
<p><code>lqg_step</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = lqg_step $x
# or in a pipeline:
@list |> map lqg_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lqr-gain-continuous">
<h3><a class="doc-anchor" href="#doc-lqr-gain-continuous">#</a> <code>lqr_gain_continuous</code></h3>
<p><code>lqr_gain_continuous</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = lqr_gain_continuous $x
# or in a pipeline:
@list |> map lqr_gain_continuous |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lqr-gain-discrete">
<h3><a class="doc-anchor" href="#doc-lqr-gain-discrete">#</a> <code>lqr_gain_discrete</code></h3>
<p><code>lqr_gain_discrete</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = lqr_gain_discrete $x
# or in a pipeline:
@list |> map lqr_gain_discrete |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lr0-items-step">
<h3><a class="doc-anchor" href="#doc-lr0-items-step">#</a> <code>lr0_items_step</code></h3>
<p><code>lr0_items_step</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = lr0_items_step $x
# or in a pipeline:
@list |> map lr0_items_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lr1-canonical-collection">
<h3><a class="doc-anchor" href="#doc-lr1-canonical-collection">#</a> <code>lr1_canonical_collection</code></h3>
<p><code>lr1_canonical_collection</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = lr1_canonical_collection $x
# or in a pipeline:
@list |> map lr1_canonical_collection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lrange">
<h3><a class="doc-anchor" href="#doc-lrange">#</a> <code>lrange</code></h3>
<p><code>lrange</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = lrange $x
# or in a pipeline:
@list |> map lrange |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lrem">
<h3><a class="doc-anchor" href="#doc-lrem">#</a> <code>lrem</code></h3>
<p><code>lrem</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = lrem $x
# or in a pipeline:
@list |> map lrem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lru-new">
<h3><a class="doc-anchor" href="#doc-lru-new">#</a> <code>lru_new</code></h3>
<p><code>lru_new</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = lru_new $x
# or in a pipeline:
@list |> map lru_new |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lrun">
<h3><a class="doc-anchor" href="#doc-lrun">#</a> <code>lrun</code></h3>
<p><code>lrun</code> — extended stdlib batch 3 builtin. Alias for <code>longest_run</code>.</p>
<pre><code class="lang-perl">my $result = lrun $x
# or in a pipeline:
@list |> map lrun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lse">
<h3><a class="doc-anchor" href="#doc-lse">#</a> <code>lse</code></h3>
<p><code>lse</code> — batch 11 builtin. Alias for <code>log_sum_exp</code>.</p>
<pre><code class="lang-perl">my $result = lse $x
# or in a pipeline:
@list |> map lse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lsearch">
<h3><a class="doc-anchor" href="#doc-lsearch">#</a> <code>lsearch</code></h3>
<p><code>lsearch</code> — collection (batch 2) builtin. Alias for <code>linear_search</code>.</p>
<pre><code class="lang-perl">my $result = lsearch $x
# or in a pipeline:
@list |> map lsearch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lsp-completion-words">
<h3><a class="doc-anchor" href="#doc-lsp-completion-words">#</a> <code>lsp_completion_words</code></h3>
<p><code>lsp_completion_words</code> (alias <code>lsp_words</code>) — emits every name LSP tab-complete should know about, sorted ASCII. Three sources merged: (1) every callable bare-name spelling from <code>%all</code> (~9k names, primaries + aliases), (2) sigil-prefixed live bindings (<code>%a</code>, <code>%all</code>, <code>%b</code>, <code>%parameters</code>, <code>@ARGV</code>, <code>@INC</code>, <code>@fpath</code>, <code>@path</code>, <code>$_</code>, <code>$stryke::VERSION</code>, …), (3) <code>CORE::</code>/<code>main::</code> qualified spellings of every callable / unqualified binding, plus stryke language keywords (<code>fn</code>, <code>match</code>, <code>class</code>, <code>struct</code>, <code>enum</code>, <code>mysync</code>, <code>frozen</code>, …). Drives the canonical <code>strykelang/lsp_completion_words.txt</code> snapshot consumed by both the static analyzer (linter) and LSP completion provider.</p>
<pre><code class="lang-perl">lsp_words |> ep # browse everything
p len(lsp_words) # ~18,000 entries
# Regenerate the on-disk snapshot:
# stryke -e 'lsp_words |> ep' > strykelang/lsp_completion_words.txt
</code></pre>
</article>
<article class="doc-entry" id="doc-lst-to-solar">
<h3><a class="doc-anchor" href="#doc-lst-to-solar">#</a> <code>lst_to_solar</code></h3>
<p><code>lst_to_solar</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = lst_to_solar $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lstat">
<h3><a class="doc-anchor" href="#doc-lstat">#</a> <code>lstat</code></h3>
<p><code>lstat</code> — filesystem builtin.</p>
<pre><code class="lang-perl">my $result = lstat $x
# or in a pipeline:
@list |> map lstat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lucas">
<h3><a class="doc-anchor" href="#doc-lucas">#</a> <code>lucas</code></h3>
<p><code>lucas</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = lucas $x
# or in a pipeline:
@list |> map lucas |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-luhn">
<h3><a class="doc-anchor" href="#doc-luhn">#</a> <code>luhn</code></h3>
<p><code>luhn</code> — math / numeric (uncategorized batch) builtin. Alias for <code>luhn_check</code>.</p>
<pre><code class="lang-perl">my $result = luhn $x
# or in a pipeline:
@list |> map luhn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-luhn-check">
<h3><a class="doc-anchor" href="#doc-luhn-check">#</a> <code>luhn_check</code></h3>
<p><code>luhn_check</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = luhn_check $x
# or in a pipeline:
@list |> map luhn_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-luminance-relative">
<h3><a class="doc-anchor" href="#doc-luminance-relative">#</a> <code>luminance_relative</code></h3>
<p><code>luminance_relative</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = luminance_relative $x
# or in a pipeline:
@list |> map luminance_relative |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lunation-index">
<h3><a class="doc-anchor" href="#doc-lunation-index">#</a> <code>lunation_index</code></h3>
<p><code>lunation_index</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = lunation_index $x
# or in a pipeline:
@list |> map lunation_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lv-competition-step">
<h3><a class="doc-anchor" href="#doc-lv-competition-step">#</a> <code>lv_competition_step</code></h3>
<p><code>lv_competition_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = lv_competition_step $x
# or in a pipeline:
@list |> map lv_competition_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ly-to-pc">
<h3><a class="doc-anchor" href="#doc-ly-to-pc">#</a> <code>ly_to_pc</code></h3>
<p><code>ly_to_pc</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = ly_to_pc $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lyndon-factorize">
<h3><a class="doc-anchor" href="#doc-lyndon-factorize">#</a> <code>lyndon_factorize</code></h3>
<p><code>lyndon_factorize</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = lyndon_factorize $x
# or in a pipeline:
@list |> map lyndon_factorize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lz">
<h3><a class="doc-anchor" href="#doc-lz">#</a> <code>lz</code></h3>
<p><code>lz</code> — base conversion builtin. Alias for <code>leading_zeros</code>.</p>
<pre><code class="lang-perl">my $result = lz $x
# or in a pipeline:
@list |> map lz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lz4-block-step">
<h3><a class="doc-anchor" href="#doc-lz4-block-step">#</a> <code>lz4_block_step</code></h3>
<p><code>lz4_block_step</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = lz4_block_step $x
# or in a pipeline:
@list |> map lz4_block_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lz4-encode-block">
<h3><a class="doc-anchor" href="#doc-lz4-encode-block">#</a> <code>lz4_encode_block</code></h3>
<p><code>lz4_encode_block</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = lz4_encode_block $x
# or in a pipeline:
@list |> map lz4_encode_block |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lz4-match-offset">
<h3><a class="doc-anchor" href="#doc-lz4-match-offset">#</a> <code>lz4_match_offset</code></h3>
<p><code>lz4_match_offset</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = lz4_match_offset $x
# or in a pipeline:
@list |> map lz4_match_offset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lz77-match-length">
<h3><a class="doc-anchor" href="#doc-lz77-match-length">#</a> <code>lz77_match_length</code></h3>
<p><code>lz77_match_length</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = lz77_match_length $x
# or in a pipeline:
@list |> map lz77_match_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lz78-dictionary-growth">
<h3><a class="doc-anchor" href="#doc-lz78-dictionary-growth">#</a> <code>lz78_dictionary_growth</code></h3>
<p><code>lz78_dictionary_growth</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = lz78_dictionary_growth $x
# or in a pipeline:
@list |> map lz78_dictionary_growth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lzma-encode-step">
<h3><a class="doc-anchor" href="#doc-lzma-encode-step">#</a> <code>lzma_encode_step</code></h3>
<p><code>lzma_encode_step</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = lzma_encode_step $x
# or in a pipeline:
@list |> map lzma_encode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lzma-range-step">
<h3><a class="doc-anchor" href="#doc-lzma-range-step">#</a> <code>lzma_range_step</code></h3>
<p><code>lzma_range_step</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = lzma_range_step $x
# or in a pipeline:
@list |> map lzma_range_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lzo-encode-step">
<h3><a class="doc-anchor" href="#doc-lzo-encode-step">#</a> <code>lzo_encode_step</code></h3>
<p><code>lzo_encode_step</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = lzo_encode_step $x
# or in a pipeline:
@list |> map lzo_encode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lzw-encode">
<h3><a class="doc-anchor" href="#doc-lzw-encode">#</a> <code>lzw_encode</code></h3>
<p><code>lzw_encode</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = lzw_encode $x
# or in a pipeline:
@list |> map lzw_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lzw-step-dict">
<h3><a class="doc-anchor" href="#doc-lzw-step-dict">#</a> <code>lzw_step_dict</code></h3>
<p><code>lzw_step_dict</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = lzw_step_dict $x
# or in a pipeline:
@list |> map lzw_step_dict |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-m5">
<h3><a class="doc-anchor" href="#doc-m5">#</a> <code>m5</code></h3>
<p><code>m5</code> — crypto / encoding builtin. Alias for <code>md5</code>.</p>
<pre><code class="lang-perl">my $result = m5 $x
# or in a pipeline:
@list |> map m5 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-m-to-feet">
<h3><a class="doc-anchor" href="#doc-m-to-feet">#</a> <code>m_to_feet</code></h3>
<p><code>m_to_feet</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = m_to_feet $input
</code></pre>
</article>
<article class="doc-entry" id="doc-m-to-miles">
<h3><a class="doc-anchor" href="#doc-m-to-miles">#</a> <code>m_to_miles</code></h3>
<p><code>m_to_miles</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = m_to_miles $input
</code></pre>
</article>
<article class="doc-entry" id="doc-m-to-s">
<h3><a class="doc-anchor" href="#doc-m-to-s">#</a> <code>m_to_s</code></h3>
<p><code>m_to_s</code> — unit conversions builtin. Alias for <code>minutes_to_seconds</code>.</p>
<pre><code class="lang-perl">my $result = m_to_s $input
</code></pre>
</article>
<article class="doc-entry" id="doc-m-to-yards">
<h3><a class="doc-anchor" href="#doc-m-to-yards">#</a> <code>m_to_yards</code></h3>
<p><code>m_to_yards</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = m_to_yards $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ma-model-likelihood">
<h3><a class="doc-anchor" href="#doc-ma-model-likelihood">#</a> <code>ma_model_likelihood</code></h3>
<p><code>ma_model_likelihood</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = ma_model_likelihood $x
# or in a pipeline:
@list |> map ma_model_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mac-duration">
<h3><a class="doc-anchor" href="#doc-mac-duration">#</a> <code>mac_duration</code></h3>
<p><code>bond_duration</code> (alias <code>mac_duration</code>) computes Macaulay duration — the weighted-average time to receive cash flows.</p>
<pre><code class="lang-perl">my $dur = bond_duration([5,5,5,105], 0.05) # ≈ 3.72 years
</code></pre>
</article>
<article class="doc-entry" id="doc-macarthur-wilson-extinction">
<h3><a class="doc-anchor" href="#doc-macarthur-wilson-extinction">#</a> <code>macarthur_wilson_extinction</code></h3>
<p><code>macarthur_wilson_extinction</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = macarthur_wilson_extinction $x
# or in a pipeline:
@list |> map macarthur_wilson_extinction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-macarthur-wilson-immigration">
<h3><a class="doc-anchor" href="#doc-macarthur-wilson-immigration">#</a> <code>macarthur_wilson_immigration</code></h3>
<p><code>macarthur_wilson_immigration</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = macarthur_wilson_immigration $x
# or in a pipeline:
@list |> map macarthur_wilson_immigration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-macaulay-duration">
<h3><a class="doc-anchor" href="#doc-macaulay-duration">#</a> <code>macaulay_duration</code></h3>
<p><code>macaulay_duration</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = macaulay_duration $x
# or in a pipeline:
@list |> map macaulay_duration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-macauley-duration">
<h3><a class="doc-anchor" href="#doc-macauley-duration">#</a> <code>macauley_duration</code></h3>
<p><code>macauley_duration</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = macauley_duration $x
# or in a pipeline:
@list |> map macauley_duration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-macdur">
<h3><a class="doc-anchor" href="#doc-macdur">#</a> <code>macdur</code></h3>
<p><code>macdur</code> — finance (extended) builtin. Alias for <code>duration</code>.</p>
<pre><code class="lang-perl">my $result = macdur $x
# or in a pipeline:
@list |> map macdur |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mach-full-step">
<h3><a class="doc-anchor" href="#doc-mach-full-step">#</a> <code>mach_full_step</code></h3>
<p><code>mach_full_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = mach_full_step $x
# or in a pipeline:
@list |> map mach_full_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mad">
<h3><a class="doc-anchor" href="#doc-mad">#</a> <code>mad</code></h3>
<p><code>mad</code> — math / numeric (uncategorized batch) builtin. Alias for <code>median_absolute_deviation</code>.</p>
<pre><code class="lang-perl">my $result = mad $x
# or in a pipeline:
@list |> map mad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-madd">
<h3><a class="doc-anchor" href="#doc-madd">#</a> <code>madd</code></h3>
<p><code>madd</code> — extended stdlib builtin. Alias for <code>matrix_add</code>.</p>
<pre><code class="lang-perl">my $result = madd $x
# or in a pipeline:
@list |> map madd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mae">
<h3><a class="doc-anchor" href="#doc-mae">#</a> <code>mae</code></h3>
<p><code>mae</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = mae $x
# or in a pipeline:
@list |> map mae |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mag">
<h3><a class="doc-anchor" href="#doc-mag">#</a> <code>mag</code></h3>
<p><code>mag</code> — extended stdlib builtin. Alias for <code>magnitude</code>.</p>
<pre><code class="lang-perl">my $result = mag $x
# or in a pipeline:
@list |> map mag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magenta">
<h3><a class="doc-anchor" href="#doc-magenta">#</a> <code>magenta</code></h3>
<p><code>magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = magenta $x
# or in a pipeline:
@list |> map magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magenta-bold">
<h3><a class="doc-anchor" href="#doc-magenta-bold">#</a> <code>magenta_bold</code></h3>
<p><code>magenta_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = magenta_bold $x
# or in a pipeline:
@list |> map magenta_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maglens">
<h3><a class="doc-anchor" href="#doc-maglens">#</a> <code>maglens</code></h3>
<p><code>maglens</code> — physics formulas builtin. Alias for <code>magnification_lens</code>.</p>
<pre><code class="lang-perl">my $result = maglens $x
# or in a pipeline:
@list |> map maglens |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magnification-lens">
<h3><a class="doc-anchor" href="#doc-magnification-lens">#</a> <code>magnification_lens</code></h3>
<p><code>magnification_lens</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = magnification_lens $x
# or in a pipeline:
@list |> map magnification_lens |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magnitude">
<h3><a class="doc-anchor" href="#doc-magnitude">#</a> <code>magnitude</code></h3>
<p><code>magnitude</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = magnitude $x
# or in a pipeline:
@list |> map magnitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magnus-1st">
<h3><a class="doc-anchor" href="#doc-magnus-1st">#</a> <code>magnus_1st</code></h3>
<p><code>magnus_1st</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = magnus_1st $x
# or in a pipeline:
@list |> map magnus_1st |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mahal">
<h3><a class="doc-anchor" href="#doc-mahal">#</a> <code>mahal</code></h3>
<p><code>mahalanobis</code> — Mahalanobis distance. Args: data, center, inverse_covariance. Like R's mahalanobis().</p>
<pre><code class="lang-perl">my @d = @{mahal([[1,2],[3,4]], [2,3], [[1,0],[0,1]])}
</code></pre>
</article>
<article class="doc-entry" id="doc-mahalanobis-1d">
<h3><a class="doc-anchor" href="#doc-mahalanobis-1d">#</a> <code>mahalanobis_1d</code></h3>
<p><code>mahalanobis_1d</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = mahalanobis_1d $x
# or in a pipeline:
@list |> map mahalanobis_1d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-main">
<h3><a class="doc-anchor" href="#doc-main">#</a> <code>main</code></h3>
<p><code>main::</code> — the default package every script starts in. <code>our</code> variables and <code>fn</code> declarations without an explicit <code>package</code> directive land in <code>main::</code>; bare references like <code>$x</code> / <code>@a</code> / <code>%h</code> resolve to <code>$main::x</code> / <code>@main::a</code> / <code>%main::h</code> when looked up via the symbol table.</p>
<p>Use <code>main::</code> qualifier when you need to disambiguate inside a nested package, or when introspecting a script from a library context.</p>
<pre><code class="lang-perl">our $verbose = 1
p $main::verbose # 1 — same scalar
# Inside a class, the bare name resolves to the class — main:: gets you out:
class Foo {
fn check { p $main::verbose } # reads top-level our
}
# %main:: is the symbol-table stash. Lists every name declared
# at the top level (subs, our, our @, our %).
p scalar keys %main:: # symbol-table size
keys %main:: |> sort |> p # browse every top-level name
</code></pre>
<p>Related namespaces: <code>CORE::</code> (every builtin), <code>stryke::</code> (reflection hashes — <code>%stryke::builtins</code> etc.), and <code>Pkg::</code> for any user-declared <code>package Pkg</code>.</p>
</article>
<article class="doc-entry" id="doc-main-sequence-lifetime">
<h3><a class="doc-anchor" href="#doc-main-sequence-lifetime">#</a> <code>main_sequence_lifetime</code></h3>
<p><code>main_sequence_lifetime</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = main_sequence_lifetime $x
# or in a pipeline:
@list |> map main_sequence_lifetime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mainardi-codazzi-step">
<h3><a class="doc-anchor" href="#doc-mainardi-codazzi-step">#</a> <code>mainardi_codazzi_step</code></h3>
<p><code>mainardi_codazzi_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = mainardi_codazzi_step $x
# or in a pipeline:
@list |> map mainardi_codazzi_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-majority">
<h3><a class="doc-anchor" href="#doc-majority">#</a> <code>majority</code></h3>
<p><code>majority</code> — extended stdlib batch 3 builtin. Alias for <code>majority_element</code>.</p>
<pre><code class="lang-perl">my $result = majority $x
# or in a pipeline:
@list |> map majority |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-majority-element">
<h3><a class="doc-anchor" href="#doc-majority-element">#</a> <code>majority_element</code></h3>
<p><code>majority_element</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = majority_element $x
# or in a pipeline:
@list |> map majority_element |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mall">
<h3><a class="doc-anchor" href="#doc-mall">#</a> <code>mall</code></h3>
<p><code>mall</code> — extended stdlib builtin. Alias for <code>match_all</code>.</p>
<pre><code class="lang-perl">my $result = mall $x
# or in a pipeline:
@list |> map mall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mallat-pyramid-step">
<h3><a class="doc-anchor" href="#doc-mallat-pyramid-step">#</a> <code>mallat_pyramid_step</code></h3>
<p><code>mallat_pyramid_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = mallat_pyramid_step $x
# or in a pipeline:
@list |> map mallat_pyramid_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-manacher">
<h3><a class="doc-anchor" href="#doc-manacher">#</a> <code>manacher</code></h3>
<p><code>manacher</code> — batch 10 builtin. Alias for <code>manacher_radii</code>.</p>
<pre><code class="lang-perl">my $result = manacher $x
# or in a pipeline:
@list |> map manacher |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-manacher-radii">
<h3><a class="doc-anchor" href="#doc-manacher-radii">#</a> <code>manacher_radii</code></h3>
<p><code>manacher_radii</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = manacher_radii $x
# or in a pipeline:
@list |> map manacher_radii |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mandel">
<h3><a class="doc-anchor" href="#doc-mandel">#</a> <code>mandel</code></h3>
<p><code>mandel</code> — algorithms / puzzles builtin. Alias for <code>mandelbrot_char</code>.</p>
<pre><code class="lang-perl">my $result = mandel $x
# or in a pipeline:
@list |> map mandel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mandel-q">
<h3><a class="doc-anchor" href="#doc-mandel-q">#</a> <code>mandel_q</code></h3>
<p><code>mandel_q</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = mandel_q $x
# or in a pipeline:
@list |> map mandel_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mandelbrot-char">
<h3><a class="doc-anchor" href="#doc-mandelbrot-char">#</a> <code>mandelbrot_char</code></h3>
<p><code>mandelbrot_char</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = mandelbrot_char $x
# or in a pipeline:
@list |> map mandelbrot_char |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-manhattan-distance">
<h3><a class="doc-anchor" href="#doc-manhattan-distance">#</a> <code>manhattan_distance</code></h3>
<p><code>manhattan_distance</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = manhattan_distance $x
# or in a pipeline:
@list |> map manhattan_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-manipulability-yoshikawa">
<h3><a class="doc-anchor" href="#doc-manipulability-yoshikawa">#</a> <code>manipulability_yoshikawa</code></h3>
<p><code>manipulability_yoshikawa</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = manipulability_yoshikawa $x
# or in a pipeline:
@list |> map manipulability_yoshikawa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mann-kendall-tau">
<h3><a class="doc-anchor" href="#doc-mann-kendall-tau">#</a> <code>mann_kendall_tau</code></h3>
<p><code>mann_kendall_tau</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = mann_kendall_tau $x
# or in a pipeline:
@list |> map mann_kendall_tau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mann-whitney">
<h3><a class="doc-anchor" href="#doc-mann-whitney">#</a> <code>mann_whitney</code></h3>
<p><code>wilcox_test</code> (aliases <code>wilcox</code>, <code>mann_whitney</code>) — Wilcoxon rank-sum test (Mann-Whitney U). Returns U statistic. Like R's wilcox.test().</p>
<pre><code class="lang-perl">my $U = wilcox([1,2,3], [4,5,6]) # 0 (no overlap)
</code></pre>
</article>
<article class="doc-entry" id="doc-manning-velocity">
<h3><a class="doc-anchor" href="#doc-manning-velocity">#</a> <code>manning_velocity</code></h3>
<p><code>manning_velocity</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = manning_velocity $x
# or in a pipeline:
@list |> map manning_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mannwhitneyu">
<h3><a class="doc-anchor" href="#doc-mannwhitneyu">#</a> <code>mannwhitneyu</code></h3>
<p><code>mannwhitneyu</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = mannwhitneyu $x
# or in a pipeline:
@list |> map mannwhitneyu |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-bp">
<h3><a class="doc-anchor" href="#doc-map-bp">#</a> <code>map_bp</code></h3>
<p><code>map_bp</code> — batch 12 builtin. Alias for <code>mean_arterial_pressure</code>.</p>
<pre><code class="lang-perl">my $result = map_bp $x
# or in a pipeline:
@list |> map map_bp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-chars">
<h3><a class="doc-anchor" href="#doc-map-chars">#</a> <code>map_chars</code></h3>
<p><code>map_chars</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = map_chars $x
# or in a pipeline:
@list |> map map_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-indexed">
<h3><a class="doc-anchor" href="#doc-map-indexed">#</a> <code>map_indexed</code></h3>
<p><code>map_indexed</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = map_indexed $x
# or in a pipeline:
@list |> map map_indexed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-keys-fn">
<h3><a class="doc-anchor" href="#doc-map-keys-fn">#</a> <code>map_keys_fn</code></h3>
<p><code>map_keys_fn</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = map_keys_fn $x
# or in a pipeline:
@list |> map map_keys_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-range">
<h3><a class="doc-anchor" href="#doc-map-range">#</a> <code>map_range</code></h3>
<p><code>map_range($value, $in_min, $in_max, $out_min, $out_max)</code> (alias <code>remap</code>) — remap a value from one range to another.</p>
<pre><code class="lang-perl">p remap(50, 0, 100, 0, 1) # 0.5
p remap(75, 0, 100, 0, 255) # 191.25 (percent to byte)
</code></pre>
</article>
<article class="doc-entry" id="doc-map-values-fn">
<h3><a class="doc-anchor" href="#doc-map-values-fn">#</a> <code>map_values_fn</code></h3>
<p><code>map_values_fn</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = map_values_fn $x
# or in a pipeline:
@list |> map map_values_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-while">
<h3><a class="doc-anchor" href="#doc-map-while">#</a> <code>map_while</code></h3>
<p><code>map_while</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = map_while $x
# or in a pipeline:
@list |> map map_while |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mapcat">
<h3><a class="doc-anchor" href="#doc-mapcat">#</a> <code>mapcat</code></h3>
<p><code>mapcat</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = mapcat $x
# or in a pipeline:
@list |> map mapcat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mapi">
<h3><a class="doc-anchor" href="#doc-mapi">#</a> <code>mapi</code></h3>
<p><code>mapi</code> — go/general functional utilities builtin. Alias for <code>map_indexed</code>.</p>
<pre><code class="lang-perl">my $result = mapi $x
# or in a pipeline:
@list |> map mapi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mapping-class-torus">
<h3><a class="doc-anchor" href="#doc-mapping-class-torus">#</a> <code>mapping_class_torus</code></h3>
<p><code>mapping_class_torus</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = mapping_class_torus $x
# or in a pipeline:
@list |> map mapping_class_torus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mapw">
<h3><a class="doc-anchor" href="#doc-mapw">#</a> <code>mapw</code></h3>
<p><code>mapw</code> — rust iterator methods builtin. Alias for <code>map_while</code>.</p>
<pre><code class="lang-perl">my $result = mapw $x
# or in a pipeline:
@list |> map mapw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-marcum-q">
<h3><a class="doc-anchor" href="#doc-marcum-q">#</a> <code>marcum_q</code></h3>
<p><code>marcum_q</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = marcum_q $x
# or in a pipeline:
@list |> map marcum_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-margalef-richness">
<h3><a class="doc-anchor" href="#doc-margalef-richness">#</a> <code>margalef_richness</code></h3>
<p><code>margalef_richness</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = margalef_richness $x
# or in a pipeline:
@list |> map margalef_richness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-margin">
<h3><a class="doc-anchor" href="#doc-margin">#</a> <code>margin</code></h3>
<p><code>margin</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = margin $x
# or in a pipeline:
@list |> map margin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-margin-price">
<h3><a class="doc-anchor" href="#doc-margin-price">#</a> <code>margin_price</code></h3>
<p><code>margin_price</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = margin_price $x
# or in a pipeline:
@list |> map margin_price |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-margrabe">
<h3><a class="doc-anchor" href="#doc-margrabe">#</a> <code>margrabe</code></h3>
<p><code>margrabe</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = margrabe $x
# or in a pipeline:
@list |> map margrabe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-markov-decision-value">
<h3><a class="doc-anchor" href="#doc-markov-decision-value">#</a> <code>markov_decision_value</code></h3>
<p><code>markov_decision_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = markov_decision_value $x
# or in a pipeline:
@list |> map markov_decision_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-markov-switching-ar">
<h3><a class="doc-anchor" href="#doc-markov-switching-ar">#</a> <code>markov_switching_ar</code></h3>
<p><code>markov_switching_ar</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = markov_switching_ar $x
# or in a pipeline:
@list |> map markov_switching_ar |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-markov-switching-mr">
<h3><a class="doc-anchor" href="#doc-markov-switching-mr">#</a> <code>markov_switching_mr</code></h3>
<p><code>markov_switching_mr</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = markov_switching_mr $x
# or in a pipeline:
@list |> map markov_switching_mr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-markup">
<h3><a class="doc-anchor" href="#doc-markup">#</a> <code>markup</code></h3>
<p><code>markup</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = markup $x
# or in a pipeline:
@list |> map markup |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-markup-price">
<h3><a class="doc-anchor" href="#doc-markup-price">#</a> <code>markup_price</code></h3>
<p><code>markup_price</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = markup_price $x
# or in a pipeline:
@list |> map markup_price |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-marshallian-demand">
<h3><a class="doc-anchor" href="#doc-marshallian-demand">#</a> <code>marshallian_demand</code></h3>
<p><code>marshallian_demand</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = marshallian_demand $x
# or in a pipeline:
@list |> map marshallian_demand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mask">
<h3><a class="doc-anchor" href="#doc-mask">#</a> <code>mask</code></h3>
<p><code>mask</code> — string processing (uncategorized batch) builtin. Alias for <code>mask_string</code>.</p>
<pre><code class="lang-perl">my $result = mask $x
# or in a pipeline:
@list |> map mask |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mask-string">
<h3><a class="doc-anchor" href="#doc-mask-string">#</a> <code>mask_string</code></h3>
<p><code>mask_string</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = mask_string $x
# or in a pipeline:
@list |> map mask_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mass-transport-overpotential">
<h3><a class="doc-anchor" href="#doc-mass-transport-overpotential">#</a> <code>mass_transport_overpotential</code></h3>
<p><code>mass_transport_overpotential</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = mass_transport_overpotential $x
# or in a pipeline:
@list |> map mass_transport_overpotential |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mat-mul">
<h3><a class="doc-anchor" href="#doc-mat-mul">#</a> <code>mat_mul</code></h3>
<p><code>mat_mul</code> — matrix / linear algebra builtin. Alias for <code>matrix_multiply</code>.</p>
<pre><code class="lang-perl">my $result = mat_mul $x
# or in a pipeline:
@list |> map mat_mul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mat-scale">
<h3><a class="doc-anchor" href="#doc-mat-scale">#</a> <code>mat_scale</code></h3>
<p><code>mat_scale</code> — extended stdlib builtin. Alias for <code>matrix_scale</code>.</p>
<pre><code class="lang-perl">my $result = mat_scale $x
# or in a pipeline:
@list |> map mat_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-match-all">
<h3><a class="doc-anchor" href="#doc-match-all">#</a> <code>match_all</code></h3>
<p><code>match_all</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = match_all $x
# or in a pipeline:
@list |> map match_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-match-rating-codex">
<h3><a class="doc-anchor" href="#doc-match-rating-codex">#</a> <code>match_rating_codex</code></h3>
<p><code>match_rating_codex</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = match_rating_codex $x
# or in a pipeline:
@list |> map match_rating_codex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matches-regex">
<h3><a class="doc-anchor" href="#doc-matches-regex">#</a> <code>matches_regex</code></h3>
<p><code>matches_regex</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = matches_regex $x
# or in a pipeline:
@list |> map matches_regex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matching-market-step">
<h3><a class="doc-anchor" href="#doc-matching-market-step">#</a> <code>matching_market_step</code></h3>
<p><code>matching_market_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = matching_market_step $x
# or in a pipeline:
@list |> map matching_market_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matching-pennies-payoff">
<h3><a class="doc-anchor" href="#doc-matching-pennies-payoff">#</a> <code>matching_pennies_payoff</code></h3>
<p><code>matching_pennies_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = matching_pennies_payoff $x
# or in a pipeline:
@list |> map matching_pennies_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mathieu-b">
<h3><a class="doc-anchor" href="#doc-mathieu-b">#</a> <code>mathieu_b</code></h3>
<p><code>mathieu_b</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = mathieu_b $x
# or in a pipeline:
@list |> map mathieu_b |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mathieu-ce0">
<h3><a class="doc-anchor" href="#doc-mathieu-ce0">#</a> <code>mathieu_ce0</code></h3>
<p><code>mathieu_ce0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = mathieu_ce0 $x
# or in a pipeline:
@list |> map mathieu_ce0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mathieu-se1">
<h3><a class="doc-anchor" href="#doc-mathieu-se1">#</a> <code>mathieu_se1</code></h3>
<p><code>mathieu_se1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = mathieu_se1 $x
# or in a pipeline:
@list |> map mathieu_se1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matmul">
<h3><a class="doc-anchor" href="#doc-matmul">#</a> <code>matmul</code></h3>
<p><code>matmul</code> — extended stdlib builtin. Alias for <code>matrix_mul</code>.</p>
<pre><code class="lang-perl">my $result = matmul $x
# or in a pipeline:
@list |> map matmul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-add">
<h3><a class="doc-anchor" href="#doc-matrix-add">#</a> <code>matrix_add</code></h3>
<p><code>matrix_add</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_add $x
# or in a pipeline:
@list |> map matrix_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-anti-diagonal">
<h3><a class="doc-anchor" href="#doc-matrix-anti-diagonal">#</a> <code>matrix_anti_diagonal</code></h3>
<p><code>matrix_anti_diagonal</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = matrix_anti_diagonal $x
# or in a pipeline:
@list |> map matrix_anti_diagonal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-col">
<h3><a class="doc-anchor" href="#doc-matrix-col">#</a> <code>matrix_col</code></h3>
<p><code>matrix_col</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_col $x
# or in a pipeline:
@list |> map matrix_col |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-det">
<h3><a class="doc-anchor" href="#doc-matrix-det">#</a> <code>matrix_det</code></h3>
<p><code>matrix_det</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_det $x
# or in a pipeline:
@list |> map matrix_det |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-diag">
<h3><a class="doc-anchor" href="#doc-matrix-diag">#</a> <code>matrix_diag</code></h3>
<p><code>matrix_diag</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_diag $x
# or in a pipeline:
@list |> map matrix_diag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-diagonal">
<h3><a class="doc-anchor" href="#doc-matrix-diagonal">#</a> <code>matrix_diagonal</code></h3>
<p><code>matrix_diagonal</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = matrix_diagonal $x
# or in a pipeline:
@list |> map matrix_diagonal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-flatten">
<h3><a class="doc-anchor" href="#doc-matrix-flatten">#</a> <code>matrix_flatten</code></h3>
<p><code>matrix_flatten</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_flatten $x
# or in a pipeline:
@list |> map matrix_flatten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-from-rows">
<h3><a class="doc-anchor" href="#doc-matrix-from-rows">#</a> <code>matrix_from_rows</code></h3>
<p><code>matrix_from_rows</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_from_rows $x
# or in a pipeline:
@list |> map matrix_from_rows |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-hadamard">
<h3><a class="doc-anchor" href="#doc-matrix-hadamard">#</a> <code>matrix_hadamard</code></h3>
<p><code>matrix_hadamard</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_hadamard $x
# or in a pipeline:
@list |> map matrix_hadamard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-identity">
<h3><a class="doc-anchor" href="#doc-matrix-identity">#</a> <code>matrix_identity</code></h3>
<p><code>matrix_identity</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_identity $x
# or in a pipeline:
@list |> map matrix_identity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-identity-q">
<h3><a class="doc-anchor" href="#doc-matrix-identity-q">#</a> <code>matrix_identity_q</code></h3>
<p><code>matrix_identity_q</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = matrix_identity_q $x
# or in a pipeline:
@list |> map matrix_identity_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-inverse">
<h3><a class="doc-anchor" href="#doc-matrix-inverse">#</a> <code>matrix_inverse</code></h3>
<p><code>matrix_inverse</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_inverse $x
# or in a pipeline:
@list |> map matrix_inverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-lu">
<h3><a class="doc-anchor" href="#doc-matrix-lu">#</a> <code>matrix_lu</code></h3>
<p><code>matrix_lu</code> (alias <code>mlu</code>) computes the LU decomposition with partial pivoting. Returns [L, U, P] where PA = LU.</p>
<pre><code class="lang-perl">my ($L, $U, $P) = @{mlu([[4,3],[6,3]])}
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-map">
<h3><a class="doc-anchor" href="#doc-matrix-map">#</a> <code>matrix_map</code></h3>
<p><code>matrix_map</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_map $x
# or in a pipeline:
@list |> map matrix_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-max">
<h3><a class="doc-anchor" href="#doc-matrix-max">#</a> <code>matrix_max</code></h3>
<p><code>matrix_max</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_max $x
# or in a pipeline:
@list |> map matrix_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-min">
<h3><a class="doc-anchor" href="#doc-matrix-min">#</a> <code>matrix_min</code></h3>
<p><code>matrix_min</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_min $x
# or in a pipeline:
@list |> map matrix_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-mul">
<h3><a class="doc-anchor" href="#doc-matrix-mul">#</a> <code>matrix_mul</code></h3>
<p><code>matrix_mul</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_mul $x
# or in a pipeline:
@list |> map matrix_mul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-mult">
<h3><a class="doc-anchor" href="#doc-matrix-mult">#</a> <code>matrix_mult</code></h3>
<p><code>matrix_mult</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_mult $x
# or in a pipeline:
@list |> map matrix_mult |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-multiply">
<h3><a class="doc-anchor" href="#doc-matrix-multiply">#</a> <code>matrix_multiply</code></h3>
<p><code>matrix_multiply</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = matrix_multiply $x
# or in a pipeline:
@list |> map matrix_multiply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-norm">
<h3><a class="doc-anchor" href="#doc-matrix-norm">#</a> <code>matrix_norm</code></h3>
<p><code>matrix_norm</code> (alias <code>mnorm</code>) computes a matrix norm. Default is Frobenius; pass 1 for max-column-sum, Inf for max-row-sum.</p>
<pre><code class="lang-perl">p mnorm([[3,4]]) # 5 (Frobenius)
p mnorm([[1,2],[3,4]], 1) # 6 (1-norm)
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-ones">
<h3><a class="doc-anchor" href="#doc-matrix-ones">#</a> <code>matrix_ones</code></h3>
<p><code>matrix_ones</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_ones $x
# or in a pipeline:
@list |> map matrix_ones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-orthogonal-q">
<h3><a class="doc-anchor" href="#doc-matrix-orthogonal-q">#</a> <code>matrix_orthogonal_q</code></h3>
<p><code>matrix_orthogonal_q</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = matrix_orthogonal_q $x
# or in a pipeline:
@list |> map matrix_orthogonal_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-pinv">
<h3><a class="doc-anchor" href="#doc-matrix-pinv">#</a> <code>matrix_pinv</code></h3>
<p><code>matrix_pinv</code> (aliases <code>mpinv</code>, <code>pinv</code>) computes the Moore-Penrose pseudo-inverse via (A^T A)^{-1} A^T.</p>
<pre><code class="lang-perl">my $A_plus = pinv([[1,2],[3,4],[5,6]])
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-power">
<h3><a class="doc-anchor" href="#doc-matrix-power">#</a> <code>matrix_power</code></h3>
<p><code>matrix_power</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_power $x
# or in a pipeline:
@list |> map matrix_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-qr">
<h3><a class="doc-anchor" href="#doc-matrix-qr">#</a> <code>matrix_qr</code></h3>
<p><code>matrix_qr</code> (alias <code>mqr</code>) computes the QR decomposition via Gram-Schmidt orthogonalization. Returns [Q, R] where A = QR.</p>
<pre><code class="lang-perl">my ($Q, $R) = @{mqr([[1,1],[1,-1]])}
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-random-normal">
<h3><a class="doc-anchor" href="#doc-matrix-random-normal">#</a> <code>matrix_random_normal</code></h3>
<p><code>matrix_random_normal</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = matrix_random_normal $x
# or in a pipeline:
@list |> map matrix_random_normal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-random-uniform">
<h3><a class="doc-anchor" href="#doc-matrix-random-uniform">#</a> <code>matrix_random_uniform</code></h3>
<p><code>matrix_random_uniform</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = matrix_random_uniform $x
# or in a pipeline:
@list |> map matrix_random_uniform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-row">
<h3><a class="doc-anchor" href="#doc-matrix-row">#</a> <code>matrix_row</code></h3>
<p><code>matrix_row</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_row $x
# or in a pipeline:
@list |> map matrix_row |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-scalar">
<h3><a class="doc-anchor" href="#doc-matrix-scalar">#</a> <code>matrix_scalar</code></h3>
<p><code>matrix_scalar</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_scalar $x
# or in a pipeline:
@list |> map matrix_scalar |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-scale">
<h3><a class="doc-anchor" href="#doc-matrix-scale">#</a> <code>matrix_scale</code></h3>
<p><code>matrix_scale</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_scale $x
# or in a pipeline:
@list |> map matrix_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-shape">
<h3><a class="doc-anchor" href="#doc-matrix-shape">#</a> <code>matrix_shape</code></h3>
<p><code>matrix_shape</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_shape $x
# or in a pipeline:
@list |> map matrix_shape |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-solve">
<h3><a class="doc-anchor" href="#doc-matrix-solve">#</a> <code>matrix_solve</code></h3>
<p><code>matrix_solve</code> (aliases <code>msolve</code>, <code>solve</code>) solves the linear system Ax=b via Gaussian elimination with partial pivoting. Returns the solution vector x.</p>
<pre><code class="lang-perl">my $A = [[2,1],[-1,1]]
my $b = [5,2]
my $x = solve($A, $b) # [1, 3]
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-sub">
<h3><a class="doc-anchor" href="#doc-matrix-sub">#</a> <code>matrix_sub</code></h3>
<p><code>matrix_sub</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_sub $x
# or in a pipeline:
@list |> map matrix_sub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-sum">
<h3><a class="doc-anchor" href="#doc-matrix-sum">#</a> <code>matrix_sum</code></h3>
<p><code>matrix_sum</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_sum $x
# or in a pipeline:
@list |> map matrix_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-symmetric-q">
<h3><a class="doc-anchor" href="#doc-matrix-symmetric-q">#</a> <code>matrix_symmetric_q</code></h3>
<p><code>matrix_symmetric_q</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = matrix_symmetric_q $x
# or in a pipeline:
@list |> map matrix_symmetric_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-trace">
<h3><a class="doc-anchor" href="#doc-matrix-trace">#</a> <code>matrix_trace</code></h3>
<p><code>matrix_trace</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_trace $x
# or in a pipeline:
@list |> map matrix_trace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-transpose">
<h3><a class="doc-anchor" href="#doc-matrix-transpose">#</a> <code>matrix_transpose</code></h3>
<p><code>matrix_transpose</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_transpose $x
# or in a pipeline:
@list |> map matrix_transpose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-zero-q">
<h3><a class="doc-anchor" href="#doc-matrix-zero-q">#</a> <code>matrix_zero_q</code></h3>
<p><code>matrix_zero_q</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = matrix_zero_q $x
# or in a pipeline:
@list |> map matrix_zero_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-zeros">
<h3><a class="doc-anchor" href="#doc-matrix-zeros">#</a> <code>matrix_zeros</code></h3>
<p><code>matrix_zeros</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_zeros $x
# or in a pipeline:
@list |> map matrix_zeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matroid-greedy-step">
<h3><a class="doc-anchor" href="#doc-matroid-greedy-step">#</a> <code>matroid_greedy_step</code></h3>
<p><code>matroid_greedy_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = matroid_greedy_step $x
# or in a pipeline:
@list |> map matroid_greedy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matroid-intersection-step">
<h3><a class="doc-anchor" href="#doc-matroid-intersection-step">#</a> <code>matroid_intersection_step</code></h3>
<p><code>matroid_intersection_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = matroid_intersection_step $x
# or in a pipeline:
@list |> map matroid_intersection_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max2">
<h3><a class="doc-anchor" href="#doc-max2">#</a> <code>max2</code></h3>
<p><code>max2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = max2 $x
# or in a pipeline:
@list |> map max2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-abs">
<h3><a class="doc-anchor" href="#doc-max-abs">#</a> <code>max_abs</code></h3>
<p><code>max_abs</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = max_abs $x
# or in a pipeline:
@list |> map max_abs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-by">
<h3><a class="doc-anchor" href="#doc-max-by">#</a> <code>max_by</code></h3>
<p><code>max_by</code> — functional / iterator builtin. Alias for <code>take_while</code>.</p>
<pre><code class="lang-perl">my $result = max_by $x
# or in a pipeline:
@list |> map max_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-degree">
<h3><a class="doc-anchor" href="#doc-max-degree">#</a> <code>max_degree</code></h3>
<p><code>max_degree</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = max_degree $x
# or in a pipeline:
@list |> map max_degree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-drawdown">
<h3><a class="doc-anchor" href="#doc-max-drawdown">#</a> <code>max_drawdown</code></h3>
<p><code>max_drawdown(@equity_curve)</code> (alias <code>mdd</code>) — computes the maximum peak-to-trough decline in a series of values. Returns as a decimal (0.2 = 20% drawdown). Key risk metric.</p>
<pre><code class="lang-perl">my @equity = (100, 120, 90, 110, 85, 130)
p mdd(@equity) # ~0.29 (29% max drawdown)
</code></pre>
</article>
<article class="doc-entry" id="doc-max-drawdown-arr">
<h3><a class="doc-anchor" href="#doc-max-drawdown-arr">#</a> <code>max_drawdown_arr</code></h3>
<p><code>max_drawdown_arr</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = max_drawdown_arr $x
# or in a pipeline:
@list |> map max_drawdown_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-float">
<h3><a class="doc-anchor" href="#doc-max-float">#</a> <code>max_float</code></h3>
<p><code>max_float</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = max_float $x
# or in a pipeline:
@list |> map max_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-flow-ek">
<h3><a class="doc-anchor" href="#doc-max-flow-ek">#</a> <code>max_flow_ek</code></h3>
<p><code>max_flow_ek</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = max_flow_ek $x
# or in a pipeline:
@list |> map max_flow_ek |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-flow-ford-fulkerson-step">
<h3><a class="doc-anchor" href="#doc-max-flow-ford-fulkerson-step">#</a> <code>max_flow_ford_fulkerson_step</code></h3>
<p><code>max_flow_ford_fulkerson_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = max_flow_ford_fulkerson_step $x
# or in a pipeline:
@list |> map max_flow_ford_fulkerson_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-heart-rate">
<h3><a class="doc-anchor" href="#doc-max-heart-rate">#</a> <code>max_heart_rate</code></h3>
<p><code>max_heart_rate</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = max_heart_rate $x
# or in a pipeline:
@list |> map max_heart_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-independent-set">
<h3><a class="doc-anchor" href="#doc-max-independent-set">#</a> <code>max_independent_set</code></h3>
<p><code>max_independent_set</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = max_independent_set $x
# or in a pipeline:
@list |> map max_independent_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-list">
<h3><a class="doc-anchor" href="#doc-max-list">#</a> <code>max_list</code></h3>
<p><code>max_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = max_list $x
# or in a pipeline:
@list |> map max_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-norm">
<h3><a class="doc-anchor" href="#doc-max-norm">#</a> <code>max_norm</code></h3>
<p><code>max_norm</code> — batch 11 builtin. Alias for <code>linf_norm</code>.</p>
<pre><code class="lang-perl">my $result = max_norm $x
# or in a pipeline:
@list |> map max_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-of">
<h3><a class="doc-anchor" href="#doc-max-of">#</a> <code>max_of</code></h3>
<p><code>max_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = max_of $x
# or in a pipeline:
@list |> map max_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-sum-subarray">
<h3><a class="doc-anchor" href="#doc-max-sum-subarray">#</a> <code>max_sum_subarray</code></h3>
<p><code>max_sum_subarray</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = max_sum_subarray $x
# or in a pipeline:
@list |> map max_sum_subarray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maxby">
<h3><a class="doc-anchor" href="#doc-maxby">#</a> <code>maxby</code></h3>
<p><code>maxby</code> — additional missing stdlib functions builtin. Alias for <code>maximum_by</code>.</p>
<pre><code class="lang-perl">my $result = maxby $x
# or in a pipeline:
@list |> map maxby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maxdd">
<h3><a class="doc-anchor" href="#doc-maxdd">#</a> <code>maxdd</code></h3>
<p><code>maxdd</code> — finance (extended) builtin. Alias for <code>max_drawdown</code>.</p>
<pre><code class="lang-perl">my $result = maxdd $x
# or in a pipeline:
@list |> map maxdd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maximin-share">
<h3><a class="doc-anchor" href="#doc-maximin-share">#</a> <code>maximin_share</code></h3>
<p><code>maximin_share</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = maximin_share $x
# or in a pipeline:
@list |> map maximin_share |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maximum-bipartite-matching">
<h3><a class="doc-anchor" href="#doc-maximum-bipartite-matching">#</a> <code>maximum_bipartite_matching</code></h3>
<p><code>maximum_bipartite_matching</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = maximum_bipartite_matching $x
# or in a pipeline:
@list |> map maximum_bipartite_matching |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maximum-by">
<h3><a class="doc-anchor" href="#doc-maximum-by">#</a> <code>maximum_by</code></h3>
<p><code>maximum_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = maximum_by $x
# or in a pipeline:
@list |> map maximum_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maxstr">
<h3><a class="doc-anchor" href="#doc-maxstr">#</a> <code>maxstr</code></h3>
<p><code>maxstr</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = maxstr $x
# or in a pipeline:
@list |> map maxstr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maxsub">
<h3><a class="doc-anchor" href="#doc-maxsub">#</a> <code>maxsub</code></h3>
<p><code>maxsub</code> — extended stdlib batch 3 builtin. Alias for <code>max_sum_subarray</code>.</p>
<pre><code class="lang-perl">my $result = maxsub $x
# or in a pipeline:
@list |> map maxsub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maya-long-count-from-fixed">
<h3><a class="doc-anchor" href="#doc-maya-long-count-from-fixed">#</a> <code>maya_long_count_from_fixed</code></h3>
<p><code>maya_long_count_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = maya_long_count_from_fixed $x
# or in a pipeline:
@list |> map maya_long_count_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mayan-haab-from-fixed">
<h3><a class="doc-anchor" href="#doc-mayan-haab-from-fixed">#</a> <code>mayan_haab_from_fixed</code></h3>
<p><code>mayan_haab_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = mayan_haab_from_fixed $x
# or in a pipeline:
@list |> map mayan_haab_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mayan-tzolkin-from-fixed">
<h3><a class="doc-anchor" href="#doc-mayan-tzolkin-from-fixed">#</a> <code>mayan_tzolkin_from_fixed</code></h3>
<p><code>mayan_tzolkin_from_fixed</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = mayan_tzolkin_from_fixed $x
# or in a pipeline:
@list |> map mayan_tzolkin_from_fixed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mb-to-bytes">
<h3><a class="doc-anchor" href="#doc-mb-to-bytes">#</a> <code>mb_to_bytes</code></h3>
<p><code>mb_to_bytes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = mb_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mb-to-gb">
<h3><a class="doc-anchor" href="#doc-mb-to-gb">#</a> <code>mb_to_gb</code></h3>
<p><code>mb_to_gb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = mb_to_gb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mc-limiter">
<h3><a class="doc-anchor" href="#doc-mc-limiter">#</a> <code>mc_limiter</code></h3>
<p><code>mc_limiter</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = mc_limiter $x
# or in a pipeline:
@list |> map mc_limiter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcat">
<h3><a class="doc-anchor" href="#doc-mcat">#</a> <code>mcat</code></h3>
<p><code>mcat</code> — algebraic match builtin. Alias for <code>mapcat</code>.</p>
<pre><code class="lang-perl">my $result = mcat $x
# or in a pipeline:
@list |> map mcat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcc">
<h3><a class="doc-anchor" href="#doc-mcc">#</a> <code>mcc</code></h3>
<p><code>mcc</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = mcc $x
# or in a pipeline:
@list |> map mcc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcol">
<h3><a class="doc-anchor" href="#doc-mcol">#</a> <code>mcol</code></h3>
<p><code>mcol</code> — extended stdlib builtin. Alias for <code>matrix_col</code>.</p>
<pre><code class="lang-perl">my $result = mcol $x
# or in a pipeline:
@list |> map mcol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcp-serve-registered-tools">
<h3><a class="doc-anchor" href="#doc-mcp-serve-registered-tools">#</a> <code>mcp_serve_registered_tools</code></h3>
<p><code>mcp_serve_registered_tools("server-name")</code> — convert every tool registered via <code>tool fn</code> / <code>ai_register_tool</code> into MCP server schema and run the stdio JSON-RPC loop. Used by <code>stryke build --mcp-server</code>.</p>
</article>
<article class="doc-entry" id="doc-md5">
<h3><a class="doc-anchor" href="#doc-md5">#</a> <code>md5</code></h3>
<p><code>md5</code> — crypto / encoding builtin.</p>
<pre><code class="lang-perl">my $result = md5 $x
# or in a pipeline:
@list |> map md5 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mdet">
<h3><a class="doc-anchor" href="#doc-mdet">#</a> <code>mdet</code></h3>
<p><code>mdet</code> — extended stdlib builtin. Alias for <code>matrix_det</code>.</p>
<pre><code class="lang-perl">my $result = mdet $x
# or in a pipeline:
@list |> map mdet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mdiag">
<h3><a class="doc-anchor" href="#doc-mdiag">#</a> <code>mdiag</code></h3>
<p><code>mdiag</code> — extended stdlib builtin. Alias for <code>matrix_diag</code>.</p>
<pre><code class="lang-perl">my $result = mdiag $x
# or in a pipeline:
@list |> map mdiag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mdiagvec">
<h3><a class="doc-anchor" href="#doc-mdiagvec">#</a> <code>mdiagvec</code></h3>
<p><code>mdiagvec</code> — batch 11 builtin. Alias for <code>matrix_diagonal</code>.</p>
<pre><code class="lang-perl">my $result = mdiagvec $x
# or in a pipeline:
@list |> map mdiagvec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mdist">
<h3><a class="doc-anchor" href="#doc-mdist">#</a> <code>mdist</code></h3>
<p><code>mdist</code> — extended stdlib builtin. Alias for <code>manhattan_distance</code>.</p>
<pre><code class="lang-perl">my $result = mdist $x
# or in a pipeline:
@list |> map mdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mduration">
<h3><a class="doc-anchor" href="#doc-mduration">#</a> <code>mduration</code></h3>
<p><code>mduration</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = mduration $x
# or in a pipeline:
@list |> map mduration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-absolute-error">
<h3><a class="doc-anchor" href="#doc-mean-absolute-error">#</a> <code>mean_absolute_error</code></h3>
<p><code>mean_absolute_error</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = mean_absolute_error $x
# or in a pipeline:
@list |> map mean_absolute_error |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-activity-coeff-pitzer">
<h3><a class="doc-anchor" href="#doc-mean-activity-coeff-pitzer">#</a> <code>mean_activity_coeff_pitzer</code></h3>
<p><code>mean_activity_coeff_pitzer</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = mean_activity_coeff_pitzer $x
# or in a pipeline:
@list |> map mean_activity_coeff_pitzer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-arterial-pressure">
<h3><a class="doc-anchor" href="#doc-mean-arterial-pressure">#</a> <code>mean_arterial_pressure</code></h3>
<p><code>mean_arterial_pressure</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = mean_arterial_pressure $x
# or in a pipeline:
@list |> map mean_arterial_pressure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-curvature-step">
<h3><a class="doc-anchor" href="#doc-mean-curvature-step">#</a> <code>mean_curvature_step</code></h3>
<p><code>mean_curvature_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = mean_curvature_step $x
# or in a pipeline:
@list |> map mean_curvature_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-filter-window">
<h3><a class="doc-anchor" href="#doc-mean-filter-window">#</a> <code>mean_filter_window</code></h3>
<p><code>mean_filter_window</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = mean_filter_window $x
# or in a pipeline:
@list |> map mean_filter_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-list">
<h3><a class="doc-anchor" href="#doc-mean-list">#</a> <code>mean_list</code></h3>
<p><code>mean_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = mean_list $x
# or in a pipeline:
@list |> map mean_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-solar-anomaly">
<h3><a class="doc-anchor" href="#doc-mean-solar-anomaly">#</a> <code>mean_solar_anomaly</code></h3>
<p><code>mean_solar_anomaly</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = mean_solar_anomaly $x
# or in a pipeline:
@list |> map mean_solar_anomaly |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-solar-longitude">
<h3><a class="doc-anchor" href="#doc-mean-solar-longitude">#</a> <code>mean_solar_longitude</code></h3>
<p><code>mean_solar_longitude</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = mean_solar_longitude $x
# or in a pipeline:
@list |> map mean_solar_longitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-squared-error">
<h3><a class="doc-anchor" href="#doc-mean-squared-error">#</a> <code>mean_squared_error</code></h3>
<p><code>mean_squared_error</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = mean_squared_error $x
# or in a pipeline:
@list |> map mean_squared_error |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-tone-freq">
<h3><a class="doc-anchor" href="#doc-mean-tone-freq">#</a> <code>mean_tone_freq</code></h3>
<p><code>mean_tone_freq</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = mean_tone_freq $x
# or in a pipeline:
@list |> map mean_tone_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-measure">
<h3><a class="doc-anchor" href="#doc-measure">#</a> <code>measure</code></h3>
<p><code>measure</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = measure $x
# or in a pipeline:
@list |> map measure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mechanism-design-obj">
<h3><a class="doc-anchor" href="#doc-mechanism-design-obj">#</a> <code>mechanism_design_obj</code></h3>
<p><code>mechanism_design_obj</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = mechanism_design_obj $x
# or in a pipeline:
@list |> map mechanism_design_obj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-medfilt">
<h3><a class="doc-anchor" href="#doc-medfilt">#</a> <code>medfilt</code></h3>
<p><code>median_filter(\@signal, $window_size)</code> (alias <code>medfilt</code>) — applies a median filter for noise removal. Each output is the median of the surrounding window. Excellent for removing impulse noise while preserving edges.</p>
<pre><code class="lang-perl">my @spiky = (1, 2, 100, 3, 4) # 100 is spike
my $clean = medfilt(\@spiky, 3)
p @$clean # spike removed
</code></pre>
</article>
<article class="doc-entry" id="doc-medfilt-1d">
<h3><a class="doc-anchor" href="#doc-medfilt-1d">#</a> <code>medfilt_1d</code></h3>
<p><code>medfilt_1d</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = medfilt_1d $x
# or in a pipeline:
@list |> map medfilt_1d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-median-absolute-deviation">
<h3><a class="doc-anchor" href="#doc-median-absolute-deviation">#</a> <code>median_absolute_deviation</code></h3>
<p><code>median_absolute_deviation</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = median_absolute_deviation $x
# or in a pipeline:
@list |> map median_absolute_deviation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-median-filter-window">
<h3><a class="doc-anchor" href="#doc-median-filter-window">#</a> <code>median_filter_window</code></h3>
<p><code>median_filter_window</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = median_filter_window $x
# or in a pipeline:
@list |> map median_filter_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-median-voter-step">
<h3><a class="doc-anchor" href="#doc-median-voter-step">#</a> <code>median_voter_step</code></h3>
<p><code>median_voter_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = median_voter_step $x
# or in a pipeline:
@list |> map median_voter_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mem-free">
<h3><a class="doc-anchor" href="#doc-mem-free">#</a> <code>mem_free</code></h3>
<p><code>mem_free</code> — free/available physical RAM in bytes. On Linux reads <code>MemAvailable</code> from <code>/proc/meminfo</code> (falls back to <code>MemFree</code>). On macOS uses <code>vm.page_free_count</code> via sysctl. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p mem_free # 3821666304
p format_bytes(mem_free) # 3.6 GiB
my $pct = int(mem_free / mem_total * 100)
p "$pct% free"
</code></pre>
</article>
<article class="doc-entry" id="doc-mem-total">
<h3><a class="doc-anchor" href="#doc-mem-total">#</a> <code>mem_total</code></h3>
<p><code>mem_total</code> — total physical RAM in bytes. Uses <code>/proc/meminfo</code> on Linux, <code>sysctlbyname("hw.memsize")</code> on macOS. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p mem_total # 68719476736
p format_bytes(mem_total) # 64.0 GiB
</code></pre>
</article>
<article class="doc-entry" id="doc-mem-used">
<h3><a class="doc-anchor" href="#doc-mem-used">#</a> <code>mem_used</code></h3>
<p><code>mem_used</code> — used physical RAM in bytes (total - free). Returns <code>undef</code> if either <code>mem_total</code> or <code>mem_free</code> is unavailable.</p>
<pre><code class="lang-perl">p format_bytes(mem_used) # 60.4 GiB
gauge(mem_used / mem_total) |> p # memory usage gauge
</code></pre>
</article>
<article class="doc-entry" id="doc-membership-idx">
<h3><a class="doc-anchor" href="#doc-membership-idx">#</a> <code>membership_idx</code></h3>
<p><code>membership_idx</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = membership_idx $x
# or in a pipeline:
@list |> map membership_idx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-menhinick-richness">
<h3><a class="doc-anchor" href="#doc-menhinick-richness">#</a> <code>menhinick_richness</code></h3>
<p><code>menhinick_richness</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = menhinick_richness $x
# or in a pipeline:
@list |> map menhinick_richness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mercury-perihelion-advance">
<h3><a class="doc-anchor" href="#doc-mercury-perihelion-advance">#</a> <code>mercury_perihelion_advance</code></h3>
<p><code>mercury_perihelion_advance</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = mercury_perihelion_advance $x
# or in a pipeline:
@list |> map mercury_perihelion_advance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-merge-hash">
<h3><a class="doc-anchor" href="#doc-merge-hash">#</a> <code>merge_hash</code></h3>
<p><code>merge_hash</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = merge_hash $x
# or in a pipeline:
@list |> map merge_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-merge-sorted">
<h3><a class="doc-anchor" href="#doc-merge-sorted">#</a> <code>merge_sorted</code></h3>
<p><code>merge_sorted</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = merge_sorted $x
# or in a pipeline:
@list |> map merge_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mertens">
<h3><a class="doc-anchor" href="#doc-mertens">#</a> <code>mertens</code></h3>
<p><code>mertens</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = mertens $x
# or in a pipeline:
@list |> map mertens |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mertens-zamir-step">
<h3><a class="doc-anchor" href="#doc-mertens-zamir-step">#</a> <code>mertens_zamir_step</code></h3>
<p><code>mertens_zamir_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = mertens_zamir_step $x
# or in a pipeline:
@list |> map mertens_zamir_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-merton-jump-call">
<h3><a class="doc-anchor" href="#doc-merton-jump-call">#</a> <code>merton_jump_call</code></h3>
<p><code>merton_jump_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = merton_jump_call $x
# or in a pipeline:
@list |> map merton_jump_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metal-corrosion-rate">
<h3><a class="doc-anchor" href="#doc-metal-corrosion-rate">#</a> <code>metal_corrosion_rate</code></h3>
<p><code>metal_corrosion_rate</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = metal_corrosion_rate $x
# or in a pipeline:
@list |> map metal_corrosion_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metamorphic-grade">
<h3><a class="doc-anchor" href="#doc-metamorphic-grade">#</a> <code>metamorphic_grade</code></h3>
<p><code>metamorphic_grade</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = metamorphic_grade $x
# or in a pipeline:
@list |> map metamorphic_grade |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metaphone">
<h3><a class="doc-anchor" href="#doc-metaphone">#</a> <code>metaphone</code></h3>
<p><code>metaphone</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = metaphone $x
# or in a pipeline:
@list |> map metaphone |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metaphone-phonetic">
<h3><a class="doc-anchor" href="#doc-metaphone-phonetic">#</a> <code>metaphone_phonetic</code></h3>
<p><code>metaphone_phonetic</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = metaphone_phonetic $x
# or in a pipeline:
@list |> map metaphone_phonetic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-meters-to-feet">
<h3><a class="doc-anchor" href="#doc-meters-to-feet">#</a> <code>meters_to_feet</code></h3>
<p><code>meters_to_feet</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = meters_to_feet $input
</code></pre>
</article>
<article class="doc-entry" id="doc-methane-growth-rate">
<h3><a class="doc-anchor" href="#doc-methane-growth-rate">#</a> <code>methane_growth_rate</code></h3>
<p><code>methane_growth_rate</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = methane_growth_rate $x
# or in a pipeline:
@list |> map methane_growth_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metonic-cycle">
<h3><a class="doc-anchor" href="#doc-metonic-cycle">#</a> <code>metonic_cycle</code></h3>
<p><code>metonic_cycle</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = metonic_cycle $x
# or in a pipeline:
@list |> map metonic_cycle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metph">
<h3><a class="doc-anchor" href="#doc-metph">#</a> <code>metph</code></h3>
<p><code>metph</code> — encoding / phonetics builtin. Alias for <code>metaphone</code>.</p>
<pre><code class="lang-perl">my $result = metph $x
# or in a pipeline:
@list |> map metph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metric-frw-lapse">
<h3><a class="doc-anchor" href="#doc-metric-frw-lapse">#</a> <code>metric_frw_lapse</code></h3>
<p><code>metric_frw_lapse</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = metric_frw_lapse $x
# or in a pipeline:
@list |> map metric_frw_lapse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metric-kerr-step-simple">
<h3><a class="doc-anchor" href="#doc-metric-kerr-step-simple">#</a> <code>metric_kerr_step_simple</code></h3>
<p><code>metric_kerr_step_simple</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = metric_kerr_step_simple $x
# or in a pipeline:
@list |> map metric_kerr_step_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metric-minkowski-eta-step">
<h3><a class="doc-anchor" href="#doc-metric-minkowski-eta-step">#</a> <code>metric_minkowski_eta_step</code></h3>
<p><code>metric_minkowski_eta_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = metric_minkowski_eta_step $x
# or in a pipeline:
@list |> map metric_minkowski_eta_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metric-schwarzschild-step">
<h3><a class="doc-anchor" href="#doc-metric-schwarzschild-step">#</a> <code>metric_schwarzschild_step</code></h3>
<p><code>metric_schwarzschild_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = metric_schwarzschild_step $x
# or in a pipeline:
@list |> map metric_schwarzschild_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metro-hash-64">
<h3><a class="doc-anchor" href="#doc-metro-hash-64">#</a> <code>metro_hash_64</code></h3>
<p><code>metro_hash_64</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = metro_hash_64 $x
# or in a pipeline:
@list |> map metro_hash_64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mexican-hat-wavelet">
<h3><a class="doc-anchor" href="#doc-mexican-hat-wavelet">#</a> <code>mexican_hat_wavelet</code></h3>
<p><code>mexican_hat_wavelet</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = mexican_hat_wavelet $x
# or in a pipeline:
@list |> map mexican_hat_wavelet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mfcc-coeff-step">
<h3><a class="doc-anchor" href="#doc-mfcc-coeff-step">#</a> <code>mfcc_coeff_step</code></h3>
<p><code>mfcc_coeff_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = mfcc_coeff_step $x
# or in a pipeline:
@list |> map mfcc_coeff_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mflat">
<h3><a class="doc-anchor" href="#doc-mflat">#</a> <code>mflat</code></h3>
<p><code>mflat</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_flatten</code>.</p>
<pre><code class="lang-perl">my $result = mflat $x
# or in a pipeline:
@list |> map mflat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mfromr">
<h3><a class="doc-anchor" href="#doc-mfromr">#</a> <code>mfromr</code></h3>
<p><code>mfromr</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_from_rows</code>.</p>
<pre><code class="lang-perl">my $result = mfromr $x
# or in a pipeline:
@list |> map mfromr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mget">
<h3><a class="doc-anchor" href="#doc-mget">#</a> <code>mget</code></h3>
<p><code>mget</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = mget $x
# or in a pipeline:
@list |> map mget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mgrs-decode">
<h3><a class="doc-anchor" href="#doc-mgrs-decode">#</a> <code>mgrs_decode</code></h3>
<p><code>mgrs_decode</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = mgrs_decode $x
# or in a pipeline:
@list |> map mgrs_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mgrs-encode">
<h3><a class="doc-anchor" href="#doc-mgrs-encode">#</a> <code>mgrs_encode</code></h3>
<p><code>mgrs_encode</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = mgrs_encode $x
# or in a pipeline:
@list |> map mgrs_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mhad">
<h3><a class="doc-anchor" href="#doc-mhad">#</a> <code>mhad</code></h3>
<p><code>mhad</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_hadamard</code>.</p>
<pre><code class="lang-perl">my $result = mhad $x
# or in a pipeline:
@list |> map mhad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-michaelis-menten">
<h3><a class="doc-anchor" href="#doc-michaelis-menten">#</a> <code>michaelis_menten</code></h3>
<p><code>michaelis_menten</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = michaelis_menten $x
# or in a pipeline:
@list |> map michaelis_menten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-microlensing-magnification">
<h3><a class="doc-anchor" href="#doc-microlensing-magnification">#</a> <code>microlensing_magnification</code></h3>
<p><code>microlensing_magnification</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = microlensing_magnification $x
# or in a pipeline:
@list |> map microlensing_magnification |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mid-str">
<h3><a class="doc-anchor" href="#doc-mid-str">#</a> <code>mid_str</code></h3>
<p><code>mid_str</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = mid_str $x
# or in a pipeline:
@list |> map mid_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mident">
<h3><a class="doc-anchor" href="#doc-mident">#</a> <code>mident</code></h3>
<p><code>mident</code> — extended stdlib builtin. Alias for <code>matrix_identity</code>.</p>
<pre><code class="lang-perl">my $result = mident $x
# or in a pipeline:
@list |> map mident |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midi-to-hz">
<h3><a class="doc-anchor" href="#doc-midi-to-hz">#</a> <code>midi_to_hz</code></h3>
<p><code>midi_to_hz</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = midi_to_hz $input
</code></pre>
</article>
<article class="doc-entry" id="doc-midi-to-pitch-class">
<h3><a class="doc-anchor" href="#doc-midi-to-pitch-class">#</a> <code>midi_to_pitch_class</code></h3>
<p><code>midi_to_pitch_class</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = midi_to_pitch_class $input
</code></pre>
</article>
<article class="doc-entry" id="doc-midpnt">
<h3><a class="doc-anchor" href="#doc-midpnt">#</a> <code>midpnt</code></h3>
<p><code>midpnt</code> — geometry / physics builtin. Alias for <code>midpoint</code>.</p>
<pre><code class="lang-perl">my $result = midpnt $x
# or in a pipeline:
@list |> map midpnt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpoint">
<h3><a class="doc-anchor" href="#doc-midpoint">#</a> <code>midpoint</code></h3>
<p><code>midpoint</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = midpoint $x
# or in a pipeline:
@list |> map midpoint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpoint-great-circle">
<h3><a class="doc-anchor" href="#doc-midpoint-great-circle">#</a> <code>midpoint_great_circle</code></h3>
<p><code>midpoint_great_circle</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = midpoint_great_circle $x
# or in a pipeline:
@list |> map midpoint_great_circle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpoint-of">
<h3><a class="doc-anchor" href="#doc-midpoint-of">#</a> <code>midpoint_of</code></h3>
<p><code>midpoint_of</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = midpoint_of $x
# or in a pipeline:
@list |> map midpoint_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpoint-rule">
<h3><a class="doc-anchor" href="#doc-midpoint-rule">#</a> <code>midpoint_rule</code></h3>
<p><code>midpoint_rule</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = midpoint_rule $x
# or in a pipeline:
@list |> map midpoint_rule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpt">
<h3><a class="doc-anchor" href="#doc-midpt">#</a> <code>midpt</code></h3>
<p><code>midpt</code> — extended stdlib builtin. Alias for <code>midpoint_of</code>.</p>
<pre><code class="lang-perl">my $result = midpt $x
# or in a pipeline:
@list |> map midpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-miles-to-km">
<h3><a class="doc-anchor" href="#doc-miles-to-km">#</a> <code>miles_to_km</code></h3>
<p><code>miles_to_km</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = miles_to_km $input
</code></pre>
</article>
<article class="doc-entry" id="doc-miles-to-m">
<h3><a class="doc-anchor" href="#doc-miles-to-m">#</a> <code>miles_to_m</code></h3>
<p><code>miles_to_m</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = miles_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-milne">
<h3><a class="doc-anchor" href="#doc-milne">#</a> <code>milne</code></h3>
<p><code>milne</code> — batch 19 builtin. Alias for <code>milne_pc</code>.</p>
<pre><code class="lang-perl">my $result = milne $x
# or in a pipeline:
@list |> map milne |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-milne-pc">
<h3><a class="doc-anchor" href="#doc-milne-pc">#</a> <code>milne_pc</code></h3>
<p><code>milne_pc</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = milne_pc $x
# or in a pipeline:
@list |> map milne_pc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-milstein-step">
<h3><a class="doc-anchor" href="#doc-milstein-step">#</a> <code>milstein_step</code></h3>
<p><code>milstein_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = milstein_step $x
# or in a pipeline:
@list |> map milstein_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min2">
<h3><a class="doc-anchor" href="#doc-min2">#</a> <code>min2</code></h3>
<p><code>min2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = min2 $x
# or in a pipeline:
@list |> map min2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-abs">
<h3><a class="doc-anchor" href="#doc-min-abs">#</a> <code>min_abs</code></h3>
<p><code>min_abs</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = min_abs $x
# or in a pipeline:
@list |> map min_abs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-by">
<h3><a class="doc-anchor" href="#doc-min-by">#</a> <code>min_by</code></h3>
<p><code>min_by</code> — functional / iterator builtin. Alias for <code>take_while</code>.</p>
<pre><code class="lang-perl">my $result = min_by $x
# or in a pipeline:
@list |> map min_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-cut-value">
<h3><a class="doc-anchor" href="#doc-min-cut-value">#</a> <code>min_cut_value</code></h3>
<p><code>min_cut_value</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = min_cut_value $x
# or in a pipeline:
@list |> map min_cut_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-float">
<h3><a class="doc-anchor" href="#doc-min-float">#</a> <code>min_float</code></h3>
<p><code>min_float</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = min_float $x
# or in a pipeline:
@list |> map min_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-list">
<h3><a class="doc-anchor" href="#doc-min-list">#</a> <code>min_list</code></h3>
<p><code>min_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = min_list $x
# or in a pipeline:
@list |> map min_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-max">
<h3><a class="doc-anchor" href="#doc-min-max">#</a> <code>min_max</code></h3>
<p><code>min_max</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = min_max $x
# or in a pipeline:
@list |> map min_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-of">
<h3><a class="doc-anchor" href="#doc-min-of">#</a> <code>min_of</code></h3>
<p><code>min_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = min_of $x
# or in a pipeline:
@list |> map min_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-steiner-tree">
<h3><a class="doc-anchor" href="#doc-min-steiner-tree">#</a> <code>min_steiner_tree</code></h3>
<p><code>min_steiner_tree</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = min_steiner_tree $x
# or in a pipeline:
@list |> map min_steiner_tree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-vertex-cover">
<h3><a class="doc-anchor" href="#doc-min-vertex-cover">#</a> <code>min_vertex_cover</code></h3>
<p><code>min_vertex_cover</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = min_vertex_cover $x
# or in a pipeline:
@list |> map min_vertex_cover |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minby">
<h3><a class="doc-anchor" href="#doc-minby">#</a> <code>minby</code></h3>
<p><code>minby</code> — additional missing stdlib functions builtin. Alias for <code>minimum_by</code>.</p>
<pre><code class="lang-perl">my $result = minby $x
# or in a pipeline:
@list |> map minby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mincut-stoer-wagner">
<h3><a class="doc-anchor" href="#doc-mincut-stoer-wagner">#</a> <code>mincut_stoer_wagner</code></h3>
<p><code>mincut_stoer_wagner</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = mincut_stoer_wagner $x
# or in a pipeline:
@list |> map mincut_stoer_wagner |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mineral-mohs-hardness">
<h3><a class="doc-anchor" href="#doc-mineral-mohs-hardness">#</a> <code>mineral_mohs_hardness</code></h3>
<p><code>mineral_mohs_hardness</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = mineral_mohs_hardness $x
# or in a pipeline:
@list |> map mineral_mohs_hardness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minimum-by">
<h3><a class="doc-anchor" href="#doc-minimum-by">#</a> <code>minimum_by</code></h3>
<p><code>minimum_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = minimum_by $x
# or in a pipeline:
@list |> map minimum_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minkdist">
<h3><a class="doc-anchor" href="#doc-minkdist">#</a> <code>minkdist</code></h3>
<p><code>minkdist</code> — math / numeric (uncategorized batch) builtin. Alias for <code>minkowski_distance</code>.</p>
<pre><code class="lang-perl">my $result = minkdist $x
# or in a pipeline:
@list |> map minkdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minkowski-distance">
<h3><a class="doc-anchor" href="#doc-minkowski-distance">#</a> <code>minkowski_distance</code></h3>
<p><code>minkowski_distance</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = minkowski_distance $x
# or in a pipeline:
@list |> map minkowski_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minkowski-sum-simple">
<h3><a class="doc-anchor" href="#doc-minkowski-sum-simple">#</a> <code>minkowski_sum_simple</code></h3>
<p><code>minkowski_sum_simple</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = minkowski_sum_simple $x
# or in a pipeline:
@list |> map minkowski_sum_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minmax">
<h3><a class="doc-anchor" href="#doc-minmax">#</a> <code>minmax</code></h3>
<p><code>minmax</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = minmax $x
# or in a pipeline:
@list |> map minmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minmax-by">
<h3><a class="doc-anchor" href="#doc-minmax-by">#</a> <code>minmax_by</code></h3>
<p><code>minmax_by</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = minmax_by $x
# or in a pipeline:
@list |> map minmax_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minmax-scale">
<h3><a class="doc-anchor" href="#doc-minmax-scale">#</a> <code>minmax_scale</code></h3>
<p><code>minmax_scale</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = minmax_scale $x
# or in a pipeline:
@list |> map minmax_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minmod-limiter">
<h3><a class="doc-anchor" href="#doc-minmod-limiter">#</a> <code>minmod_limiter</code></h3>
<p><code>minmod_limiter</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = minmod_limiter $x
# or in a pipeline:
@list |> map minmod_limiter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minstr">
<h3><a class="doc-anchor" href="#doc-minstr">#</a> <code>minstr</code></h3>
<p><code>minstr</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = minstr $x
# or in a pipeline:
@list |> map minstr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minutes-to-hours">
<h3><a class="doc-anchor" href="#doc-minutes-to-hours">#</a> <code>minutes_to_hours</code></h3>
<p><code>minutes_to_hours</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = minutes_to_hours $input
</code></pre>
</article>
<article class="doc-entry" id="doc-minutes-to-seconds">
<h3><a class="doc-anchor" href="#doc-minutes-to-seconds">#</a> <code>minutes_to_seconds</code></h3>
<p><code>minutes_to_seconds</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = minutes_to_seconds $input
</code></pre>
</article>
<article class="doc-entry" id="doc-minv">
<h3><a class="doc-anchor" href="#doc-minv">#</a> <code>minv</code></h3>
<p><code>minv</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_inverse</code>.</p>
<pre><code class="lang-perl">my $result = minv $x
# or in a pipeline:
@list |> map minv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mirr">
<h3><a class="doc-anchor" href="#doc-mirr">#</a> <code>mirr</code></h3>
<p><code>mirr</code> — batch 10 builtin. Alias for <code>modified_irr</code>.</p>
<pre><code class="lang-perl">my $result = mirr $x
# or in a pipeline:
@list |> map mirr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mirr-excel">
<h3><a class="doc-anchor" href="#doc-mirr-excel">#</a> <code>mirr_excel</code></h3>
<p><code>mirr_excel</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = mirr_excel $x
# or in a pipeline:
@list |> map mirr_excel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mirror-descent-step">
<h3><a class="doc-anchor" href="#doc-mirror-descent-step">#</a> <code>mirror_descent_step</code></h3>
<p><code>mirror_descent_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = mirror_descent_step $x
# or in a pipeline:
@list |> map mirror_descent_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mirror-equation-v">
<h3><a class="doc-anchor" href="#doc-mirror-equation-v">#</a> <code>mirror_equation_v</code></h3>
<p><code>mirror_equation_v</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = mirror_equation_v $x
# or in a pipeline:
@list |> map mirror_equation_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mirror-string">
<h3><a class="doc-anchor" href="#doc-mirror-string">#</a> <code>mirror_string</code></h3>
<p><code>mirror_string</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = mirror_string $x
# or in a pipeline:
@list |> map mirror_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mirror-symmetry-check">
<h3><a class="doc-anchor" href="#doc-mirror-symmetry-check">#</a> <code>mirror_symmetry_check</code></h3>
<p><code>mirror_symmetry_check</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = mirror_symmetry_check $x
# or in a pipeline:
@list |> map mirror_symmetry_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mish">
<h3><a class="doc-anchor" href="#doc-mish">#</a> <code>mish</code></h3>
<p><code>mish</code> applies the Mish activation: x·tanh(softplus(x)). Often outperforms ReLU/Swish.</p>
<pre><code class="lang-perl">p mish(1) # 0.8651
p mish(-1) # -0.3034
</code></pre>
</article>
<article class="doc-entry" id="doc-mixed-integer-round-down">
<h3><a class="doc-anchor" href="#doc-mixed-integer-round-down">#</a> <code>mixed_integer_round_down</code></h3>
<p><code>mixed_integer_round_down</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = mixed_integer_round_down $x
# or in a pipeline:
@list |> map mixed_integer_round_down |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mixed-integer-round-up">
<h3><a class="doc-anchor" href="#doc-mixed-integer-round-up">#</a> <code>mixed_integer_round_up</code></h3>
<p><code>mixed_integer_round_up</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = mixed_integer_round_up $x
# or in a pipeline:
@list |> map mixed_integer_round_up |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mixed-potential-step">
<h3><a class="doc-anchor" href="#doc-mixed-potential-step">#</a> <code>mixed_potential_step</code></h3>
<p><code>mixed_potential_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = mixed_potential_step $x
# or in a pipeline:
@list |> map mixed_potential_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mixed-strategy-value">
<h3><a class="doc-anchor" href="#doc-mixed-strategy-value">#</a> <code>mixed_strategy_value</code></h3>
<p><code>mixed_strategy_value</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = mixed_strategy_value $x
# or in a pipeline:
@list |> map mixed_strategy_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mixing-length-prandtl">
<h3><a class="doc-anchor" href="#doc-mixing-length-prandtl">#</a> <code>mixing_length_prandtl</code></h3>
<p><code>mixing_length_prandtl</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = mixing_length_prandtl $x
# or in a pipeline:
@list |> map mixing_length_prandtl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mjo-phase-step">
<h3><a class="doc-anchor" href="#doc-mjo-phase-step">#</a> <code>mjo_phase_step</code></h3>
<p><code>mjo_phase_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = mjo_phase_step $x
# or in a pipeline:
@list |> map mjo_phase_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-adabelief-step">
<h3><a class="doc-anchor" href="#doc-ml-adabelief-step">#</a> <code>ml_adabelief_step</code></h3>
<p><code>ml_adabelief_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_adabelief_step $x
# or in a pipeline:
@list |> map ml_adabelief_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-adagrad-step">
<h3><a class="doc-anchor" href="#doc-ml-adagrad-step">#</a> <code>ml_adagrad_step</code></h3>
<p><code>ml_adagrad_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_adagrad_step $x
# or in a pipeline:
@list |> map ml_adagrad_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-adam-step">
<h3><a class="doc-anchor" href="#doc-ml-adam-step">#</a> <code>ml_adam_step</code></h3>
<p><code>ml_adam_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_adam_step $x
# or in a pipeline:
@list |> map ml_adam_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-adamax-step">
<h3><a class="doc-anchor" href="#doc-ml-adamax-step">#</a> <code>ml_adamax_step</code></h3>
<p><code>ml_adamax_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_adamax_step $x
# or in a pipeline:
@list |> map ml_adamax_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-adamw-step">
<h3><a class="doc-anchor" href="#doc-ml-adamw-step">#</a> <code>ml_adamw_step</code></h3>
<p><code>ml_adamw_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_adamw_step $x
# or in a pipeline:
@list |> map ml_adamw_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-amsgrad-step">
<h3><a class="doc-anchor" href="#doc-ml-amsgrad-step">#</a> <code>ml_amsgrad_step</code></h3>
<p><code>ml_amsgrad_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_amsgrad_step $x
# or in a pipeline:
@list |> map ml_amsgrad_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-arcface-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-arcface-loss-step">#</a> <code>ml_arcface_loss_step</code></h3>
<p><code>ml_arcface_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_arcface_loss_step $x
# or in a pipeline:
@list |> map ml_arcface_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-attention-score-step">
<h3><a class="doc-anchor" href="#doc-ml-attention-score-step">#</a> <code>ml_attention_score_step</code></h3>
<p><code>ml_attention_score_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_attention_score_step $x
# or in a pipeline:
@list |> map ml_attention_score_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-batch-norm-step">
<h3><a class="doc-anchor" href="#doc-ml-batch-norm-step">#</a> <code>ml_batch_norm_step</code></h3>
<p><code>ml_batch_norm_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_batch_norm_step $x
# or in a pipeline:
@list |> map ml_batch_norm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-binary-cross-entropy">
<h3><a class="doc-anchor" href="#doc-ml-binary-cross-entropy">#</a> <code>ml_binary_cross_entropy</code></h3>
<p><code>ml_binary_cross_entropy</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_binary_cross_entropy $x
# or in a pipeline:
@list |> map ml_binary_cross_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-celu-step">
<h3><a class="doc-anchor" href="#doc-ml-celu-step">#</a> <code>ml_celu_step</code></h3>
<p><code>ml_celu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_celu_step $x
# or in a pipeline:
@list |> map ml_celu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-center-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-center-loss-step">#</a> <code>ml_center_loss_step</code></h3>
<p><code>ml_center_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_center_loss_step $x
# or in a pipeline:
@list |> map ml_center_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-ciou-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-ciou-loss-step">#</a> <code>ml_ciou_loss_step</code></h3>
<p><code>ml_ciou_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_ciou_loss_step $x
# or in a pipeline:
@list |> map ml_ciou_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-constant-init">
<h3><a class="doc-anchor" href="#doc-ml-constant-init">#</a> <code>ml_constant_init</code></h3>
<p><code>ml_constant_init</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_constant_init $x
# or in a pipeline:
@list |> map ml_constant_init |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-contrastive-loss">
<h3><a class="doc-anchor" href="#doc-ml-contrastive-loss">#</a> <code>ml_contrastive_loss</code></h3>
<p><code>ml_contrastive_loss</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_contrastive_loss $x
# or in a pipeline:
@list |> map ml_contrastive_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-cosine-lr-schedule">
<h3><a class="doc-anchor" href="#doc-ml-cosine-lr-schedule">#</a> <code>ml_cosine_lr_schedule</code></h3>
<p><code>ml_cosine_lr_schedule</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_cosine_lr_schedule $x
# or in a pipeline:
@list |> map ml_cosine_lr_schedule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-cross-entropy-loss">
<h3><a class="doc-anchor" href="#doc-ml-cross-entropy-loss">#</a> <code>ml_cross_entropy_loss</code></h3>
<p><code>ml_cross_entropy_loss</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_cross_entropy_loss $x
# or in a pipeline:
@list |> map ml_cross_entropy_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-cutmix-box-iou">
<h3><a class="doc-anchor" href="#doc-ml-cutmix-box-iou">#</a> <code>ml_cutmix_box_iou</code></h3>
<p><code>ml_cutmix_box_iou</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_cutmix_box_iou $x
# or in a pipeline:
@list |> map ml_cutmix_box_iou |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-cyclic-lr-step">
<h3><a class="doc-anchor" href="#doc-ml-cyclic-lr-step">#</a> <code>ml_cyclic_lr_step</code></h3>
<p><code>ml_cyclic_lr_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_cyclic_lr_step $x
# or in a pipeline:
@list |> map ml_cyclic_lr_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-dice-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-dice-loss-step">#</a> <code>ml_dice_loss_step</code></h3>
<p><code>ml_dice_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_dice_loss_step $x
# or in a pipeline:
@list |> map ml_dice_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-diou-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-diou-loss-step">#</a> <code>ml_diou_loss_step</code></h3>
<p><code>ml_diou_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_diou_loss_step $x
# or in a pipeline:
@list |> map ml_diou_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-dropout-mask-prob">
<h3><a class="doc-anchor" href="#doc-ml-dropout-mask-prob">#</a> <code>ml_dropout_mask_prob</code></h3>
<p><code>ml_dropout_mask_prob</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_dropout_mask_prob $x
# or in a pipeline:
@list |> map ml_dropout_mask_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-elu-step">
<h3><a class="doc-anchor" href="#doc-ml-elu-step">#</a> <code>ml_elu_step</code></h3>
<p><code>ml_elu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_elu_step $x
# or in a pipeline:
@list |> map ml_elu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-eos-logit-boost">
<h3><a class="doc-anchor" href="#doc-ml-eos-logit-boost">#</a> <code>ml_eos_logit_boost</code></h3>
<p><code>ml_eos_logit_boost</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_eos_logit_boost $x
# or in a pipeline:
@list |> map ml_eos_logit_boost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-exponential-lr">
<h3><a class="doc-anchor" href="#doc-ml-exponential-lr">#</a> <code>ml_exponential_lr</code></h3>
<p><code>ml_exponential_lr</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_exponential_lr $x
# or in a pipeline:
@list |> map ml_exponential_lr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-focal-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-focal-loss-step">#</a> <code>ml_focal_loss_step</code></h3>
<p><code>ml_focal_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_focal_loss_step $x
# or in a pipeline:
@list |> map ml_focal_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-geglu-step">
<h3><a class="doc-anchor" href="#doc-ml-geglu-step">#</a> <code>ml_geglu_step</code></h3>
<p><code>ml_geglu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_geglu_step $x
# or in a pipeline:
@list |> map ml_geglu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-gelu-step">
<h3><a class="doc-anchor" href="#doc-ml-gelu-step">#</a> <code>ml_gelu_step</code></h3>
<p><code>ml_gelu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_gelu_step $x
# or in a pipeline:
@list |> map ml_gelu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-giou-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-giou-loss-step">#</a> <code>ml_giou_loss_step</code></h3>
<p><code>ml_giou_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_giou_loss_step $x
# or in a pipeline:
@list |> map ml_giou_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-glorot-init-value">
<h3><a class="doc-anchor" href="#doc-ml-glorot-init-value">#</a> <code>ml_glorot_init_value</code></h3>
<p><code>ml_glorot_init_value</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_glorot_init_value $x
# or in a pipeline:
@list |> map ml_glorot_init_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-glu-step">
<h3><a class="doc-anchor" href="#doc-ml-glu-step">#</a> <code>ml_glu_step</code></h3>
<p><code>ml_glu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_glu_step $x
# or in a pipeline:
@list |> map ml_glu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-gradient-accumulate">
<h3><a class="doc-anchor" href="#doc-ml-gradient-accumulate">#</a> <code>ml_gradient_accumulate</code></h3>
<p><code>ml_gradient_accumulate</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_gradient_accumulate $x
# or in a pipeline:
@list |> map ml_gradient_accumulate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-gradient-centralize">
<h3><a class="doc-anchor" href="#doc-ml-gradient-centralize">#</a> <code>ml_gradient_centralize</code></h3>
<p><code>ml_gradient_centralize</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_gradient_centralize $x
# or in a pipeline:
@list |> map ml_gradient_centralize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-gradient-clip-norm">
<h3><a class="doc-anchor" href="#doc-ml-gradient-clip-norm">#</a> <code>ml_gradient_clip_norm</code></h3>
<p><code>ml_gradient_clip_norm</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_gradient_clip_norm $x
# or in a pipeline:
@list |> map ml_gradient_clip_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-gradient-clip-value">
<h3><a class="doc-anchor" href="#doc-ml-gradient-clip-value">#</a> <code>ml_gradient_clip_value</code></h3>
<p><code>ml_gradient_clip_value</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_gradient_clip_value $x
# or in a pipeline:
@list |> map ml_gradient_clip_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-group-norm-step">
<h3><a class="doc-anchor" href="#doc-ml-group-norm-step">#</a> <code>ml_group_norm_step</code></h3>
<p><code>ml_group_norm_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_group_norm_step $x
# or in a pipeline:
@list |> map ml_group_norm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-hard-sigmoid">
<h3><a class="doc-anchor" href="#doc-ml-hard-sigmoid">#</a> <code>ml_hard_sigmoid</code></h3>
<p><code>ml_hard_sigmoid</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_hard_sigmoid $x
# or in a pipeline:
@list |> map ml_hard_sigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-hard-tanh">
<h3><a class="doc-anchor" href="#doc-ml-hard-tanh">#</a> <code>ml_hard_tanh</code></h3>
<p><code>ml_hard_tanh</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_hard_tanh $x
# or in a pipeline:
@list |> map ml_hard_tanh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-he-init-value">
<h3><a class="doc-anchor" href="#doc-ml-he-init-value">#</a> <code>ml_he_init_value</code></h3>
<p><code>ml_he_init_value</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_he_init_value $x
# or in a pipeline:
@list |> map ml_he_init_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-huber-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-huber-loss-step">#</a> <code>ml_huber_loss_step</code></h3>
<p><code>ml_huber_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_huber_loss_step $x
# or in a pipeline:
@list |> map ml_huber_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-id-to-label-step">
<h3><a class="doc-anchor" href="#doc-ml-id-to-label-step">#</a> <code>ml_id_to_label_step</code></h3>
<p><code>ml_id_to_label_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_id_to_label_step $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-instance-norm-step">
<h3><a class="doc-anchor" href="#doc-ml-instance-norm-step">#</a> <code>ml_instance_norm_step</code></h3>
<p><code>ml_instance_norm_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_instance_norm_step $x
# or in a pipeline:
@list |> map ml_instance_norm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-inverse-sqrt-lr">
<h3><a class="doc-anchor" href="#doc-ml-inverse-sqrt-lr">#</a> <code>ml_inverse_sqrt_lr</code></h3>
<p><code>ml_inverse_sqrt_lr</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_inverse_sqrt_lr $x
# or in a pipeline:
@list |> map ml_inverse_sqrt_lr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-iou-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-iou-loss-step">#</a> <code>ml_iou_loss_step</code></h3>
<p><code>ml_iou_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_iou_loss_step $x
# or in a pipeline:
@list |> map ml_iou_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-kaiming-init">
<h3><a class="doc-anchor" href="#doc-ml-kaiming-init">#</a> <code>ml_kaiming_init</code></h3>
<p><code>ml_kaiming_init</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_kaiming_init $x
# or in a pipeline:
@list |> map ml_kaiming_init |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-kl-divergence-loss">
<h3><a class="doc-anchor" href="#doc-ml-kl-divergence-loss">#</a> <code>ml_kl_divergence_loss</code></h3>
<p><code>ml_kl_divergence_loss</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_kl_divergence_loss $x
# or in a pipeline:
@list |> map ml_kl_divergence_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-l2-normalize-step">
<h3><a class="doc-anchor" href="#doc-ml-l2-normalize-step">#</a> <code>ml_l2_normalize_step</code></h3>
<p><code>ml_l2_normalize_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_l2_normalize_step $x
# or in a pipeline:
@list |> map ml_l2_normalize_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-label-smoothing">
<h3><a class="doc-anchor" href="#doc-ml-label-smoothing">#</a> <code>ml_label_smoothing</code></h3>
<p><code>ml_label_smoothing</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_label_smoothing $x
# or in a pipeline:
@list |> map ml_label_smoothing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-label-to-id">
<h3><a class="doc-anchor" href="#doc-ml-label-to-id">#</a> <code>ml_label_to_id</code></h3>
<p><code>ml_label_to_id</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_label_to_id $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-lamb-step">
<h3><a class="doc-anchor" href="#doc-ml-lamb-step">#</a> <code>ml_lamb_step</code></h3>
<p><code>ml_lamb_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_lamb_step $x
# or in a pipeline:
@list |> map ml_lamb_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-lars-step">
<h3><a class="doc-anchor" href="#doc-ml-lars-step">#</a> <code>ml_lars_step</code></h3>
<p><code>ml_lars_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_lars_step $x
# or in a pipeline:
@list |> map ml_lars_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-layer-norm-step">
<h3><a class="doc-anchor" href="#doc-ml-layer-norm-step">#</a> <code>ml_layer_norm_step</code></h3>
<p><code>ml_layer_norm_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_layer_norm_step $x
# or in a pipeline:
@list |> map ml_layer_norm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-leaky-relu-step">
<h3><a class="doc-anchor" href="#doc-ml-leaky-relu-step">#</a> <code>ml_leaky_relu_step</code></h3>
<p><code>ml_leaky_relu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_leaky_relu_step $x
# or in a pipeline:
@list |> map ml_leaky_relu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-lecun-init-value">
<h3><a class="doc-anchor" href="#doc-ml-lecun-init-value">#</a> <code>ml_lecun_init_value</code></h3>
<p><code>ml_lecun_init_value</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_lecun_init_value $x
# or in a pipeline:
@list |> map ml_lecun_init_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-lion-step">
<h3><a class="doc-anchor" href="#doc-ml-lion-step">#</a> <code>ml_lion_step</code></h3>
<p><code>ml_lion_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_lion_step $x
# or in a pipeline:
@list |> map ml_lion_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-log-sigmoid">
<h3><a class="doc-anchor" href="#doc-ml-log-sigmoid">#</a> <code>ml_log_sigmoid</code></h3>
<p><code>ml_log_sigmoid</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_log_sigmoid $x
# or in a pipeline:
@list |> map ml_log_sigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-log-softmax-step">
<h3><a class="doc-anchor" href="#doc-ml-log-softmax-step">#</a> <code>ml_log_softmax_step</code></h3>
<p><code>ml_log_softmax_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_log_softmax_step $x
# or in a pipeline:
@list |> map ml_log_softmax_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-logsumexp-step">
<h3><a class="doc-anchor" href="#doc-ml-logsumexp-step">#</a> <code>ml_logsumexp_step</code></h3>
<p><code>ml_logsumexp_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_logsumexp_step $x
# or in a pipeline:
@list |> map ml_logsumexp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-lookahead-step">
<h3><a class="doc-anchor" href="#doc-ml-lookahead-step">#</a> <code>ml_lookahead_step</code></h3>
<p><code>ml_lookahead_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_lookahead_step $x
# or in a pipeline:
@list |> map ml_lookahead_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-mish-step">
<h3><a class="doc-anchor" href="#doc-ml-mish-step">#</a> <code>ml_mish_step</code></h3>
<p><code>ml_mish_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_mish_step $x
# or in a pipeline:
@list |> map ml_mish_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-mixup-lambda">
<h3><a class="doc-anchor" href="#doc-ml-mixup-lambda">#</a> <code>ml_mixup_lambda</code></h3>
<p><code>ml_mixup_lambda</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_mixup_lambda $x
# or in a pipeline:
@list |> map ml_mixup_lambda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-momentum-step">
<h3><a class="doc-anchor" href="#doc-ml-momentum-step">#</a> <code>ml_momentum_step</code></h3>
<p><code>ml_momentum_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_momentum_step $x
# or in a pipeline:
@list |> map ml_momentum_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-multihead-avg">
<h3><a class="doc-anchor" href="#doc-ml-multihead-avg">#</a> <code>ml_multihead_avg</code></h3>
<p><code>ml_multihead_avg</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_multihead_avg $x
# or in a pipeline:
@list |> map ml_multihead_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-nadam-step">
<h3><a class="doc-anchor" href="#doc-ml-nadam-step">#</a> <code>ml_nadam_step</code></h3>
<p><code>ml_nadam_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_nadam_step $x
# or in a pipeline:
@list |> map ml_nadam_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-nesterov-momentum">
<h3><a class="doc-anchor" href="#doc-ml-nesterov-momentum">#</a> <code>ml_nesterov_momentum</code></h3>
<p><code>ml_nesterov_momentum</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_nesterov_momentum $x
# or in a pipeline:
@list |> map ml_nesterov_momentum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-nucleus-sample-p">
<h3><a class="doc-anchor" href="#doc-ml-nucleus-sample-p">#</a> <code>ml_nucleus_sample_p</code></h3>
<p><code>ml_nucleus_sample_p</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_nucleus_sample_p $x
# or in a pipeline:
@list |> map ml_nucleus_sample_p |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-one-cycle-lr">
<h3><a class="doc-anchor" href="#doc-ml-one-cycle-lr">#</a> <code>ml_one_cycle_lr</code></h3>
<p><code>ml_one_cycle_lr</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_one_cycle_lr $x
# or in a pipeline:
@list |> map ml_one_cycle_lr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-one-hot-index">
<h3><a class="doc-anchor" href="#doc-ml-one-hot-index">#</a> <code>ml_one_hot_index</code></h3>
<p><code>ml_one_hot_index</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_one_hot_index $x
# or in a pipeline:
@list |> map ml_one_hot_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-orthogonal-init">
<h3><a class="doc-anchor" href="#doc-ml-orthogonal-init">#</a> <code>ml_orthogonal_init</code></h3>
<p><code>ml_orthogonal_init</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_orthogonal_init $x
# or in a pipeline:
@list |> map ml_orthogonal_init |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-polynomial-lr">
<h3><a class="doc-anchor" href="#doc-ml-polynomial-lr">#</a> <code>ml_polynomial_lr</code></h3>
<p><code>ml_polynomial_lr</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_polynomial_lr $x
# or in a pipeline:
@list |> map ml_polynomial_lr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-prelu-step">
<h3><a class="doc-anchor" href="#doc-ml-prelu-step">#</a> <code>ml_prelu_step</code></h3>
<p><code>ml_prelu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_prelu_step $x
# or in a pipeline:
@list |> map ml_prelu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-radam-step">
<h3><a class="doc-anchor" href="#doc-ml-radam-step">#</a> <code>ml_radam_step</code></h3>
<p><code>ml_radam_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_radam_step $x
# or in a pipeline:
@list |> map ml_radam_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-random-erasing-step">
<h3><a class="doc-anchor" href="#doc-ml-random-erasing-step">#</a> <code>ml_random_erasing_step</code></h3>
<p><code>ml_random_erasing_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_random_erasing_step $x
# or in a pipeline:
@list |> map ml_random_erasing_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-relu-step">
<h3><a class="doc-anchor" href="#doc-ml-relu-step">#</a> <code>ml_relu_step</code></h3>
<p><code>ml_relu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_relu_step $x
# or in a pipeline:
@list |> map ml_relu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-repetition-penalty">
<h3><a class="doc-anchor" href="#doc-ml-repetition-penalty">#</a> <code>ml_repetition_penalty</code></h3>
<p><code>ml_repetition_penalty</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_repetition_penalty $x
# or in a pipeline:
@list |> map ml_repetition_penalty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-rms-norm-step">
<h3><a class="doc-anchor" href="#doc-ml-rms-norm-step">#</a> <code>ml_rms_norm_step</code></h3>
<p><code>ml_rms_norm_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_rms_norm_step $x
# or in a pipeline:
@list |> map ml_rms_norm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-rmsprop-step">
<h3><a class="doc-anchor" href="#doc-ml-rmsprop-step">#</a> <code>ml_rmsprop_step</code></h3>
<p><code>ml_rmsprop_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_rmsprop_step $x
# or in a pipeline:
@list |> map ml_rmsprop_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-scaled-dot-product">
<h3><a class="doc-anchor" href="#doc-ml-scaled-dot-product">#</a> <code>ml_scaled_dot_product</code></h3>
<p><code>ml_scaled_dot_product</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_scaled_dot_product $x
# or in a pipeline:
@list |> map ml_scaled_dot_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-selu-step">
<h3><a class="doc-anchor" href="#doc-ml-selu-step">#</a> <code>ml_selu_step</code></h3>
<p><code>ml_selu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_selu_step $x
# or in a pipeline:
@list |> map ml_selu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-sgd-step">
<h3><a class="doc-anchor" href="#doc-ml-sgd-step">#</a> <code>ml_sgd_step</code></h3>
<p><code>ml_sgd_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_sgd_step $x
# or in a pipeline:
@list |> map ml_sgd_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-shampoo-step">
<h3><a class="doc-anchor" href="#doc-ml-shampoo-step">#</a> <code>ml_shampoo_step</code></h3>
<p><code>ml_shampoo_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_shampoo_step $x
# or in a pipeline:
@list |> map ml_shampoo_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-silu-step">
<h3><a class="doc-anchor" href="#doc-ml-silu-step">#</a> <code>ml_silu_step</code></h3>
<p><code>ml_silu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_silu_step $x
# or in a pipeline:
@list |> map ml_silu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-smooth-l1-loss">
<h3><a class="doc-anchor" href="#doc-ml-smooth-l1-loss">#</a> <code>ml_smooth_l1_loss</code></h3>
<p><code>ml_smooth_l1_loss</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_smooth_l1_loss $x
# or in a pipeline:
@list |> map ml_smooth_l1_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-softmax-temperature">
<h3><a class="doc-anchor" href="#doc-ml-softmax-temperature">#</a> <code>ml_softmax_temperature</code></h3>
<p><code>ml_softmax_temperature</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_softmax_temperature $x
# or in a pipeline:
@list |> map ml_softmax_temperature |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-softplus-step">
<h3><a class="doc-anchor" href="#doc-ml-softplus-step">#</a> <code>ml_softplus_step</code></h3>
<p><code>ml_softplus_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_softplus_step $x
# or in a pipeline:
@list |> map ml_softplus_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-softsign-step">
<h3><a class="doc-anchor" href="#doc-ml-softsign-step">#</a> <code>ml_softsign_step</code></h3>
<p><code>ml_softsign_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_softsign_step $x
# or in a pipeline:
@list |> map ml_softsign_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-sophia-step">
<h3><a class="doc-anchor" href="#doc-ml-sophia-step">#</a> <code>ml_sophia_step</code></h3>
<p><code>ml_sophia_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_sophia_step $x
# or in a pipeline:
@list |> map ml_sophia_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-spectral-norm-step">
<h3><a class="doc-anchor" href="#doc-ml-spectral-norm-step">#</a> <code>ml_spectral_norm_step</code></h3>
<p><code>ml_spectral_norm_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_spectral_norm_step $x
# or in a pipeline:
@list |> map ml_spectral_norm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-step-lr-schedule">
<h3><a class="doc-anchor" href="#doc-ml-step-lr-schedule">#</a> <code>ml_step_lr_schedule</code></h3>
<p><code>ml_step_lr_schedule</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_step_lr_schedule $x
# or in a pipeline:
@list |> map ml_step_lr_schedule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-swiglu-step">
<h3><a class="doc-anchor" href="#doc-ml-swiglu-step">#</a> <code>ml_swiglu_step</code></h3>
<p><code>ml_swiglu_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_swiglu_step $x
# or in a pipeline:
@list |> map ml_swiglu_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-swish-step">
<h3><a class="doc-anchor" href="#doc-ml-swish-step">#</a> <code>ml_swish_step</code></h3>
<p><code>ml_swish_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_swish_step $x
# or in a pipeline:
@list |> map ml_swish_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-temperature-decay">
<h3><a class="doc-anchor" href="#doc-ml-temperature-decay">#</a> <code>ml_temperature_decay</code></h3>
<p><code>ml_temperature_decay</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_temperature_decay $x
# or in a pipeline:
@list |> map ml_temperature_decay |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-to-cups">
<h3><a class="doc-anchor" href="#doc-ml-to-cups">#</a> <code>ml_to_cups</code></h3>
<p><code>ml_to_cups</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ml_to_cups $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-to-liters">
<h3><a class="doc-anchor" href="#doc-ml-to-liters">#</a> <code>ml_to_liters</code></h3>
<p><code>ml_to_liters</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ml_to_liters $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-token-logit-top-k">
<h3><a class="doc-anchor" href="#doc-ml-token-logit-top-k">#</a> <code>ml_token_logit_top_k</code></h3>
<p><code>ml_token_logit_top_k</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_token_logit_top_k $x
# or in a pipeline:
@list |> map ml_token_logit_top_k |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-topk-argmax">
<h3><a class="doc-anchor" href="#doc-ml-topk-argmax">#</a> <code>ml_topk_argmax</code></h3>
<p><code>ml_topk_argmax</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_topk_argmax $x
# or in a pipeline:
@list |> map ml_topk_argmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-triplet-loss-step">
<h3><a class="doc-anchor" href="#doc-ml-triplet-loss-step">#</a> <code>ml_triplet_loss_step</code></h3>
<p><code>ml_triplet_loss_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_triplet_loss_step $x
# or in a pipeline:
@list |> map ml_triplet_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-truncnormal-init">
<h3><a class="doc-anchor" href="#doc-ml-truncnormal-init">#</a> <code>ml_truncnormal_init</code></h3>
<p><code>ml_truncnormal_init</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_truncnormal_init $x
# or in a pipeline:
@list |> map ml_truncnormal_init |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-uniform-init">
<h3><a class="doc-anchor" href="#doc-ml-uniform-init">#</a> <code>ml_uniform_init</code></h3>
<p><code>ml_uniform_init</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_uniform_init $x
# or in a pipeline:
@list |> map ml_uniform_init |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-warmup-lr-step">
<h3><a class="doc-anchor" href="#doc-ml-warmup-lr-step">#</a> <code>ml_warmup_lr_step</code></h3>
<p><code>ml_warmup_lr_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_warmup_lr_step $x
# or in a pipeline:
@list |> map ml_warmup_lr_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-weight-decay-step">
<h3><a class="doc-anchor" href="#doc-ml-weight-decay-step">#</a> <code>ml_weight_decay_step</code></h3>
<p><code>ml_weight_decay_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_weight_decay_step $x
# or in a pipeline:
@list |> map ml_weight_decay_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-weight-norm-step">
<h3><a class="doc-anchor" href="#doc-ml-weight-norm-step">#</a> <code>ml_weight_norm_step</code></h3>
<p><code>ml_weight_norm_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_weight_norm_step $x
# or in a pipeline:
@list |> map ml_weight_norm_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-xavier-init-value">
<h3><a class="doc-anchor" href="#doc-ml-xavier-init-value">#</a> <code>ml_xavier_init_value</code></h3>
<p><code>ml_xavier_init_value</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_xavier_init_value $x
# or in a pipeline:
@list |> map ml_xavier_init_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-yogi-step">
<h3><a class="doc-anchor" href="#doc-ml-yogi-step">#</a> <code>ml_yogi_step</code></h3>
<p><code>ml_yogi_step</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_yogi_step $x
# or in a pipeline:
@list |> map ml_yogi_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-zero-init">
<h3><a class="doc-anchor" href="#doc-ml-zero-init">#</a> <code>ml_zero_init</code></h3>
<p><code>ml_zero_init</code> — batch 45 builtin.</p>
<pre><code class="lang-perl">my $result = ml_zero_init $x
# or in a pipeline:
@list |> map ml_zero_init |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mle-exponential-log-lik">
<h3><a class="doc-anchor" href="#doc-mle-exponential-log-lik">#</a> <code>mle_exponential_log_lik</code></h3>
<p><code>mle_exponential_log_lik</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = mle_exponential_log_lik $x
# or in a pipeline:
@list |> map mle_exponential_log_lik |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mle-normal-log-lik">
<h3><a class="doc-anchor" href="#doc-mle-normal-log-lik">#</a> <code>mle_normal_log_lik</code></h3>
<p><code>mle_normal_log_lik</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = mle_normal_log_lik $x
# or in a pipeline:
@list |> map mle_normal_log_lik |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mle-poisson-log-lik">
<h3><a class="doc-anchor" href="#doc-mle-poisson-log-lik">#</a> <code>mle_poisson_log_lik</code></h3>
<p><code>mle_poisson_log_lik</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = mle_poisson_log_lik $x
# or in a pipeline:
@list |> map mle_poisson_log_lik |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mm">
<h3><a class="doc-anchor" href="#doc-mm">#</a> <code>mm</code></h3>
<p><code>mm</code> — extended stdlib builtin. Alias for <code>matrix_mul</code>.</p>
<pre><code class="lang-perl">my $result = mm $x
# or in a pipeline:
@list |> map mm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmap">
<h3><a class="doc-anchor" href="#doc-mmap">#</a> <code>mmap</code></h3>
<p><code>mmap</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_map</code>.</p>
<pre><code class="lang-perl">my $result = mmap $x
# or in a pipeline:
@list |> map mmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmax">
<h3><a class="doc-anchor" href="#doc-mmax">#</a> <code>mmax</code></h3>
<p><code>mmax</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_max</code>.</p>
<pre><code class="lang-perl">my $result = mmax $x
# or in a pipeline:
@list |> map mmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmhg-to-pa">
<h3><a class="doc-anchor" href="#doc-mmhg-to-pa">#</a> <code>mmhg_to_pa</code></h3>
<p><code>mmhg_to_pa</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = mmhg_to_pa $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mmin">
<h3><a class="doc-anchor" href="#doc-mmin">#</a> <code>mmin</code></h3>
<p><code>mmin</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_min</code>.</p>
<pre><code class="lang-perl">my $result = mmin $x
# or in a pipeline:
@list |> map mmin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmult">
<h3><a class="doc-anchor" href="#doc-mmult">#</a> <code>mmult</code></h3>
<p><code>mmult</code> — extended stdlib builtin. Alias for <code>matrix_mult</code>.</p>
<pre><code class="lang-perl">my $result = mmult $x
# or in a pipeline:
@list |> map mmult |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmx">
<h3><a class="doc-anchor" href="#doc-mmx">#</a> <code>mmx</code></h3>
<p><code>mmx</code> — python/ruby stdlib builtin. Alias for <code>minmax</code>.</p>
<pre><code class="lang-perl">my $result = mmx $x
# or in a pipeline:
@list |> map mmx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmxb">
<h3><a class="doc-anchor" href="#doc-mmxb">#</a> <code>mmxb</code></h3>
<p><code>mmxb</code> — python/ruby stdlib builtin. Alias for <code>minmax_by</code>.</p>
<pre><code class="lang-perl">my $result = mmxb $x
# or in a pipeline:
@list |> map mmxb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mob">
<h3><a class="doc-anchor" href="#doc-mob">#</a> <code>mob</code></h3>
<p><code>mob</code> — extended stdlib batch 3 builtin. Alias for <code>mobius</code>.</p>
<pre><code class="lang-perl">my $result = mob $x
# or in a pipeline:
@list |> map mob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mobius">
<h3><a class="doc-anchor" href="#doc-mobius">#</a> <code>mobius</code></h3>
<p><code>mobius</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = mobius $x
# or in a pipeline:
@list |> map mobius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mobius-function-pair">
<h3><a class="doc-anchor" href="#doc-mobius-function-pair">#</a> <code>mobius_function_pair</code></h3>
<p><code>mobius_function_pair</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = mobius_function_pair $x
# or in a pipeline:
@list |> map mobius_function_pair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mobius-inversion-step">
<h3><a class="doc-anchor" href="#doc-mobius-inversion-step">#</a> <code>mobius_inversion_step</code></h3>
<p><code>mobius_inversion_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = mobius_inversion_step $x
# or in a pipeline:
@list |> map mobius_inversion_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mobius-poset-two">
<h3><a class="doc-anchor" href="#doc-mobius-poset-two">#</a> <code>mobius_poset_two</code></h3>
<p><code>mobius_poset_two</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = mobius_poset_two $x
# or in a pipeline:
@list |> map mobius_poset_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-exp">
<h3><a class="doc-anchor" href="#doc-mod-exp">#</a> <code>mod_exp</code></h3>
<p><code>mod_exp</code> (aliases <code>modexp</code>, <code>powmod</code>) computes modular exponentiation: base^exp mod m, using fast binary exponentiation.</p>
<pre><code class="lang-perl">p powmod(2, 10, 1000) # 24 (2^10 mod 1000)
p powmod(3, 13, 50) # 7
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-inv">
<h3><a class="doc-anchor" href="#doc-mod-inv">#</a> <code>mod_inv</code></h3>
<p><code>mod_inv</code> (alias <code>modinv</code>) computes the modular multiplicative inverse via extended Euclidean algorithm. Errors if no inverse exists.</p>
<pre><code class="lang-perl">p modinv(3, 7) # 5 (3*5 ≡ 1 mod 7)
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-op">
<h3><a class="doc-anchor" href="#doc-mod-op">#</a> <code>mod_op</code></h3>
<p><code>mod_op</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = mod_op $x
# or in a pipeline:
@list |> map mod_op |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-sph-bessel-i0">
<h3><a class="doc-anchor" href="#doc-mod-sph-bessel-i0">#</a> <code>mod_sph_bessel_i0</code></h3>
<p><code>mod_sph_bessel_i0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = mod_sph_bessel_i0 $x
# or in a pipeline:
@list |> map mod_sph_bessel_i0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-sph-bessel-i1">
<h3><a class="doc-anchor" href="#doc-mod-sph-bessel-i1">#</a> <code>mod_sph_bessel_i1</code></h3>
<p><code>mod_sph_bessel_i1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = mod_sph_bessel_i1 $x
# or in a pipeline:
@list |> map mod_sph_bessel_i1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-sph-bessel-k0">
<h3><a class="doc-anchor" href="#doc-mod-sph-bessel-k0">#</a> <code>mod_sph_bessel_k0</code></h3>
<p><code>mod_sph_bessel_k0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = mod_sph_bessel_k0 $x
# or in a pipeline:
@list |> map mod_sph_bessel_k0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moddur">
<h3><a class="doc-anchor" href="#doc-moddur">#</a> <code>moddur</code></h3>
<p><code>moddur</code> — finance (extended) builtin. Alias for <code>modified_duration</code>.</p>
<pre><code class="lang-perl">my $result = moddur $x
# or in a pipeline:
@list |> map moddur |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-agg">
<h3><a class="doc-anchor" href="#doc-mode-agg">#</a> <code>mode_agg</code></h3>
<p><code>mode_agg</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = mode_agg $x
# or in a pipeline:
@list |> map mode_agg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-list">
<h3><a class="doc-anchor" href="#doc-mode-list">#</a> <code>mode_list</code></h3>
<p><code>mode_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = mode_list $x
# or in a pipeline:
@list |> map mode_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-pitches-dorian">
<h3><a class="doc-anchor" href="#doc-mode-pitches-dorian">#</a> <code>mode_pitches_dorian</code></h3>
<p><code>mode_pitches_dorian</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = mode_pitches_dorian $x
# or in a pipeline:
@list |> map mode_pitches_dorian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-pitches-lydian">
<h3><a class="doc-anchor" href="#doc-mode-pitches-lydian">#</a> <code>mode_pitches_lydian</code></h3>
<p><code>mode_pitches_lydian</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = mode_pitches_lydian $x
# or in a pipeline:
@list |> map mode_pitches_lydian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-pitches-phrygian">
<h3><a class="doc-anchor" href="#doc-mode-pitches-phrygian">#</a> <code>mode_pitches_phrygian</code></h3>
<p><code>mode_pitches_phrygian</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = mode_pitches_phrygian $x
# or in a pipeline:
@list |> map mode_pitches_phrygian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-stat">
<h3><a class="doc-anchor" href="#doc-mode-stat">#</a> <code>mode_stat</code></h3>
<p><code>mode_stat</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = mode_stat $x
# or in a pipeline:
@list |> map mode_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-val">
<h3><a class="doc-anchor" href="#doc-mode-val">#</a> <code>mode_val</code></h3>
<p><code>mode_val</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = mode_val $x
# or in a pipeline:
@list |> map mode_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-model-checking-ctl">
<h3><a class="doc-anchor" href="#doc-model-checking-ctl">#</a> <code>model_checking_ctl</code></h3>
<p><code>model_checking_ctl</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = model_checking_ctl $x
# or in a pipeline:
@list |> map model_checking_ctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-model-checking-ltl">
<h3><a class="doc-anchor" href="#doc-model-checking-ltl">#</a> <code>model_checking_ltl</code></h3>
<p><code>model_checking_ltl</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = model_checking_ltl $x
# or in a pipeline:
@list |> map model_checking_ltl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modhex-encode">
<h3><a class="doc-anchor" href="#doc-modhex-encode">#</a> <code>modhex_encode</code></h3>
<p><code>modhex_encode</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = modhex_encode $x
# or in a pipeline:
@list |> map modhex_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modified-duration">
<h3><a class="doc-anchor" href="#doc-modified-duration">#</a> <code>modified_duration</code></h3>
<p><code>modified_duration($face, $coupon_rate, $ytm, $periods)</code> (alias <code>mod_dur</code>) — computes modified duration, which directly measures price sensitivity to yield changes. Equal to Macaulay duration / (1 + ytm).</p>
<pre><code class="lang-perl">p mod_dur(1000, 0.05, 0.05, 10) # ~7.3
</code></pre>
</article>
<article class="doc-entry" id="doc-modified-irr">
<h3><a class="doc-anchor" href="#doc-modified-irr">#</a> <code>modified_irr</code></h3>
<p><code>modified_irr</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = modified_irr $x
# or in a pipeline:
@list |> map modified_irr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modified-midpoint-ode">
<h3><a class="doc-anchor" href="#doc-modified-midpoint-ode">#</a> <code>modified_midpoint_ode</code></h3>
<p><code>modified_midpoint_ode</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = modified_midpoint_ode $x
# or in a pipeline:
@list |> map modified_midpoint_ode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modified-sharpe">
<h3><a class="doc-anchor" href="#doc-modified-sharpe">#</a> <code>modified_sharpe</code></h3>
<p><code>modified_sharpe</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = modified_sharpe $x
# or in a pipeline:
@list |> map modified_sharpe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modmidpoint">
<h3><a class="doc-anchor" href="#doc-modmidpoint">#</a> <code>modmidpoint</code></h3>
<p><code>modmidpoint</code> — batch 19 builtin. Alias for <code>modified_midpoint_ode</code>.</p>
<pre><code class="lang-perl">my $result = modmidpoint $x
# or in a pipeline:
@list |> map modmidpoint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modular-data-s-value">
<h3><a class="doc-anchor" href="#doc-modular-data-s-value">#</a> <code>modular_data_s_value</code></h3>
<p><code>modular_data_s_value</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = modular_data_s_value $x
# or in a pipeline:
@list |> map modular_data_s_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modular-data-t-value">
<h3><a class="doc-anchor" href="#doc-modular-data-t-value">#</a> <code>modular_data_t_value</code></h3>
<p><code>modular_data_t_value</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = modular_data_t_value $x
# or in a pipeline:
@list |> map modular_data_t_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modularity-q">
<h3><a class="doc-anchor" href="#doc-modularity-q">#</a> <code>modularity_q</code></h3>
<p><code>modularity_q</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = modularity_q $x
# or in a pipeline:
@list |> map modularity_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modularity-score">
<h3><a class="doc-anchor" href="#doc-modularity-score">#</a> <code>modularity_score</code></h3>
<p><code>modularity_score</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = modularity_score $x
# or in a pipeline:
@list |> map modularity_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moduli-dimension-curves">
<h3><a class="doc-anchor" href="#doc-moduli-dimension-curves">#</a> <code>moduli_dimension_curves</code></h3>
<p><code>moduli_dimension_curves</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = moduli_dimension_curves $x
# or in a pipeline:
@list |> map moduli_dimension_curves |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-molality">
<h3><a class="doc-anchor" href="#doc-molality">#</a> <code>molality</code></h3>
<p><code>molality</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = molality $x
# or in a pipeline:
@list |> map molality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-molarity">
<h3><a class="doc-anchor" href="#doc-molarity">#</a> <code>molarity</code></h3>
<p><code>molarity</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = molarity $x
# or in a pipeline:
@list |> map molarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-molarity-dilution">
<h3><a class="doc-anchor" href="#doc-molarity-dilution">#</a> <code>molarity_dilution</code></h3>
<p><code>molarity_dilution</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = molarity_dilution $x
# or in a pipeline:
@list |> map molarity_dilution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mole-fraction">
<h3><a class="doc-anchor" href="#doc-mole-fraction">#</a> <code>mole_fraction</code></h3>
<p><code>mole_fraction</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = mole_fraction $x
# or in a pipeline:
@list |> map mole_fraction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-molecular-weight-compound">
<h3><a class="doc-anchor" href="#doc-molecular-weight-compound">#</a> <code>molecular_weight_compound</code></h3>
<p><code>molecular_weight_compound</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = molecular_weight_compound $x
# or in a pipeline:
@list |> map molecular_weight_compound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moles-from-mass">
<h3><a class="doc-anchor" href="#doc-moles-from-mass">#</a> <code>moles_from_mass</code></h3>
<p><code>moles_from_mass</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = moles_from_mass $x
# or in a pipeline:
@list |> map moles_from_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mollweide-project">
<h3><a class="doc-anchor" href="#doc-mollweide-project">#</a> <code>mollweide_project</code></h3>
<p><code>mollweide_project</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = mollweide_project $x
# or in a pipeline:
@list |> map mollweide_project |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moment-magnitude-mw">
<h3><a class="doc-anchor" href="#doc-moment-magnitude-mw">#</a> <code>moment_magnitude_mw</code></h3>
<p><code>moment_magnitude_mw</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = moment_magnitude_mw $x
# or in a pipeline:
@list |> map moment_magnitude_mw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-momentum">
<h3><a class="doc-anchor" href="#doc-momentum">#</a> <code>momentum</code></h3>
<p><code>momentum($mass, $velocity)</code> — compute momentum p = mv (kg⋅m/s).</p>
<pre><code class="lang-perl">p momentum(10, 5) # 50 kg⋅m/s
</code></pre>
</article>
<article class="doc-entry" id="doc-mones">
<h3><a class="doc-anchor" href="#doc-mones">#</a> <code>mones</code></h3>
<p><code>mones</code> — extended stdlib builtin. Alias for <code>matrix_ones</code>.</p>
<pre><code class="lang-perl">my $result = mones $x
# or in a pipeline:
@list |> map mones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-monin-obukhov-length">
<h3><a class="doc-anchor" href="#doc-monin-obukhov-length">#</a> <code>monin_obukhov_length</code></h3>
<p><code>monin_obukhov_length</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = monin_obukhov_length $x
# or in a pipeline:
@list |> map monin_obukhov_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-monobit-test">
<h3><a class="doc-anchor" href="#doc-monobit-test">#</a> <code>monobit_test</code></h3>
<p><code>monobit_test</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = monobit_test $x
# or in a pipeline:
@list |> map monobit_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-monopoly-lerner">
<h3><a class="doc-anchor" href="#doc-monopoly-lerner">#</a> <code>monopoly_lerner</code></h3>
<p><code>monopoly_lerner</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = monopoly_lerner $x
# or in a pipeline:
@list |> map monopoly_lerner |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-montecarlo-returns-step">
<h3><a class="doc-anchor" href="#doc-montecarlo-returns-step">#</a> <code>montecarlo_returns_step</code></h3>
<p><code>montecarlo_returns_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = montecarlo_returns_step $x
# or in a pipeline:
@list |> map montecarlo_returns_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-month-name">
<h3><a class="doc-anchor" href="#doc-month-name">#</a> <code>month_name</code></h3>
<p><code>month_name</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = month_name $x
# or in a pipeline:
@list |> map month_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-month-short">
<h3><a class="doc-anchor" href="#doc-month-short">#</a> <code>month_short</code></h3>
<p><code>month_short</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = month_short $x
# or in a pipeline:
@list |> map month_short |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-months-between">
<h3><a class="doc-anchor" href="#doc-months-between">#</a> <code>months_between</code></h3>
<p><code>months_between</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = months_between $x
# or in a pipeline:
@list |> map months_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-montreal-protocol-track">
<h3><a class="doc-anchor" href="#doc-montreal-protocol-track">#</a> <code>montreal_protocol_track</code></h3>
<p><code>montreal_protocol_track</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = montreal_protocol_track $x
# or in a pipeline:
@list |> map montreal_protocol_track |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moon-phase">
<h3><a class="doc-anchor" href="#doc-moon-phase">#</a> <code>moon_phase</code></h3>
<p><code>moon_phase</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = moon_phase $x
# or in a pipeline:
@list |> map moon_phase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moon-phase-age">
<h3><a class="doc-anchor" href="#doc-moon-phase-age">#</a> <code>moon_phase_age</code></h3>
<p><code>moon_phase_age</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = moon_phase_age $x
# or in a pipeline:
@list |> map moon_phase_age |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moon-position-low">
<h3><a class="doc-anchor" href="#doc-moon-position-low">#</a> <code>moon_position_low</code></h3>
<p><code>moon_position_low</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = moon_position_low $x
# or in a pipeline:
@list |> map moon_position_low |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-morse">
<h3><a class="doc-anchor" href="#doc-morse">#</a> <code>morse</code></h3>
<p><code>morse</code> — encoding / phonetics builtin. Alias for <code>morse_encode</code>.</p>
<pre><code class="lang-perl">my $result = morse $x
# or in a pipeline:
@list |> map morse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-morse-decode">
<h3><a class="doc-anchor" href="#doc-morse-decode">#</a> <code>morse_decode</code></h3>
<p><code>morse_decode</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = morse_decode $x
# or in a pipeline:
@list |> map morse_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-morse-encode">
<h3><a class="doc-anchor" href="#doc-morse-encode">#</a> <code>morse_encode</code></h3>
<p><code>morse_encode</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = morse_encode $x
# or in a pipeline:
@list |> map morse_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mortality-table-q">
<h3><a class="doc-anchor" href="#doc-mortality-table-q">#</a> <code>mortality_table_q</code></h3>
<p><code>mortality_table_q</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = mortality_table_q $x
# or in a pipeline:
@list |> map mortality_table_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mortgage-payment">
<h3><a class="doc-anchor" href="#doc-mortgage-payment">#</a> <code>mortgage_payment</code></h3>
<p><code>mortgage_payment</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = mortgage_payment $x
# or in a pipeline:
@list |> map mortgage_payment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-most-common">
<h3><a class="doc-anchor" href="#doc-most-common">#</a> <code>most_common</code></h3>
<p><code>most_common</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = most_common $x
# or in a pipeline:
@list |> map most_common |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-motion-blur-kernel">
<h3><a class="doc-anchor" href="#doc-motion-blur-kernel">#</a> <code>motion_blur_kernel</code></h3>
<p><code>motion_blur_kernel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = motion_blur_kernel $x
# or in a pipeline:
@list |> map motion_blur_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-motor-torque">
<h3><a class="doc-anchor" href="#doc-motor-torque">#</a> <code>motor_torque</code></h3>
<p><code>motor_torque</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = motor_torque $x
# or in a pipeline:
@list |> map motor_torque |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mott-schottky-capacitance">
<h3><a class="doc-anchor" href="#doc-mott-schottky-capacitance">#</a> <code>mott_schottky_capacitance</code></h3>
<p><code>mott_schottky_capacitance</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = mott_schottky_capacitance $x
# or in a pipeline:
@list |> map mott_schottky_capacitance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-movavg">
<h3><a class="doc-anchor" href="#doc-movavg">#</a> <code>movavg</code></h3>
<p><code>movavg</code> — math / numeric (uncategorized batch) builtin. Alias for <code>moving_average</code>.</p>
<pre><code class="lang-perl">my $result = movavg $x
# or in a pipeline:
@list |> map movavg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moving-average">
<h3><a class="doc-anchor" href="#doc-moving-average">#</a> <code>moving_average</code></h3>
<p><code>moving_average</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = moving_average $x
# or in a pipeline:
@list |> map moving_average |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moving-average-filter">
<h3><a class="doc-anchor" href="#doc-moving-average-filter">#</a> <code>moving_average_filter</code></h3>
<p><code>moving_average_filter</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = moving_average_filter $x
# or in a pipeline:
@list |> map moving_average_filter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mpeg-quant-value">
<h3><a class="doc-anchor" href="#doc-mpeg-quant-value">#</a> <code>mpeg_quant_value</code></h3>
<p><code>mpeg_quant_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = mpeg_quant_value $x
# or in a pipeline:
@list |> map mpeg_quant_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mph-to-kmh">
<h3><a class="doc-anchor" href="#doc-mph-to-kmh">#</a> <code>mph_to_kmh</code></h3>
<p><code>mph_to_kmh</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = mph_to_kmh $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mplanck">
<h3><a class="doc-anchor" href="#doc-mplanck">#</a> <code>mplanck</code></h3>
<p><code>mplanck</code> — physics constants builtin. Alias for <code>planck_mass</code>.</p>
<pre><code class="lang-perl">my $result = mplanck $x
# or in a pipeline:
@list |> map mplanck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mpow">
<h3><a class="doc-anchor" href="#doc-mpow">#</a> <code>mpow</code></h3>
<p><code>mpow</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_power</code>.</p>
<pre><code class="lang-perl">my $result = mpow $x
# or in a pipeline:
@list |> map mpow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mps-to-kmh">
<h3><a class="doc-anchor" href="#doc-mps-to-kmh">#</a> <code>mps_to_kmh</code></h3>
<p><code>mps_to_kmh</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = mps_to_kmh $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mrow">
<h3><a class="doc-anchor" href="#doc-mrow">#</a> <code>mrow</code></h3>
<p><code>mrow</code> — extended stdlib builtin. Alias for <code>matrix_row</code>.</p>
<pre><code class="lang-perl">my $result = mrow $x
# or in a pipeline:
@list |> map mrow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ms-to-ns">
<h3><a class="doc-anchor" href="#doc-ms-to-ns">#</a> <code>ms_to_ns</code></h3>
<p><code>ms_to_ns</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ms_to_ns $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ms-to-s">
<h3><a class="doc-anchor" href="#doc-ms-to-s">#</a> <code>ms_to_s</code></h3>
<p><code>ms_to_s</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ms_to_s $input
</code></pre>
</article>
<article class="doc-entry" id="doc-msa-column-entropy">
<h3><a class="doc-anchor" href="#doc-msa-column-entropy">#</a> <code>msa_column_entropy</code></h3>
<p><code>msa_column_entropy</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = msa_column_entropy $x
# or in a pipeline:
@list |> map msa_column_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mscal">
<h3><a class="doc-anchor" href="#doc-mscal">#</a> <code>mscal</code></h3>
<p><code>mscal</code> — extended stdlib builtin. Alias for <code>matrix_scalar</code>.</p>
<pre><code class="lang-perl">my $result = mscal $x
# or in a pipeline:
@list |> map mscal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mse">
<h3><a class="doc-anchor" href="#doc-mse">#</a> <code>mse</code></h3>
<p><code>mse</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = mse $x
# or in a pipeline:
@list |> map mse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mset">
<h3><a class="doc-anchor" href="#doc-mset">#</a> <code>mset</code></h3>
<p><code>mset</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = mset $x
# or in a pipeline:
@list |> map mset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgctl">
<h3><a class="doc-anchor" href="#doc-msgctl">#</a> <code>msgctl</code></h3>
<p><code>msgctl</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = msgctl $x
# or in a pipeline:
@list |> map msgctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgget">
<h3><a class="doc-anchor" href="#doc-msgget">#</a> <code>msgget</code></h3>
<p><code>msgget</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = msgget $x
# or in a pipeline:
@list |> map msgget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgpack-pack-int">
<h3><a class="doc-anchor" href="#doc-msgpack-pack-int">#</a> <code>msgpack_pack_int</code></h3>
<p><code>msgpack_pack_int</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = msgpack_pack_int $x
# or in a pipeline:
@list |> map msgpack_pack_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgpack-pack-str">
<h3><a class="doc-anchor" href="#doc-msgpack-pack-str">#</a> <code>msgpack_pack_str</code></h3>
<p><code>msgpack_pack_str</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = msgpack_pack_str $x
# or in a pipeline:
@list |> map msgpack_pack_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgrcv">
<h3><a class="doc-anchor" href="#doc-msgrcv">#</a> <code>msgrcv</code></h3>
<p><code>msgrcv</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = msgrcv $x
# or in a pipeline:
@list |> map msgrcv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgsnd">
<h3><a class="doc-anchor" href="#doc-msgsnd">#</a> <code>msgsnd</code></h3>
<p><code>msgsnd</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = msgsnd $x
# or in a pipeline:
@list |> map msgsnd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mshape">
<h3><a class="doc-anchor" href="#doc-mshape">#</a> <code>mshape</code></h3>
<p><code>mshape</code> — extended stdlib builtin. Alias for <code>matrix_shape</code>.</p>
<pre><code class="lang-perl">my $result = mshape $x
# or in a pipeline:
@list |> map mshape |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msorted">
<h3><a class="doc-anchor" href="#doc-msorted">#</a> <code>msorted</code></h3>
<p><code>msorted</code> — matrix operations (uncategorized batch) builtin. Alias for <code>merge_sorted</code>.</p>
<pre><code class="lang-perl">my $result = msorted $x
# or in a pipeline:
@list |> map msorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mst">
<h3><a class="doc-anchor" href="#doc-mst">#</a> <code>mst</code></h3>
<p><code>prim_mst</code> (aliases <code>mst</code>, <code>prim</code>) computes the minimum spanning tree weight via Prim's algorithm. Takes an adjacency matrix.</p>
<pre><code class="lang-perl">p mst([[0,2,0],[2,0,3],[0,3,0]]) # 5
</code></pre>
</article>
<article class="doc-entry" id="doc-mstat">
<h3><a class="doc-anchor" href="#doc-mstat">#</a> <code>mstat</code></h3>
<p><code>mstat</code> — extended stdlib builtin. Alias for <code>mode_stat</code>.</p>
<pre><code class="lang-perl">my $result = mstat $x
# or in a pipeline:
@list |> map mstat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msub">
<h3><a class="doc-anchor" href="#doc-msub">#</a> <code>msub</code></h3>
<p><code>msub</code> — extended stdlib builtin. Alias for <code>matrix_sub</code>.</p>
<pre><code class="lang-perl">my $result = msub $x
# or in a pipeline:
@list |> map msub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msum">
<h3><a class="doc-anchor" href="#doc-msum">#</a> <code>msum</code></h3>
<p><code>msum</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_sum</code>.</p>
<pre><code class="lang-perl">my $result = msum $x
# or in a pipeline:
@list |> map msum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msun">
<h3><a class="doc-anchor" href="#doc-msun">#</a> <code>msun</code></h3>
<p><code>sun_mass</code> (alias <code>msun</code>) — M☉ ≈ 1.989×10³⁰ kg. Mass of Sun (solar mass).</p>
<pre><code class="lang-perl">p msun # 1.98892e30 kg
</code></pre>
</article>
<article class="doc-entry" id="doc-mt19937-temper">
<h3><a class="doc-anchor" href="#doc-mt19937-temper">#</a> <code>mt19937_temper</code></h3>
<p><code>mt19937_temper</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = mt19937_temper $x
# or in a pipeline:
@list |> map mt19937_temper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mtf-decode">
<h3><a class="doc-anchor" href="#doc-mtf-decode">#</a> <code>mtf_decode</code></h3>
<p><code>mtf_decode</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = mtf_decode $x
# or in a pipeline:
@list |> map mtf_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mtf-encode">
<h3><a class="doc-anchor" href="#doc-mtf-encode">#</a> <code>mtf_encode</code></h3>
<p><code>mtf_encode</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = mtf_encode $x
# or in a pipeline:
@list |> map mtf_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mtime">
<h3><a class="doc-anchor" href="#doc-mtime">#</a> <code>mtime</code></h3>
<p><code>mtime</code> — file stat / path builtin. Alias for <code>file_mtime</code>.</p>
<pre><code class="lang-perl">my $result = mtime $x
# or in a pipeline:
@list |> map mtime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mtrace">
<h3><a class="doc-anchor" href="#doc-mtrace">#</a> <code>mtrace</code></h3>
<p><code>mtrace</code> — extended stdlib builtin. Alias for <code>matrix_trace</code>.</p>
<pre><code class="lang-perl">my $result = mtrace $x
# or in a pipeline:
@list |> map mtrace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mtrans">
<h3><a class="doc-anchor" href="#doc-mtrans">#</a> <code>mtrans</code></h3>
<p><code>mtrans</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_transpose</code>.</p>
<pre><code class="lang-perl">my $result = mtrans $x
# or in a pipeline:
@list |> map mtrans |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mu0">
<h3><a class="doc-anchor" href="#doc-mu0">#</a> <code>mu0</code></h3>
<p><code>mu0</code> — physics constants builtin. Alias for <code>vacuum_permeability</code>.</p>
<pre><code class="lang-perl">my $result = mu0 $x
# or in a pipeline:
@list |> map mu0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mu-law-decode">
<h3><a class="doc-anchor" href="#doc-mu-law-decode">#</a> <code>mu_law_decode</code></h3>
<p><code>mu_law_decode</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = mu_law_decode $x
# or in a pipeline:
@list |> map mu_law_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mu-law-encode">
<h3><a class="doc-anchor" href="#doc-mu-law-encode">#</a> <code>mu_law_encode</code></h3>
<p><code>mu_law_encode</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = mu_law_encode $x
# or in a pipeline:
@list |> map mu_law_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mub">
<h3><a class="doc-anchor" href="#doc-mub">#</a> <code>mub</code></h3>
<p><code>mub</code> — physics constants builtin. Alias for <code>bohr_magneton</code>.</p>
<pre><code class="lang-perl">my $result = mub $x
# or in a pipeline:
@list |> map mub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-muller">
<h3><a class="doc-anchor" href="#doc-muller">#</a> <code>muller</code></h3>
<p><code>muller</code> — batch 19 builtin. Alias for <code>muller_root</code>.</p>
<pre><code class="lang-perl">my $result = muller $x
# or in a pipeline:
@list |> map muller |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-muller-root">
<h3><a class="doc-anchor" href="#doc-muller-root">#</a> <code>muller_root</code></h3>
<p><code>muller_root</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = muller_root $x
# or in a pipeline:
@list |> map muller_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multi-decrement-q">
<h3><a class="doc-anchor" href="#doc-multi-decrement-q">#</a> <code>multi_decrement_q</code></h3>
<p><code>multi_decrement_q</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = multi_decrement_q $x
# or in a pipeline:
@list |> map multi_decrement_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multi-knapsack-step">
<h3><a class="doc-anchor" href="#doc-multi-knapsack-step">#</a> <code>multi_knapsack_step</code></h3>
<p><code>multi_knapsack_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = multi_knapsack_step $x
# or in a pipeline:
@list |> map multi_knapsack_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multi-state-pij">
<h3><a class="doc-anchor" href="#doc-multi-state-pij">#</a> <code>multi_state_pij</code></h3>
<p><code>multi_state_pij</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = multi_state_pij $x
# or in a pipeline:
@list |> map multi_state_pij |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multidim-packing-step">
<h3><a class="doc-anchor" href="#doc-multidim-packing-step">#</a> <code>multidim_packing_step</code></h3>
<p><code>multidim_packing_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = multidim_packing_step $x
# or in a pipeline:
@list |> map multidim_packing_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multinom">
<h3><a class="doc-anchor" href="#doc-multinom">#</a> <code>multinom</code></h3>
<p><code>multinom</code> — math / numeric (uncategorized batch) builtin. Alias for <code>multinomial</code>.</p>
<pre><code class="lang-perl">my $result = multinom $x
# or in a pipeline:
@list |> map multinom |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multinomial">
<h3><a class="doc-anchor" href="#doc-multinomial">#</a> <code>multinomial</code></h3>
<p><code>multinomial</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = multinomial $x
# or in a pipeline:
@list |> map multinomial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multinomial-count">
<h3><a class="doc-anchor" href="#doc-multinomial-count">#</a> <code>multinomial_count</code></h3>
<p><code>multinomial_count</code> — batch 9 builtin. Alias for <code>multiset_permutations_count</code>.</p>
<pre><code class="lang-perl">my $result = multinomial_count $x
# or in a pipeline:
@list |> map multinomial_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multinomial-logit-prob">
<h3><a class="doc-anchor" href="#doc-multinomial-logit-prob">#</a> <code>multinomial_logit_prob</code></h3>
<p><code>multinomial_logit_prob</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = multinomial_logit_prob $x
# or in a pipeline:
@list |> map multinomial_logit_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multiset-difference">
<h3><a class="doc-anchor" href="#doc-multiset-difference">#</a> <code>multiset_difference</code></h3>
<p><code>multiset_difference</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = multiset_difference $x
# or in a pipeline:
@list |> map multiset_difference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multiset-intersection">
<h3><a class="doc-anchor" href="#doc-multiset-intersection">#</a> <code>multiset_intersection</code></h3>
<p><code>multiset_intersection</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = multiset_intersection $x
# or in a pipeline:
@list |> map multiset_intersection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multiset-permutations-count">
<h3><a class="doc-anchor" href="#doc-multiset-permutations-count">#</a> <code>multiset_permutations_count</code></h3>
<p><code>multiset_permutations_count</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = multiset_permutations_count $x
# or in a pipeline:
@list |> map multiset_permutations_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multiset-union">
<h3><a class="doc-anchor" href="#doc-multiset-union">#</a> <code>multiset_union</code></h3>
<p><code>multiset_union</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = multiset_union $x
# or in a pipeline:
@list |> map multiset_union |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mun">
<h3><a class="doc-anchor" href="#doc-mun">#</a> <code>mun</code></h3>
<p><code>mun</code> — physics constants builtin. Alias for <code>nuclear_magneton</code>.</p>
<pre><code class="lang-perl">my $result = mun $x
# or in a pipeline:
@list |> map mun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-murmurhash3-x32">
<h3><a class="doc-anchor" href="#doc-murmurhash3-x32">#</a> <code>murmurhash3_x32</code></h3>
<p><code>murmurhash3_x32</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = murmurhash3_x32 $x
# or in a pipeline:
@list |> map murmurhash3_x32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mutation-bit-flip-prob">
<h3><a class="doc-anchor" href="#doc-mutation-bit-flip-prob">#</a> <code>mutation_bit_flip_prob</code></h3>
<p><code>mutation_bit_flip_prob</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = mutation_bit_flip_prob $x
# or in a pipeline:
@list |> map mutation_bit_flip_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mutation-rate">
<h3><a class="doc-anchor" href="#doc-mutation-rate">#</a> <code>mutation_rate</code></h3>
<p><code>mutation_rate</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = mutation_rate $x
# or in a pipeline:
@list |> map mutation_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mutual-information-step">
<h3><a class="doc-anchor" href="#doc-mutual-information-step">#</a> <code>mutual_information_step</code></h3>
<p><code>mutual_information_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = mutual_information_step $x
# or in a pipeline:
@list |> map mutual_information_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-myerson-optimal">
<h3><a class="doc-anchor" href="#doc-myerson-optimal">#</a> <code>myerson_optimal</code></h3>
<p><code>myerson_optimal</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = myerson_optimal $x
# or in a pipeline:
@list |> map myerson_optimal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mzeros">
<h3><a class="doc-anchor" href="#doc-mzeros">#</a> <code>mzeros</code></h3>
<p><code>mzeros</code> — extended stdlib builtin. Alias for <code>matrix_zeros</code>.</p>
<pre><code class="lang-perl">my $result = mzeros $x
# or in a pipeline:
@list |> map mzeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-n-ball-volume">
<h3><a class="doc-anchor" href="#doc-n-ball-volume">#</a> <code>n_ball_volume</code></h3>
<p><code>n_ball_volume</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = n_ball_volume $x
# or in a pipeline:
@list |> map n_ball_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nanoid">
<h3><a class="doc-anchor" href="#doc-nanoid">#</a> <code>nanoid</code></h3>
<p><code>nanoid</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = nanoid $x
# or in a pipeline:
@list |> map nanoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nao-index-step">
<h3><a class="doc-anchor" href="#doc-nao-index-step">#</a> <code>nao_index_step</code></h3>
<p><code>nao_index_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = nao_index_step $x
# or in a pipeline:
@list |> map nao_index_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nash-bargaining-solution">
<h3><a class="doc-anchor" href="#doc-nash-bargaining-solution">#</a> <code>nash_bargaining_solution</code></h3>
<p><code>nash_bargaining_solution</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = nash_bargaining_solution $x
# or in a pipeline:
@list |> map nash_bargaining_solution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nash-equilibrium-pair">
<h3><a class="doc-anchor" href="#doc-nash-equilibrium-pair">#</a> <code>nash_equilibrium_pair</code></h3>
<p><code>nash_equilibrium_pair</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = nash_equilibrium_pair $x
# or in a pipeline:
@list |> map nash_equilibrium_pair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nash-social-welfare">
<h3><a class="doc-anchor" href="#doc-nash-social-welfare">#</a> <code>nash_social_welfare</code></h3>
<p><code>nash_social_welfare</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = nash_social_welfare $x
# or in a pipeline:
@list |> map nash_social_welfare |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nato">
<h3><a class="doc-anchor" href="#doc-nato">#</a> <code>nato</code></h3>
<p><code>nato</code> — encoding / phonetics builtin. Alias for <code>nato_phonetic</code>.</p>
<pre><code class="lang-perl">my $result = nato $x
# or in a pipeline:
@list |> map nato |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nato-phonetic">
<h3><a class="doc-anchor" href="#doc-nato-phonetic">#</a> <code>nato_phonetic</code></h3>
<p><code>nato_phonetic</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = nato_phonetic $input
</code></pre>
</article>
<article class="doc-entry" id="doc-nb-bernoulli-likelihood">
<h3><a class="doc-anchor" href="#doc-nb-bernoulli-likelihood">#</a> <code>nb_bernoulli_likelihood</code></h3>
<p><code>nb_bernoulli_likelihood</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = nb_bernoulli_likelihood $x
# or in a pipeline:
@list |> map nb_bernoulli_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nb-gaussian-likelihood">
<h3><a class="doc-anchor" href="#doc-nb-gaussian-likelihood">#</a> <code>nb_gaussian_likelihood</code></h3>
<p><code>nb_gaussian_likelihood</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = nb_gaussian_likelihood $x
# or in a pipeline:
@list |> map nb_gaussian_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nb-multinomial-log-likelihood">
<h3><a class="doc-anchor" href="#doc-nb-multinomial-log-likelihood">#</a> <code>nb_multinomial_log_likelihood</code></h3>
<p><code>nb_multinomial_log_likelihood</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = nb_multinomial_log_likelihood $x
# or in a pipeline:
@list |> map nb_multinomial_log_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nbe-normalize">
<h3><a class="doc-anchor" href="#doc-nbe-normalize">#</a> <code>nbe_normalize</code></h3>
<p><code>nbe_normalize</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = nbe_normalize $x
# or in a pipeline:
@list |> map nbe_normalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ncol">
<h3><a class="doc-anchor" href="#doc-ncol">#</a> <code>ncol</code></h3>
<p><code>ncol</code> — number of columns in a matrix.</p>
<pre><code class="lang-perl">p ncol([[1,2,3],[4,5,6]]) # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-ndivs">
<h3><a class="doc-anchor" href="#doc-ndivs">#</a> <code>ndivs</code></h3>
<p><code>ndivs</code> — math / numeric (uncategorized batch) builtin. Alias for <code>num_divisors</code>.</p>
<pre><code class="lang-perl">my $result = ndivs $x
# or in a pipeline:
@list |> map ndivs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ne-from-variance">
<h3><a class="doc-anchor" href="#doc-ne-from-variance">#</a> <code>ne_from_variance</code></h3>
<p><code>ne_from_variance</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = ne_from_variance $x
# or in a pipeline:
@list |> map ne_from_variance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nearest-insertion-step">
<h3><a class="doc-anchor" href="#doc-nearest-insertion-step">#</a> <code>nearest_insertion_step</code></h3>
<p><code>nearest_insertion_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = nearest_insertion_step $x
# or in a pipeline:
@list |> map nearest_insertion_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nearest-neighbor-tour-step">
<h3><a class="doc-anchor" href="#doc-nearest-neighbor-tour-step">#</a> <code>nearest_neighbor_tour_step</code></h3>
<p><code>nearest_neighbor_tour_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = nearest_neighbor_tour_step $x
# or in a pipeline:
@list |> map nearest_neighbor_tour_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-necklace-count">
<h3><a class="doc-anchor" href="#doc-necklace-count">#</a> <code>necklace_count</code></h3>
<p><code>necklace_count</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = necklace_count $x
# or in a pipeline:
@list |> map necklace_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-needleman-wunsch-score">
<h3><a class="doc-anchor" href="#doc-needleman-wunsch-score">#</a> <code>needleman_wunsch_score</code></h3>
<p><code>needleman_wunsch_score</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = needleman_wunsch_score $x
# or in a pipeline:
@list |> map needleman_wunsch_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-neg-inf">
<h3><a class="doc-anchor" href="#doc-neg-inf">#</a> <code>neg_inf</code></h3>
<p><code>neg_inf</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = neg_inf $x
# or in a pipeline:
@list |> map neg_inf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-neg-n">
<h3><a class="doc-anchor" href="#doc-neg-n">#</a> <code>neg_n</code></h3>
<p><code>neg_n</code> — trivial numeric / predicate builtins builtin. Alias for <code>negative</code>.</p>
<pre><code class="lang-perl">my $result = neg_n $x
# or in a pipeline:
@list |> map neg_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-negate">
<h3><a class="doc-anchor" href="#doc-negate">#</a> <code>negate</code></h3>
<p><code>negate</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = negate $x
# or in a pipeline:
@list |> map negate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-negate-each">
<h3><a class="doc-anchor" href="#doc-negate-each">#</a> <code>negate_each</code></h3>
<p><code>negate_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = negate_each $x
# or in a pipeline:
@list |> map negate_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-negative">
<h3><a class="doc-anchor" href="#doc-negative">#</a> <code>negative</code></h3>
<p><code>negative</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = negative $x
# or in a pipeline:
@list |> map negative |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nei-genetic-distance">
<h3><a class="doc-anchor" href="#doc-nei-genetic-distance">#</a> <code>nei_genetic_distance</code></h3>
<p><code>nei_genetic_distance</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = nei_genetic_distance $x
# or in a pipeline:
@list |> map nei_genetic_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-neither">
<h3><a class="doc-anchor" href="#doc-neither">#</a> <code>neither</code></h3>
<p><code>neither</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = neither $x
# or in a pipeline:
@list |> map neither |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nelder-mead-contract">
<h3><a class="doc-anchor" href="#doc-nelder-mead-contract">#</a> <code>nelder_mead_contract</code></h3>
<p><code>nelder_mead_contract</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = nelder_mead_contract $x
# or in a pipeline:
@list |> map nelder_mead_contract |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nelder-mead-expand">
<h3><a class="doc-anchor" href="#doc-nelder-mead-expand">#</a> <code>nelder_mead_expand</code></h3>
<p><code>nelder_mead_expand</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = nelder_mead_expand $x
# or in a pipeline:
@list |> map nelder_mead_expand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nelder-mead-reflect">
<h3><a class="doc-anchor" href="#doc-nelder-mead-reflect">#</a> <code>nelder_mead_reflect</code></h3>
<p><code>nelder_mead_reflect</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = nelder_mead_reflect $x
# or in a pipeline:
@list |> map nelder_mead_reflect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nemhauser-wolsey-bound">
<h3><a class="doc-anchor" href="#doc-nemhauser-wolsey-bound">#</a> <code>nemhauser_wolsey_bound</code></h3>
<p><code>nemhauser_wolsey_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = nemhauser_wolsey_bound $x
# or in a pipeline:
@list |> map nemhauser_wolsey_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ner-bilou-decode">
<h3><a class="doc-anchor" href="#doc-ner-bilou-decode">#</a> <code>ner_bilou_decode</code></h3>
<p><code>ner_bilou_decode</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = ner_bilou_decode $x
# or in a pipeline:
@list |> map ner_bilou_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nernst-diffusion-layer">
<h3><a class="doc-anchor" href="#doc-nernst-diffusion-layer">#</a> <code>nernst_diffusion_layer</code></h3>
<p><code>nernst_diffusion_layer</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = nernst_diffusion_layer $x
# or in a pipeline:
@list |> map nernst_diffusion_layer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nernst-einstein-diffusivity">
<h3><a class="doc-anchor" href="#doc-nernst-einstein-diffusivity">#</a> <code>nernst_einstein_diffusivity</code></h3>
<p><code>nernst_einstein_diffusivity</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = nernst_einstein_diffusivity $x
# or in a pipeline:
@list |> map nernst_einstein_diffusivity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nernst-planck-flux">
<h3><a class="doc-anchor" href="#doc-nernst-planck-flux">#</a> <code>nernst_planck_flux</code></h3>
<p><code>nernst_planck_flux</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = nernst_planck_flux $x
# or in a pipeline:
@list |> map nernst_planck_flux |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nernst-potential-full">
<h3><a class="doc-anchor" href="#doc-nernst-potential-full">#</a> <code>nernst_potential_full</code></h3>
<p><code>nernst_potential_full</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = nernst_potential_full $x
# or in a pipeline:
@list |> map nernst_potential_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nerve-complex-count">
<h3><a class="doc-anchor" href="#doc-nerve-complex-count">#</a> <code>nerve_complex_count</code></h3>
<p><code>nerve_complex_count</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = nerve_complex_count $x
# or in a pipeline:
@list |> map nerve_complex_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nesterov-accelerate-step">
<h3><a class="doc-anchor" href="#doc-nesterov-accelerate-step">#</a> <code>nesterov_accelerate_step</code></h3>
<p><code>nesterov_accelerate_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = nesterov_accelerate_step $x
# or in a pipeline:
@list |> map nesterov_accelerate_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nesterov-step">
<h3><a class="doc-anchor" href="#doc-nesterov-step">#</a> <code>nesterov_step</code></h3>
<p><code>nesterov_step</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = nesterov_step $x
# or in a pipeline:
@list |> map nesterov_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aiad-step">
<h3><a class="doc-anchor" href="#doc-net-aiad-step">#</a> <code>net_aiad_step</code></h3>
<p><code>net_aiad_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aiad_step $x
# or in a pipeline:
@list |> map net_aiad_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aimd-step">
<h3><a class="doc-anchor" href="#doc-net-aimd-step">#</a> <code>net_aimd_step</code></h3>
<p><code>net_aimd_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aimd_step $x
# or in a pipeline:
@list |> map net_aimd_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-alohanet-throughput">
<h3><a class="doc-anchor" href="#doc-net-alohanet-throughput">#</a> <code>net_alohanet_throughput</code></h3>
<p><code>net_alohanet_throughput</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_alohanet_throughput $x
# or in a pipeline:
@list |> map net_alohanet_throughput |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-alpha-fair-step">
<h3><a class="doc-anchor" href="#doc-net-alpha-fair-step">#</a> <code>net_alpha_fair_step</code></h3>
<p><code>net_alpha_fair_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_alpha_fair_step $x
# or in a pipeline:
@list |> map net_alpha_fair_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-amc-threshold-index">
<h3><a class="doc-anchor" href="#doc-net-amc-threshold-index">#</a> <code>net_amc_threshold_index</code></h3>
<p><code>net_amc_threshold_index</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_amc_threshold_index $x
# or in a pipeline:
@list |> map net_amc_threshold_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-blue-step">
<h3><a class="doc-anchor" href="#doc-net-aqm-blue-step">#</a> <code>net_aqm_blue_step</code></h3>
<p><code>net_aqm_blue_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_blue_step $x
# or in a pipeline:
@list |> map net_aqm_blue_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-choke-step">
<h3><a class="doc-anchor" href="#doc-net-aqm-choke-step">#</a> <code>net_aqm_choke_step</code></h3>
<p><code>net_aqm_choke_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_choke_step $x
# or in a pipeline:
@list |> map net_aqm_choke_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-codel-target">
<h3><a class="doc-anchor" href="#doc-net-aqm-codel-target">#</a> <code>net_aqm_codel_target</code></h3>
<p><code>net_aqm_codel_target</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_codel_target $x
# or in a pipeline:
@list |> map net_aqm_codel_target |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-drr-step">
<h3><a class="doc-anchor" href="#doc-net-aqm-drr-step">#</a> <code>net_aqm_drr_step</code></h3>
<p><code>net_aqm_drr_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_drr_step $x
# or in a pipeline:
@list |> map net_aqm_drr_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-fq-codel-step">
<h3><a class="doc-anchor" href="#doc-net-aqm-fq-codel-step">#</a> <code>net_aqm_fq_codel_step</code></h3>
<p><code>net_aqm_fq_codel_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_fq_codel_step $x
# or in a pipeline:
@list |> map net_aqm_fq_codel_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-pie-drop-rate">
<h3><a class="doc-anchor" href="#doc-net-aqm-pie-drop-rate">#</a> <code>net_aqm_pie_drop_rate</code></h3>
<p><code>net_aqm_pie_drop_rate</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_pie_drop_rate $x
# or in a pipeline:
@list |> map net_aqm_pie_drop_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-red-drop-prob">
<h3><a class="doc-anchor" href="#doc-net-aqm-red-drop-prob">#</a> <code>net_aqm_red_drop_prob</code></h3>
<p><code>net_aqm_red_drop_prob</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_red_drop_prob $x
# or in a pipeline:
@list |> map net_aqm_red_drop_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-sfq-step">
<h3><a class="doc-anchor" href="#doc-net-aqm-sfq-step">#</a> <code>net_aqm_sfq_step</code></h3>
<p><code>net_aqm_sfq_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_sfq_step $x
# or in a pipeline:
@list |> map net_aqm_sfq_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-aqm-wrr-step">
<h3><a class="doc-anchor" href="#doc-net-aqm-wrr-step">#</a> <code>net_aqm_wrr_step</code></h3>
<p><code>net_aqm_wrr_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_aqm_wrr_step $x
# or in a pipeline:
@list |> map net_aqm_wrr_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-array-gain">
<h3><a class="doc-anchor" href="#doc-net-array-gain">#</a> <code>net_array_gain</code></h3>
<p><code>net_array_gain</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_array_gain $x
# or in a pipeline:
@list |> map net_array_gain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-backpressure-step">
<h3><a class="doc-anchor" href="#doc-net-backpressure-step">#</a> <code>net_backpressure_step</code></h3>
<p><code>net_backpressure_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_backpressure_step $x
# or in a pipeline:
@list |> map net_backpressure_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-bandwidth-delay-product">
<h3><a class="doc-anchor" href="#doc-net-bandwidth-delay-product">#</a> <code>net_bandwidth_delay_product</code></h3>
<p><code>net_bandwidth_delay_product</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_bandwidth_delay_product $x
# or in a pipeline:
@list |> map net_bandwidth_delay_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-bcjr-step">
<h3><a class="doc-anchor" href="#doc-net-bcjr-step">#</a> <code>net_bcjr_step</code></h3>
<p><code>net_bcjr_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_bcjr_step $x
# or in a pipeline:
@list |> map net_bcjr_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-blocking-probability">
<h3><a class="doc-anchor" href="#doc-net-blocking-probability">#</a> <code>net_blocking_probability</code></h3>
<p><code>net_blocking_probability</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_blocking_probability $x
# or in a pipeline:
@list |> map net_blocking_probability |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-burst-size-compute">
<h3><a class="doc-anchor" href="#doc-net-burst-size-compute">#</a> <code>net_burst_size_compute</code></h3>
<p><code>net_burst_size_compute</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_burst_size_compute $x
# or in a pipeline:
@list |> map net_burst_size_compute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-call-admission-check">
<h3><a class="doc-anchor" href="#doc-net-call-admission-check">#</a> <code>net_call_admission_check</code></h3>
<p><code>net_call_admission_check</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_call_admission_check $x
# or in a pipeline:
@list |> map net_call_admission_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-capacity-shannon">
<h3><a class="doc-anchor" href="#doc-net-capacity-shannon">#</a> <code>net_capacity_shannon</code></h3>
<p><code>net_capacity_shannon</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_capacity_shannon $x
# or in a pipeline:
@list |> map net_capacity_shannon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-coding-gain">
<h3><a class="doc-anchor" href="#doc-net-coding-gain">#</a> <code>net_coding_gain</code></h3>
<p><code>net_coding_gain</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_coding_gain $x
# or in a pipeline:
@list |> map net_coding_gain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-csma-back-off">
<h3><a class="doc-anchor" href="#doc-net-csma-back-off">#</a> <code>net_csma_back_off</code></h3>
<p><code>net_csma_back_off</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_csma_back_off $x
# or in a pipeline:
@list |> map net_csma_back_off |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-csma-efficiency">
<h3><a class="doc-anchor" href="#doc-net-csma-efficiency">#</a> <code>net_csma_efficiency</code></h3>
<p><code>net_csma_efficiency</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_csma_efficiency $x
# or in a pipeline:
@list |> map net_csma_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-diversity-gain">
<h3><a class="doc-anchor" href="#doc-net-diversity-gain">#</a> <code>net_diversity_gain</code></h3>
<p><code>net_diversity_gain</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_diversity_gain $x
# or in a pipeline:
@list |> map net_diversity_gain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-doppler-shift">
<h3><a class="doc-anchor" href="#doc-net-doppler-shift">#</a> <code>net_doppler_shift</code></h3>
<p><code>net_doppler_shift</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_doppler_shift $x
# or in a pipeline:
@list |> map net_doppler_shift |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-drop-tail-check">
<h3><a class="doc-anchor" href="#doc-net-drop-tail-check">#</a> <code>net_drop_tail_check</code></h3>
<p><code>net_drop_tail_check</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_drop_tail_check $x
# or in a pipeline:
@list |> map net_drop_tail_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-engset-formula">
<h3><a class="doc-anchor" href="#doc-net-engset-formula">#</a> <code>net_engset_formula</code></h3>
<p><code>net_engset_formula</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_engset_formula $x
# or in a pipeline:
@list |> map net_engset_formula |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-erlang-b-formula">
<h3><a class="doc-anchor" href="#doc-net-erlang-b-formula">#</a> <code>net_erlang_b_formula</code></h3>
<p><code>net_erlang_b_formula</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_erlang_b_formula $x
# or in a pipeline:
@list |> map net_erlang_b_formula |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-erlang-c-formula">
<h3><a class="doc-anchor" href="#doc-net-erlang-c-formula">#</a> <code>net_erlang_c_formula</code></h3>
<p><code>net_erlang_c_formula</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_erlang_c_formula $x
# or in a pipeline:
@list |> map net_erlang_c_formula |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-forced-flow-law">
<h3><a class="doc-anchor" href="#doc-net-forced-flow-law">#</a> <code>net_forced_flow_law</code></h3>
<p><code>net_forced_flow_law</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_forced_flow_law $x
# or in a pipeline:
@list |> map net_forced_flow_law |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-friis-received-power">
<h3><a class="doc-anchor" href="#doc-net-friis-received-power">#</a> <code>net_friis_received_power</code></h3>
<p><code>net_friis_received_power</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_friis_received_power $x
# or in a pipeline:
@list |> map net_friis_received_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-handoff-threshold">
<h3><a class="doc-anchor" href="#doc-net-handoff-threshold">#</a> <code>net_handoff_threshold</code></h3>
<p><code>net_handoff_threshold</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_handoff_threshold $x
# or in a pipeline:
@list |> map net_handoff_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-harq-combining-gain">
<h3><a class="doc-anchor" href="#doc-net-harq-combining-gain">#</a> <code>net_harq_combining_gain</code></h3>
<p><code>net_harq_combining_gain</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_harq_combining_gain $x
# or in a pipeline:
@list |> map net_harq_combining_gain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-jitter-estimate">
<h3><a class="doc-anchor" href="#doc-net-jitter-estimate">#</a> <code>net_jitter_estimate</code></h3>
<p><code>net_jitter_estimate</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_jitter_estimate $x
# or in a pipeline:
@list |> map net_jitter_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-kelly-pricing-step">
<h3><a class="doc-anchor" href="#doc-net-kelly-pricing-step">#</a> <code>net_kelly_pricing_step</code></h3>
<p><code>net_kelly_pricing_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_kelly_pricing_step $x
# or in a pipeline:
@list |> map net_kelly_pricing_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-latency-avg">
<h3><a class="doc-anchor" href="#doc-net-latency-avg">#</a> <code>net_latency_avg</code></h3>
<p><code>net_latency_avg</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_latency_avg $x
# or in a pipeline:
@list |> map net_latency_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ldpc-iteration-step">
<h3><a class="doc-anchor" href="#doc-net-ldpc-iteration-step">#</a> <code>net_ldpc_iteration_step</code></h3>
<p><code>net_ldpc_iteration_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_ldpc_iteration_step $x
# or in a pipeline:
@list |> map net_ldpc_iteration_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-link-capacity-share">
<h3><a class="doc-anchor" href="#doc-net-link-capacity-share">#</a> <code>net_link_capacity_share</code></h3>
<p><code>net_link_capacity_share</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_link_capacity_share $x
# or in a pipeline:
@list |> map net_link_capacity_share |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-little-law-l">
<h3><a class="doc-anchor" href="#doc-net-little-law-l">#</a> <code>net_little_law_l</code></h3>
<p><code>net_little_law_l</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_little_law_l $x
# or in a pipeline:
@list |> map net_little_law_l |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-log-distance-path">
<h3><a class="doc-anchor" href="#doc-net-log-distance-path">#</a> <code>net_log_distance_path</code></h3>
<p><code>net_log_distance_path</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_log_distance_path $x
# or in a pipeline:
@list |> map net_log_distance_path |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-loss-rate-to-throughput">
<h3><a class="doc-anchor" href="#doc-net-loss-rate-to-throughput">#</a> <code>net_loss_rate_to_throughput</code></h3>
<p><code>net_loss_rate_to_throughput</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_loss_rate_to_throughput $input
</code></pre>
</article>
<article class="doc-entry" id="doc-net-lyapunov-drift-plus-penalty">
<h3><a class="doc-anchor" href="#doc-net-lyapunov-drift-plus-penalty">#</a> <code>net_lyapunov_drift_plus_penalty</code></h3>
<p><code>net_lyapunov_drift_plus_penalty</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_lyapunov_drift_plus_penalty $x
# or in a pipeline:
@list |> map net_lyapunov_drift_plus_penalty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-macro-diversity-step">
<h3><a class="doc-anchor" href="#doc-net-macro-diversity-step">#</a> <code>net_macro_diversity_step</code></h3>
<p><code>net_macro_diversity_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_macro_diversity_step $x
# or in a pipeline:
@list |> map net_macro_diversity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-max-min-fair-step">
<h3><a class="doc-anchor" href="#doc-net-max-min-fair-step">#</a> <code>net_max_min_fair_step</code></h3>
<p><code>net_max_min_fair_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_max_min_fair_step $x
# or in a pipeline:
@list |> map net_max_min_fair_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-max-weight-match">
<h3><a class="doc-anchor" href="#doc-net-max-weight-match">#</a> <code>net_max_weight_match</code></h3>
<p><code>net_max_weight_match</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_max_weight_match $x
# or in a pipeline:
@list |> map net_max_weight_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-miad-step">
<h3><a class="doc-anchor" href="#doc-net-miad-step">#</a> <code>net_miad_step</code></h3>
<p><code>net_miad_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_miad_step $x
# or in a pipeline:
@list |> map net_miad_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-micro-diversity-step">
<h3><a class="doc-anchor" href="#doc-net-micro-diversity-step">#</a> <code>net_micro_diversity_step</code></h3>
<p><code>net_micro_diversity_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_micro_diversity_step $x
# or in a pipeline:
@list |> map net_micro_diversity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-mimd-step">
<h3><a class="doc-anchor" href="#doc-net-mimd-step">#</a> <code>net_mimd_step</code></h3>
<p><code>net_mimd_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_mimd_step $x
# or in a pipeline:
@list |> map net_mimd_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-mimo-capacity-step">
<h3><a class="doc-anchor" href="#doc-net-mimo-capacity-step">#</a> <code>net_mimo_capacity_step</code></h3>
<p><code>net_mimo_capacity_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_mimo_capacity_step $x
# or in a pipeline:
@list |> map net_mimo_capacity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-mmse-beam-step">
<h3><a class="doc-anchor" href="#doc-net-mmse-beam-step">#</a> <code>net_mmse_beam_step</code></h3>
<p><code>net_mmse_beam_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_mmse_beam_step $x
# or in a pipeline:
@list |> map net_mmse_beam_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-multiplexing-gain">
<h3><a class="doc-anchor" href="#doc-net-multiplexing-gain">#</a> <code>net_multiplexing_gain</code></h3>
<p><code>net_multiplexing_gain</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_multiplexing_gain $x
# or in a pipeline:
@list |> map net_multiplexing_gain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-network-utility-max">
<h3><a class="doc-anchor" href="#doc-net-network-utility-max">#</a> <code>net_network_utility_max</code></h3>
<p><code>net_network_utility_max</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_network_utility_max $x
# or in a pipeline:
@list |> map net_network_utility_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-okumura-hata-loss">
<h3><a class="doc-anchor" href="#doc-net-okumura-hata-loss">#</a> <code>net_okumura_hata_loss</code></h3>
<p><code>net_okumura_hata_loss</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_okumura_hata_loss $x
# or in a pipeline:
@list |> map net_okumura_hata_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-outage-probability">
<h3><a class="doc-anchor" href="#doc-net-outage-probability">#</a> <code>net_outage_probability</code></h3>
<p><code>net_outage_probability</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_outage_probability $x
# or in a pipeline:
@list |> map net_outage_probability |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-packet-loss-estimate">
<h3><a class="doc-anchor" href="#doc-net-packet-loss-estimate">#</a> <code>net_packet_loss_estimate</code></h3>
<p><code>net_packet_loss_estimate</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_packet_loss_estimate $x
# or in a pipeline:
@list |> map net_packet_loss_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-packet-pacing-step">
<h3><a class="doc-anchor" href="#doc-net-packet-pacing-step">#</a> <code>net_packet_pacing_step</code></h3>
<p><code>net_packet_pacing_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_packet_pacing_step $x
# or in a pipeline:
@list |> map net_packet_pacing_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-path-capacity-kleinrock">
<h3><a class="doc-anchor" href="#doc-net-path-capacity-kleinrock">#</a> <code>net_path_capacity_kleinrock</code></h3>
<p><code>net_path_capacity_kleinrock</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_path_capacity_kleinrock $x
# or in a pipeline:
@list |> map net_path_capacity_kleinrock |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-polar-decode-step">
<h3><a class="doc-anchor" href="#doc-net-polar-decode-step">#</a> <code>net_polar_decode_step</code></h3>
<p><code>net_polar_decode_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_polar_decode_step $x
# or in a pipeline:
@list |> map net_polar_decode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-polling-efficiency">
<h3><a class="doc-anchor" href="#doc-net-polling-efficiency">#</a> <code>net_polling_efficiency</code></h3>
<p><code>net_polling_efficiency</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_polling_efficiency $x
# or in a pipeline:
@list |> map net_polling_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-priority-queue-index">
<h3><a class="doc-anchor" href="#doc-net-priority-queue-index">#</a> <code>net_priority_queue_index</code></h3>
<p><code>net_priority_queue_index</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_priority_queue_index $x
# or in a pipeline:
@list |> map net_priority_queue_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-proportional-fair-share">
<h3><a class="doc-anchor" href="#doc-net-proportional-fair-share">#</a> <code>net_proportional_fair_share</code></h3>
<p><code>net_proportional_fair_share</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_proportional_fair_share $x
# or in a pipeline:
@list |> map net_proportional_fair_share |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-pruning-gain">
<h3><a class="doc-anchor" href="#doc-net-pruning-gain">#</a> <code>net_pruning_gain</code></h3>
<p><code>net_pruning_gain</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_pruning_gain $x
# or in a pipeline:
@list |> map net_pruning_gain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-qcsma-propose">
<h3><a class="doc-anchor" href="#doc-net-qcsma-propose">#</a> <code>net_qcsma_propose</code></h3>
<p><code>net_qcsma_propose</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_qcsma_propose $x
# or in a pipeline:
@list |> map net_qcsma_propose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-radio-path-loss">
<h3><a class="doc-anchor" href="#doc-net-radio-path-loss">#</a> <code>net_radio_path_loss</code></h3>
<p><code>net_radio_path_loss</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_radio_path_loss $x
# or in a pipeline:
@list |> map net_radio_path_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-rayleigh-envelope">
<h3><a class="doc-anchor" href="#doc-net-rayleigh-envelope">#</a> <code>net_rayleigh_envelope</code></h3>
<p><code>net_rayleigh_envelope</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_rayleigh_envelope $x
# or in a pipeline:
@list |> map net_rayleigh_envelope |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-reproductive-rate">
<h3><a class="doc-anchor" href="#doc-net-reproductive-rate">#</a> <code>net_reproductive_rate</code></h3>
<p><code>net_reproductive_rate</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = net_reproductive_rate $x
# or in a pipeline:
@list |> map net_reproductive_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-response-time-law">
<h3><a class="doc-anchor" href="#doc-net-response-time-law">#</a> <code>net_response_time_law</code></h3>
<p><code>net_response_time_law</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_response_time_law $x
# or in a pipeline:
@list |> map net_response_time_law |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-rician-k-factor">
<h3><a class="doc-anchor" href="#doc-net-rician-k-factor">#</a> <code>net_rician_k_factor</code></h3>
<p><code>net_rician_k_factor</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_rician_k_factor $x
# or in a pipeline:
@list |> map net_rician_k_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-router-buffer-size">
<h3><a class="doc-anchor" href="#doc-net-router-buffer-size">#</a> <code>net_router_buffer_size</code></h3>
<p><code>net_router_buffer_size</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_router_buffer_size $x
# or in a pipeline:
@list |> map net_router_buffer_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-rto-compute">
<h3><a class="doc-anchor" href="#doc-net-rto-compute">#</a> <code>net_rto_compute</code></h3>
<p><code>net_rto_compute</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_rto_compute $input
</code></pre>
</article>
<article class="doc-entry" id="doc-net-rtt-smoothed">
<h3><a class="doc-anchor" href="#doc-net-rtt-smoothed">#</a> <code>net_rtt_smoothed</code></h3>
<p><code>net_rtt_smoothed</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_rtt_smoothed $x
# or in a pipeline:
@list |> map net_rtt_smoothed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-rtt-variation">
<h3><a class="doc-anchor" href="#doc-net-rtt-variation">#</a> <code>net_rtt_variation</code></h3>
<p><code>net_rtt_variation</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_rtt_variation $x
# or in a pipeline:
@list |> map net_rtt_variation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-shadowing-normal">
<h3><a class="doc-anchor" href="#doc-net-shadowing-normal">#</a> <code>net_shadowing_normal</code></h3>
<p><code>net_shadowing_normal</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_shadowing_normal $x
# or in a pipeline:
@list |> map net_shadowing_normal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-slotted-aloha-throughput">
<h3><a class="doc-anchor" href="#doc-net-slotted-aloha-throughput">#</a> <code>net_slotted_aloha_throughput</code></h3>
<p><code>net_slotted_aloha_throughput</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_slotted_aloha_throughput $x
# or in a pipeline:
@list |> map net_slotted_aloha_throughput |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-bbr-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-bbr-step">#</a> <code>net_tcp_bbr_step</code></h3>
<p><code>net_tcp_bbr_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_bbr_step $x
# or in a pipeline:
@list |> map net_tcp_bbr_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-compound-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-compound-step">#</a> <code>net_tcp_compound_step</code></h3>
<p><code>net_tcp_compound_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_compound_step $x
# or in a pipeline:
@list |> map net_tcp_compound_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-cubic-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-cubic-step">#</a> <code>net_tcp_cubic_step</code></h3>
<p><code>net_tcp_cubic_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_cubic_step $x
# or in a pipeline:
@list |> map net_tcp_cubic_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-cwnd-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-cwnd-step">#</a> <code>net_tcp_cwnd_step</code></h3>
<p><code>net_tcp_cwnd_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_cwnd_step $x
# or in a pipeline:
@list |> map net_tcp_cwnd_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-dctcp-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-dctcp-step">#</a> <code>net_tcp_dctcp_step</code></h3>
<p><code>net_tcp_dctcp_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_dctcp_step $x
# or in a pipeline:
@list |> map net_tcp_dctcp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-htcp-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-htcp-step">#</a> <code>net_tcp_htcp_step</code></h3>
<p><code>net_tcp_htcp_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_htcp_step $x
# or in a pipeline:
@list |> map net_tcp_htcp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-hybla-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-hybla-step">#</a> <code>net_tcp_hybla_step</code></h3>
<p><code>net_tcp_hybla_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_hybla_step $x
# or in a pipeline:
@list |> map net_tcp_hybla_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-illinois-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-illinois-step">#</a> <code>net_tcp_illinois_step</code></h3>
<p><code>net_tcp_illinois_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_illinois_step $x
# or in a pipeline:
@list |> map net_tcp_illinois_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-lp-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-lp-step">#</a> <code>net_tcp_lp_step</code></h3>
<p><code>net_tcp_lp_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_lp_step $x
# or in a pipeline:
@list |> map net_tcp_lp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-reno-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-reno-step">#</a> <code>net_tcp_reno_step</code></h3>
<p><code>net_tcp_reno_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_reno_step $x
# or in a pipeline:
@list |> map net_tcp_reno_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-scalable-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-scalable-step">#</a> <code>net_tcp_scalable_step</code></h3>
<p><code>net_tcp_scalable_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_scalable_step $x
# or in a pipeline:
@list |> map net_tcp_scalable_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-ssthresh-update">
<h3><a class="doc-anchor" href="#doc-net-tcp-ssthresh-update">#</a> <code>net_tcp_ssthresh_update</code></h3>
<p><code>net_tcp_ssthresh_update</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_ssthresh_update $x
# or in a pipeline:
@list |> map net_tcp_ssthresh_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-vegas-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-vegas-step">#</a> <code>net_tcp_vegas_step</code></h3>
<p><code>net_tcp_vegas_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_vegas_step $x
# or in a pipeline:
@list |> map net_tcp_vegas_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-veno-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-veno-step">#</a> <code>net_tcp_veno_step</code></h3>
<p><code>net_tcp_veno_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_veno_step $x
# or in a pipeline:
@list |> map net_tcp_veno_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-westwood-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-westwood-step">#</a> <code>net_tcp_westwood_step</code></h3>
<p><code>net_tcp_westwood_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_westwood_step $x
# or in a pipeline:
@list |> map net_tcp_westwood_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-tcp-yeah-step">
<h3><a class="doc-anchor" href="#doc-net-tcp-yeah-step">#</a> <code>net_tcp_yeah_step</code></h3>
<p><code>net_tcp_yeah_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_tcp_yeah_step $x
# or in a pipeline:
@list |> map net_tcp_yeah_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-throughput-law">
<h3><a class="doc-anchor" href="#doc-net-throughput-law">#</a> <code>net_throughput_law</code></h3>
<p><code>net_throughput_law</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_throughput_law $x
# or in a pipeline:
@list |> map net_throughput_law |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-throughput-mathis">
<h3><a class="doc-anchor" href="#doc-net-throughput-mathis">#</a> <code>net_throughput_mathis</code></h3>
<p><code>net_throughput_mathis</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_throughput_mathis $x
# or in a pipeline:
@list |> map net_throughput_mathis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-throughput-padhye">
<h3><a class="doc-anchor" href="#doc-net-throughput-padhye">#</a> <code>net_throughput_padhye</code></h3>
<p><code>net_throughput_padhye</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_throughput_padhye $x
# or in a pipeline:
@list |> map net_throughput_padhye |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-throughput-response">
<h3><a class="doc-anchor" href="#doc-net-throughput-response">#</a> <code>net_throughput_response</code></h3>
<p><code>net_throughput_response</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_throughput_response $x
# or in a pipeline:
@list |> map net_throughput_response |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-token-rate-limit">
<h3><a class="doc-anchor" href="#doc-net-token-rate-limit">#</a> <code>net_token_rate_limit</code></h3>
<p><code>net_token_rate_limit</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_token_rate_limit $x
# or in a pipeline:
@list |> map net_token_rate_limit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-token-ring-efficiency">
<h3><a class="doc-anchor" href="#doc-net-token-ring-efficiency">#</a> <code>net_token_ring_efficiency</code></h3>
<p><code>net_token_ring_efficiency</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_token_ring_efficiency $x
# or in a pipeline:
@list |> map net_token_ring_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-traffic-shaper-step">
<h3><a class="doc-anchor" href="#doc-net-traffic-shaper-step">#</a> <code>net_traffic_shaper_step</code></h3>
<p><code>net_traffic_shaper_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_traffic_shaper_step $x
# or in a pipeline:
@list |> map net_traffic_shaper_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-turbo-decode-iter">
<h3><a class="doc-anchor" href="#doc-net-turbo-decode-iter">#</a> <code>net_turbo_decode_iter</code></h3>
<p><code>net_turbo_decode_iter</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_turbo_decode_iter $x
# or in a pipeline:
@list |> map net_turbo_decode_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-two-ray-ground-loss">
<h3><a class="doc-anchor" href="#doc-net-two-ray-ground-loss">#</a> <code>net_two_ray_ground_loss</code></h3>
<p><code>net_two_ray_ground_loss</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_two_ray_ground_loss $x
# or in a pipeline:
@list |> map net_two_ray_ground_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-utilization-law">
<h3><a class="doc-anchor" href="#doc-net-utilization-law">#</a> <code>net_utilization_law</code></h3>
<p><code>net_utilization_law</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_utilization_law $x
# or in a pipeline:
@list |> map net_utilization_law |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-viterbi-step">
<h3><a class="doc-anchor" href="#doc-net-viterbi-step">#</a> <code>net_viterbi_step</code></h3>
<p><code>net_viterbi_step</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_viterbi_step $x
# or in a pipeline:
@list |> map net_viterbi_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-water-filling-power">
<h3><a class="doc-anchor" href="#doc-net-water-filling-power">#</a> <code>net_water_filling_power</code></h3>
<p><code>net_water_filling_power</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_water_filling_power $x
# or in a pipeline:
@list |> map net_water_filling_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-net-zero-forcing-beam">
<h3><a class="doc-anchor" href="#doc-net-zero-forcing-beam">#</a> <code>net_zero_forcing_beam</code></h3>
<p><code>net_zero_forcing_beam</code> — batch 49 builtin.</p>
<pre><code class="lang-perl">my $result = net_zero_forcing_beam $x
# or in a pipeline:
@list |> map net_zero_forcing_beam |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-network-formation-step">
<h3><a class="doc-anchor" href="#doc-network-formation-step">#</a> <code>network_formation_step</code></h3>
<p><code>network_formation_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = network_formation_step $x
# or in a pipeline:
@list |> map network_formation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-neutron-mass">
<h3><a class="doc-anchor" href="#doc-neutron-mass">#</a> <code>neutron_mass</code></h3>
<p><code>neutron_mass</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = neutron_mass $x
# or in a pipeline:
@list |> map neutron_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-newey-west-se">
<h3><a class="doc-anchor" href="#doc-newey-west-se">#</a> <code>newey_west_se</code></h3>
<p><code>newey_west_se</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = newey_west_se $x
# or in a pipeline:
@list |> map newey_west_se |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-newmark-beta-step">
<h3><a class="doc-anchor" href="#doc-newmark-beta-step">#</a> <code>newmark_beta_step</code></h3>
<p><code>newmark_beta_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = newmark_beta_step $x
# or in a pipeline:
@list |> map newmark_beta_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-newton">
<h3><a class="doc-anchor" href="#doc-newton">#</a> <code>newton</code></h3>
<p><code>newton_method</code> (aliases <code>newton</code>, <code>newton_raphson</code>) finds a root via Newton-Raphson. Takes f, f', x0, and optional tolerance.</p>
<pre><code class="lang-perl">my $root = newton(fn { $_[0]**2 - 2 }, fn { 2*$_[0] }, 1.5) # √2
</code></pre>
</article>
<article class="doc-entry" id="doc-newtons-to-lbf">
<h3><a class="doc-anchor" href="#doc-newtons-to-lbf">#</a> <code>newtons_to_lbf</code></h3>
<p><code>newtons_to_lbf</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = newtons_to_lbf $input
</code></pre>
</article>
<article class="doc-entry" id="doc-next-permutation">
<h3><a class="doc-anchor" href="#doc-next-permutation">#</a> <code>next_permutation</code></h3>
<p><code>next_permutation</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = next_permutation $x
# or in a pipeline:
@list |> map next_permutation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-next-prime">
<h3><a class="doc-anchor" href="#doc-next-prime">#</a> <code>next_prime</code></h3>
<p><code>next_prime</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = next_prime $x
# or in a pipeline:
@list |> map next_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nfa-to-dfa">
<h3><a class="doc-anchor" href="#doc-nfa-to-dfa">#</a> <code>nfa_to_dfa</code></h3>
<p><code>nfa_to_dfa</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = nfa_to_dfa $input
</code></pre>
</article>
<article class="doc-entry" id="doc-nfirst">
<h3><a class="doc-anchor" href="#doc-nfirst">#</a> <code>nfirst</code></h3>
<p><code>nfirst</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = nfirst $x
# or in a pipeline:
@list |> map nfirst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nfs">
<h3><a class="doc-anchor" href="#doc-nfs">#</a> <code>nfs</code></h3>
<p><code>nfs</code> — algebraic match builtin. Alias for <code>nfirst</code>.</p>
<pre><code class="lang-perl">my $result = nfs $x
# or in a pipeline:
@list |> map nfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ngram">
<h3><a class="doc-anchor" href="#doc-ngram">#</a> <code>ngram</code></h3>
<p><code>ngram</code> — string processing (uncategorized batch) builtin. Alias for <code>ngrams</code>.</p>
<pre><code class="lang-perl">my $result = ngram $x
# or in a pipeline:
@list |> map ngram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ngrams">
<h3><a class="doc-anchor" href="#doc-ngrams">#</a> <code>ngrams</code></h3>
<p><code>ngrams</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = ngrams $x
# or in a pipeline:
@list |> map ngrams |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nichols-chart-step">
<h3><a class="doc-anchor" href="#doc-nichols-chart-step">#</a> <code>nichols_chart_step</code></h3>
<p><code>nichols_chart_step</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = nichols_chart_step $x
# or in a pipeline:
@list |> map nichols_chart_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nilpotency-class-lower">
<h3><a class="doc-anchor" href="#doc-nilpotency-class-lower">#</a> <code>nilpotency_class_lower</code></h3>
<p><code>nilpotency_class_lower</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = nilpotency_class_lower $x
# or in a pipeline:
@list |> map nilpotency_class_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-alibi-position-bias">
<h3><a class="doc-anchor" href="#doc-nlp-alibi-position-bias">#</a> <code>nlp_alibi_position_bias</code></h3>
<p><code>nlp_alibi_position_bias</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_alibi_position_bias $x
# or in a pipeline:
@list |> map nlp_alibi_position_bias |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-attention-pool-step">
<h3><a class="doc-anchor" href="#doc-nlp-attention-pool-step">#</a> <code>nlp_attention_pool_step</code></h3>
<p><code>nlp_attention_pool_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_attention_pool_step $x
# or in a pipeline:
@list |> map nlp_attention_pool_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-avg-pool-step">
<h3><a class="doc-anchor" href="#doc-nlp-avg-pool-step">#</a> <code>nlp_avg_pool_step</code></h3>
<p><code>nlp_avg_pool_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_avg_pool_step $x
# or in a pipeline:
@list |> map nlp_avg_pool_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-bigbird-step">
<h3><a class="doc-anchor" href="#doc-nlp-bigbird-step">#</a> <code>nlp_bigbird_step</code></h3>
<p><code>nlp_bigbird_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_bigbird_step $x
# or in a pipeline:
@list |> map nlp_bigbird_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-bits-per-character">
<h3><a class="doc-anchor" href="#doc-nlp-bits-per-character">#</a> <code>nlp_bits_per_character</code></h3>
<p><code>nlp_bits_per_character</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_bits_per_character $x
# or in a pipeline:
@list |> map nlp_bits_per_character |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-bleu-score-n">
<h3><a class="doc-anchor" href="#doc-nlp-bleu-score-n">#</a> <code>nlp_bleu_score_n</code></h3>
<p><code>nlp_bleu_score_n</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_bleu_score_n $x
# or in a pipeline:
@list |> map nlp_bleu_score_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-block-attn-step">
<h3><a class="doc-anchor" href="#doc-nlp-block-attn-step">#</a> <code>nlp_block_attn_step</code></h3>
<p><code>nlp_block_attn_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_block_attn_step $x
# or in a pipeline:
@list |> map nlp_block_attn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-bm25-score">
<h3><a class="doc-anchor" href="#doc-nlp-bm25-score">#</a> <code>nlp_bm25_score</code></h3>
<p><code>nlp_bm25_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_bm25_score $x
# or in a pipeline:
@list |> map nlp_bm25_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-byte-frequency">
<h3><a class="doc-anchor" href="#doc-nlp-byte-frequency">#</a> <code>nlp_byte_frequency</code></h3>
<p><code>nlp_byte_frequency</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_byte_frequency $x
# or in a pipeline:
@list |> map nlp_byte_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-byte-level-bpe-step">
<h3><a class="doc-anchor" href="#doc-nlp-byte-level-bpe-step">#</a> <code>nlp_byte_level_bpe_step</code></h3>
<p><code>nlp_byte_level_bpe_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_byte_level_bpe_step $x
# or in a pipeline:
@list |> map nlp_byte_level_bpe_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-byte-pair-merge-step">
<h3><a class="doc-anchor" href="#doc-nlp-byte-pair-merge-step">#</a> <code>nlp_byte_pair_merge_step</code></h3>
<p><code>nlp_byte_pair_merge_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_byte_pair_merge_step $x
# or in a pipeline:
@list |> map nlp_byte_pair_merge_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-cer-score">
<h3><a class="doc-anchor" href="#doc-nlp-cer-score">#</a> <code>nlp_cer_score</code></h3>
<p><code>nlp_cer_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_cer_score $x
# or in a pipeline:
@list |> map nlp_cer_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-char-frequency">
<h3><a class="doc-anchor" href="#doc-nlp-char-frequency">#</a> <code>nlp_char_frequency</code></h3>
<p><code>nlp_char_frequency</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_char_frequency $x
# or in a pipeline:
@list |> map nlp_char_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-char-ngram-count">
<h3><a class="doc-anchor" href="#doc-nlp-char-ngram-count">#</a> <code>nlp_char_ngram_count</code></h3>
<p><code>nlp_char_ngram_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_char_ngram_count $x
# or in a pipeline:
@list |> map nlp_char_ngram_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-chi2-collocation">
<h3><a class="doc-anchor" href="#doc-nlp-chi2-collocation">#</a> <code>nlp_chi2_collocation</code></h3>
<p><code>nlp_chi2_collocation</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_chi2_collocation $x
# or in a pipeline:
@list |> map nlp_chi2_collocation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-chrf-score">
<h3><a class="doc-anchor" href="#doc-nlp-chrf-score">#</a> <code>nlp_chrf_score</code></h3>
<p><code>nlp_chrf_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_chrf_score $x
# or in a pipeline:
@list |> map nlp_chrf_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-cosine-similarity-two">
<h3><a class="doc-anchor" href="#doc-nlp-cosine-similarity-two">#</a> <code>nlp_cosine_similarity_two</code></h3>
<p><code>nlp_cosine_similarity_two</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_cosine_similarity_two $x
# or in a pipeline:
@list |> map nlp_cosine_similarity_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-cross-attn-compute-step">
<h3><a class="doc-anchor" href="#doc-nlp-cross-attn-compute-step">#</a> <code>nlp_cross_attn_compute_step</code></h3>
<p><code>nlp_cross_attn_compute_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_cross_attn_compute_step $x
# or in a pipeline:
@list |> map nlp_cross_attn_compute_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-damerau-levenshtein">
<h3><a class="doc-anchor" href="#doc-nlp-damerau-levenshtein">#</a> <code>nlp_damerau_levenshtein</code></h3>
<p><code>nlp_damerau_levenshtein</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_damerau_levenshtein $x
# or in a pipeline:
@list |> map nlp_damerau_levenshtein |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-dice-coefficient-two">
<h3><a class="doc-anchor" href="#doc-nlp-dice-coefficient-two">#</a> <code>nlp_dice_coefficient_two</code></h3>
<p><code>nlp_dice_coefficient_two</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_dice_coefficient_two $x
# or in a pipeline:
@list |> map nlp_dice_coefficient_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-digit-ratio">
<h3><a class="doc-anchor" href="#doc-nlp-digit-ratio">#</a> <code>nlp_digit_ratio</code></h3>
<p><code>nlp_digit_ratio</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_digit_ratio $x
# or in a pipeline:
@list |> map nlp_digit_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-dilated-attn-step">
<h3><a class="doc-anchor" href="#doc-nlp-dilated-attn-step">#</a> <code>nlp_dilated_attn_step</code></h3>
<p><code>nlp_dilated_attn_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_dilated_attn_step $x
# or in a pipeline:
@list |> map nlp_dilated_attn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-dirichlet-smoothing">
<h3><a class="doc-anchor" href="#doc-nlp-dirichlet-smoothing">#</a> <code>nlp_dirichlet_smoothing</code></h3>
<p><code>nlp_dirichlet_smoothing</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_dirichlet_smoothing $x
# or in a pipeline:
@list |> map nlp_dirichlet_smoothing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-doc-embedding-avg">
<h3><a class="doc-anchor" href="#doc-nlp-doc-embedding-avg">#</a> <code>nlp_doc_embedding_avg</code></h3>
<p><code>nlp_doc_embedding_avg</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_doc_embedding_avg $x
# or in a pipeline:
@list |> map nlp_doc_embedding_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-doc-freq-step">
<h3><a class="doc-anchor" href="#doc-nlp-doc-freq-step">#</a> <code>nlp_doc_freq_step</code></h3>
<p><code>nlp_doc_freq_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_doc_freq_step $x
# or in a pipeline:
@list |> map nlp_doc_freq_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-dunning-log-likelihood">
<h3><a class="doc-anchor" href="#doc-nlp-dunning-log-likelihood">#</a> <code>nlp_dunning_log_likelihood</code></h3>
<p><code>nlp_dunning_log_likelihood</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_dunning_log_likelihood $x
# or in a pipeline:
@list |> map nlp_dunning_log_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-email-count">
<h3><a class="doc-anchor" href="#doc-nlp-email-count">#</a> <code>nlp_email_count</code></h3>
<p><code>nlp_email_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_email_count $x
# or in a pipeline:
@list |> map nlp_email_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-emoji-ratio">
<h3><a class="doc-anchor" href="#doc-nlp-emoji-ratio">#</a> <code>nlp_emoji_ratio</code></h3>
<p><code>nlp_emoji_ratio</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_emoji_ratio $x
# or in a pipeline:
@list |> map nlp_emoji_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-fasttext-subword-count">
<h3><a class="doc-anchor" href="#doc-nlp-fasttext-subword-count">#</a> <code>nlp_fasttext_subword_count</code></h3>
<p><code>nlp_fasttext_subword_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_fasttext_subword_count $x
# or in a pipeline:
@list |> map nlp_fasttext_subword_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-global-attn-step">
<h3><a class="doc-anchor" href="#doc-nlp-global-attn-step">#</a> <code>nlp_global_attn_step</code></h3>
<p><code>nlp_global_attn_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_global_attn_step $x
# or in a pipeline:
@list |> map nlp_global_attn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-glove-loss-step">
<h3><a class="doc-anchor" href="#doc-nlp-glove-loss-step">#</a> <code>nlp_glove_loss_step</code></h3>
<p><code>nlp_glove_loss_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_glove_loss_step $x
# or in a pipeline:
@list |> map nlp_glove_loss_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-good-turing-count">
<h3><a class="doc-anchor" href="#doc-nlp-good-turing-count">#</a> <code>nlp_good_turing_count</code></h3>
<p><code>nlp_good_turing_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_good_turing_count $x
# or in a pipeline:
@list |> map nlp_good_turing_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-hamming-distance">
<h3><a class="doc-anchor" href="#doc-nlp-hamming-distance">#</a> <code>nlp_hamming_distance</code></h3>
<p><code>nlp_hamming_distance</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_hamming_distance $x
# or in a pipeline:
@list |> map nlp_hamming_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-hashtag-count">
<h3><a class="doc-anchor" href="#doc-nlp-hashtag-count">#</a> <code>nlp_hashtag_count</code></h3>
<p><code>nlp_hashtag_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_hashtag_count $x
# or in a pipeline:
@list |> map nlp_hashtag_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-inverse-doc-freq">
<h3><a class="doc-anchor" href="#doc-nlp-inverse-doc-freq">#</a> <code>nlp_inverse_doc_freq</code></h3>
<p><code>nlp_inverse_doc_freq</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_inverse_doc_freq $x
# or in a pipeline:
@list |> map nlp_inverse_doc_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-jaccard-similarity-two">
<h3><a class="doc-anchor" href="#doc-nlp-jaccard-similarity-two">#</a> <code>nlp_jaccard_similarity_two</code></h3>
<p><code>nlp_jaccard_similarity_two</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_jaccard_similarity_two $x
# or in a pipeline:
@list |> map nlp_jaccard_similarity_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-jaro-distance">
<h3><a class="doc-anchor" href="#doc-nlp-jaro-distance">#</a> <code>nlp_jaro_distance</code></h3>
<p><code>nlp_jaro_distance</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_jaro_distance $x
# or in a pipeline:
@list |> map nlp_jaro_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-jaro-winkler">
<h3><a class="doc-anchor" href="#doc-nlp-jaro-winkler">#</a> <code>nlp_jaro_winkler</code></h3>
<p><code>nlp_jaro_winkler</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_jaro_winkler $x
# or in a pipeline:
@list |> map nlp_jaro_winkler |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-jelinek-mercer">
<h3><a class="doc-anchor" href="#doc-nlp-jelinek-mercer">#</a> <code>nlp_jelinek_mercer</code></h3>
<p><code>nlp_jelinek_mercer</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_jelinek_mercer $x
# or in a pipeline:
@list |> map nlp_jelinek_mercer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-kl-lm-div">
<h3><a class="doc-anchor" href="#doc-nlp-kl-lm-div">#</a> <code>nlp_kl_lm_div</code></h3>
<p><code>nlp_kl_lm_div</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_kl_lm_div $x
# or in a pipeline:
@list |> map nlp_kl_lm_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-kneser-ney-step">
<h3><a class="doc-anchor" href="#doc-nlp-kneser-ney-step">#</a> <code>nlp_kneser_ney_step</code></h3>
<p><code>nlp_kneser_ney_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_kneser_ney_step $x
# or in a pipeline:
@list |> map nlp_kneser_ney_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-laplace-smoothing">
<h3><a class="doc-anchor" href="#doc-nlp-laplace-smoothing">#</a> <code>nlp_laplace_smoothing</code></h3>
<p><code>nlp_laplace_smoothing</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_laplace_smoothing $x
# or in a pipeline:
@list |> map nlp_laplace_smoothing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-lcs-length">
<h3><a class="doc-anchor" href="#doc-nlp-lcs-length">#</a> <code>nlp_lcs_length</code></h3>
<p><code>nlp_lcs_length</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_lcs_length $x
# or in a pipeline:
@list |> map nlp_lcs_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-lcs-ratio">
<h3><a class="doc-anchor" href="#doc-nlp-lcs-ratio">#</a> <code>nlp_lcs_ratio</code></h3>
<p><code>nlp_lcs_ratio</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_lcs_ratio $x
# or in a pipeline:
@list |> map nlp_lcs_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-lda-alpha-step">
<h3><a class="doc-anchor" href="#doc-nlp-lda-alpha-step">#</a> <code>nlp_lda_alpha_step</code></h3>
<p><code>nlp_lda_alpha_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_lda_alpha_step $x
# or in a pipeline:
@list |> map nlp_lda_alpha_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-lda-beta-step">
<h3><a class="doc-anchor" href="#doc-nlp-lda-beta-step">#</a> <code>nlp_lda_beta_step</code></h3>
<p><code>nlp_lda_beta_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_lda_beta_step $x
# or in a pipeline:
@list |> map nlp_lda_beta_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-lda-topic-dist">
<h3><a class="doc-anchor" href="#doc-nlp-lda-topic-dist">#</a> <code>nlp_lda_topic_dist</code></h3>
<p><code>nlp_lda_topic_dist</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_lda_topic_dist $x
# or in a pipeline:
@list |> map nlp_lda_topic_dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-levenshtein-dist">
<h3><a class="doc-anchor" href="#doc-nlp-levenshtein-dist">#</a> <code>nlp_levenshtein_dist</code></h3>
<p><code>nlp_levenshtein_dist</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_levenshtein_dist $x
# or in a pipeline:
@list |> map nlp_levenshtein_dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-lidstone-smoothing">
<h3><a class="doc-anchor" href="#doc-nlp-lidstone-smoothing">#</a> <code>nlp_lidstone_smoothing</code></h3>
<p><code>nlp_lidstone_smoothing</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_lidstone_smoothing $x
# or in a pipeline:
@list |> map nlp_lidstone_smoothing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-linformer-step">
<h3><a class="doc-anchor" href="#doc-nlp-linformer-step">#</a> <code>nlp_linformer_step</code></h3>
<p><code>nlp_linformer_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_linformer_step $x
# or in a pipeline:
@list |> map nlp_linformer_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-local-attn-step">
<h3><a class="doc-anchor" href="#doc-nlp-local-attn-step">#</a> <code>nlp_local_attn_step</code></h3>
<p><code>nlp_local_attn_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_local_attn_step $x
# or in a pipeline:
@list |> map nlp_local_attn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-loglikelihood-collocation">
<h3><a class="doc-anchor" href="#doc-nlp-loglikelihood-collocation">#</a> <code>nlp_loglikelihood_collocation</code></h3>
<p><code>nlp_loglikelihood_collocation</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_loglikelihood_collocation $x
# or in a pipeline:
@list |> map nlp_loglikelihood_collocation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-longformer-step">
<h3><a class="doc-anchor" href="#doc-nlp-longformer-step">#</a> <code>nlp_longformer_step</code></h3>
<p><code>nlp_longformer_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_longformer_step $x
# or in a pipeline:
@list |> map nlp_longformer_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-max-pool-step">
<h3><a class="doc-anchor" href="#doc-nlp-max-pool-step">#</a> <code>nlp_max_pool_step</code></h3>
<p><code>nlp_max_pool_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_max_pool_step $x
# or in a pipeline:
@list |> map nlp_max_pool_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-max-seq-len-check">
<h3><a class="doc-anchor" href="#doc-nlp-max-seq-len-check">#</a> <code>nlp_max_seq_len_check</code></h3>
<p><code>nlp_max_seq_len_check</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_max_seq_len_check $x
# or in a pipeline:
@list |> map nlp_max_seq_len_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-mention-count">
<h3><a class="doc-anchor" href="#doc-nlp-mention-count">#</a> <code>nlp_mention_count</code></h3>
<p><code>nlp_mention_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_mention_count $x
# or in a pipeline:
@list |> map nlp_mention_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-meteor-score">
<h3><a class="doc-anchor" href="#doc-nlp-meteor-score">#</a> <code>nlp_meteor_score</code></h3>
<p><code>nlp_meteor_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_meteor_score $x
# or in a pipeline:
@list |> map nlp_meteor_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-npmi-score">
<h3><a class="doc-anchor" href="#doc-nlp-npmi-score">#</a> <code>nlp_npmi_score</code></h3>
<p><code>nlp_npmi_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_npmi_score $x
# or in a pipeline:
@list |> map nlp_npmi_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-okapi-score">
<h3><a class="doc-anchor" href="#doc-nlp-okapi-score">#</a> <code>nlp_okapi_score</code></h3>
<p><code>nlp_okapi_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_okapi_score $x
# or in a pipeline:
@list |> map nlp_okapi_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-overlap-coefficient">
<h3><a class="doc-anchor" href="#doc-nlp-overlap-coefficient">#</a> <code>nlp_overlap_coefficient</code></h3>
<p><code>nlp_overlap_coefficient</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_overlap_coefficient $x
# or in a pipeline:
@list |> map nlp_overlap_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-pe-freq-band">
<h3><a class="doc-anchor" href="#doc-nlp-pe-freq-band">#</a> <code>nlp_pe_freq_band</code></h3>
<p><code>nlp_pe_freq_band</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_pe_freq_band $x
# or in a pipeline:
@list |> map nlp_pe_freq_band |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-performer-step">
<h3><a class="doc-anchor" href="#doc-nlp-performer-step">#</a> <code>nlp_performer_step</code></h3>
<p><code>nlp_performer_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_performer_step $x
# or in a pipeline:
@list |> map nlp_performer_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-perplexity-value">
<h3><a class="doc-anchor" href="#doc-nlp-perplexity-value">#</a> <code>nlp_perplexity_value</code></h3>
<p><code>nlp_perplexity_value</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_perplexity_value $x
# or in a pipeline:
@list |> map nlp_perplexity_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-phone-count">
<h3><a class="doc-anchor" href="#doc-nlp-phone-count">#</a> <code>nlp_phone_count</code></h3>
<p><code>nlp_phone_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_phone_count $x
# or in a pipeline:
@list |> map nlp_phone_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-plsa-step">
<h3><a class="doc-anchor" href="#doc-nlp-plsa-step">#</a> <code>nlp_plsa_step</code></h3>
<p><code>nlp_plsa_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_plsa_step $x
# or in a pipeline:
@list |> map nlp_plsa_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-pmi-score">
<h3><a class="doc-anchor" href="#doc-nlp-pmi-score">#</a> <code>nlp_pmi_score</code></h3>
<p><code>nlp_pmi_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_pmi_score $x
# or in a pipeline:
@list |> map nlp_pmi_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-pointwise-attn-score">
<h3><a class="doc-anchor" href="#doc-nlp-pointwise-attn-score">#</a> <code>nlp_pointwise_attn_score</code></h3>
<p><code>nlp_pointwise_attn_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_pointwise_attn_score $x
# or in a pipeline:
@list |> map nlp_pointwise_attn_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-position-encoding-cos">
<h3><a class="doc-anchor" href="#doc-nlp-position-encoding-cos">#</a> <code>nlp_position_encoding_cos</code></h3>
<p><code>nlp_position_encoding_cos</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_position_encoding_cos $x
# or in a pipeline:
@list |> map nlp_position_encoding_cos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-position-encoding-sin">
<h3><a class="doc-anchor" href="#doc-nlp-position-encoding-sin">#</a> <code>nlp_position_encoding_sin</code></h3>
<p><code>nlp_position_encoding_sin</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_position_encoding_sin $x
# or in a pipeline:
@list |> map nlp_position_encoding_sin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-punct-ratio">
<h3><a class="doc-anchor" href="#doc-nlp-punct-ratio">#</a> <code>nlp_punct_ratio</code></h3>
<p><code>nlp_punct_ratio</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_punct_ratio $x
# or in a pipeline:
@list |> map nlp_punct_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-query-likelihood-step">
<h3><a class="doc-anchor" href="#doc-nlp-query-likelihood-step">#</a> <code>nlp_query_likelihood_step</code></h3>
<p><code>nlp_query_likelihood_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_query_likelihood_step $x
# or in a pipeline:
@list |> map nlp_query_likelihood_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-reformer-step">
<h3><a class="doc-anchor" href="#doc-nlp-reformer-step">#</a> <code>nlp_reformer_step</code></h3>
<p><code>nlp_reformer_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_reformer_step $x
# or in a pipeline:
@list |> map nlp_reformer_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-relative-position-bias">
<h3><a class="doc-anchor" href="#doc-nlp-relative-position-bias">#</a> <code>nlp_relative_position_bias</code></h3>
<p><code>nlp_relative_position_bias</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_relative_position_bias $x
# or in a pipeline:
@list |> map nlp_relative_position_bias |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-rope-apply-step">
<h3><a class="doc-anchor" href="#doc-nlp-rope-apply-step">#</a> <code>nlp_rope_apply_step</code></h3>
<p><code>nlp_rope_apply_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_rope_apply_step $x
# or in a pipeline:
@list |> map nlp_rope_apply_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-rope-rotary-angle">
<h3><a class="doc-anchor" href="#doc-nlp-rope-rotary-angle">#</a> <code>nlp_rope_rotary_angle</code></h3>
<p><code>nlp_rope_rotary_angle</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_rope_rotary_angle $x
# or in a pipeline:
@list |> map nlp_rope_rotary_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-rouge-score-n">
<h3><a class="doc-anchor" href="#doc-nlp-rouge-score-n">#</a> <code>nlp_rouge_score_n</code></h3>
<p><code>nlp_rouge_score_n</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_rouge_score_n $x
# or in a pipeline:
@list |> map nlp_rouge_score_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-routing-attn-step">
<h3><a class="doc-anchor" href="#doc-nlp-routing-attn-step">#</a> <code>nlp_routing_attn_step</code></h3>
<p><code>nlp_routing_attn_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_routing_attn_step $x
# or in a pipeline:
@list |> map nlp_routing_attn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-self-attn-compute-step">
<h3><a class="doc-anchor" href="#doc-nlp-self-attn-compute-step">#</a> <code>nlp_self_attn_compute_step</code></h3>
<p><code>nlp_self_attn_compute_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_self_attn_compute_step $x
# or in a pipeline:
@list |> map nlp_self_attn_compute_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-sentencepiece-score">
<h3><a class="doc-anchor" href="#doc-nlp-sentencepiece-score">#</a> <code>nlp_sentencepiece_score</code></h3>
<p><code>nlp_sentencepiece_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_sentencepiece_score $x
# or in a pipeline:
@list |> map nlp_sentencepiece_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-sif-weight-step">
<h3><a class="doc-anchor" href="#doc-nlp-sif-weight-step">#</a> <code>nlp_sif_weight_step</code></h3>
<p><code>nlp_sif_weight_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_sif_weight_step $x
# or in a pipeline:
@list |> map nlp_sif_weight_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-simpson-coefficient">
<h3><a class="doc-anchor" href="#doc-nlp-simpson-coefficient">#</a> <code>nlp_simpson_coefficient</code></h3>
<p><code>nlp_simpson_coefficient</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_simpson_coefficient $x
# or in a pipeline:
@list |> map nlp_simpson_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-skip-gram-count">
<h3><a class="doc-anchor" href="#doc-nlp-skip-gram-count">#</a> <code>nlp_skip_gram_count</code></h3>
<p><code>nlp_skip_gram_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_skip_gram_count $x
# or in a pipeline:
@list |> map nlp_skip_gram_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-sliding-window-step">
<h3><a class="doc-anchor" href="#doc-nlp-sliding-window-step">#</a> <code>nlp_sliding_window_step</code></h3>
<p><code>nlp_sliding_window_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_sliding_window_step $x
# or in a pipeline:
@list |> map nlp_sliding_window_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-sparse-attn-score">
<h3><a class="doc-anchor" href="#doc-nlp-sparse-attn-score">#</a> <code>nlp_sparse_attn_score</code></h3>
<p><code>nlp_sparse_attn_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_sparse_attn_score $x
# or in a pipeline:
@list |> map nlp_sparse_attn_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-strided-attn-step">
<h3><a class="doc-anchor" href="#doc-nlp-strided-attn-step">#</a> <code>nlp_strided_attn_step</code></h3>
<p><code>nlp_strided_attn_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_strided_attn_step $x
# or in a pipeline:
@list |> map nlp_strided_attn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-subword-regularization">
<h3><a class="doc-anchor" href="#doc-nlp-subword-regularization">#</a> <code>nlp_subword_regularization</code></h3>
<p><code>nlp_subword_regularization</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_subword_regularization $x
# or in a pipeline:
@list |> map nlp_subword_regularization |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-sum-pool-step">
<h3><a class="doc-anchor" href="#doc-nlp-sum-pool-step">#</a> <code>nlp_sum_pool_step</code></h3>
<p><code>nlp_sum_pool_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_sum_pool_step $x
# or in a pipeline:
@list |> map nlp_sum_pool_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-t-score-collocation">
<h3><a class="doc-anchor" href="#doc-nlp-t-score-collocation">#</a> <code>nlp_t_score_collocation</code></h3>
<p><code>nlp_t_score_collocation</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_t_score_collocation $x
# or in a pipeline:
@list |> map nlp_t_score_collocation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-ter-score">
<h3><a class="doc-anchor" href="#doc-nlp-ter-score">#</a> <code>nlp_ter_score</code></h3>
<p><code>nlp_ter_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_ter_score $x
# or in a pipeline:
@list |> map nlp_ter_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-tf-idf-step">
<h3><a class="doc-anchor" href="#doc-nlp-tf-idf-step">#</a> <code>nlp_tf_idf_step</code></h3>
<p><code>nlp_tf_idf_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_tf_idf_step $x
# or in a pipeline:
@list |> map nlp_tf_idf_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-token-drop-rate">
<h3><a class="doc-anchor" href="#doc-nlp-token-drop-rate">#</a> <code>nlp_token_drop_rate</code></h3>
<p><code>nlp_token_drop_rate</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_token_drop_rate $x
# or in a pipeline:
@list |> map nlp_token_drop_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-token-overlap-two">
<h3><a class="doc-anchor" href="#doc-nlp-token-overlap-two">#</a> <code>nlp_token_overlap_two</code></h3>
<p><code>nlp_token_overlap_two</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_token_overlap_two $x
# or in a pipeline:
@list |> map nlp_token_overlap_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-unigram-lm-score">
<h3><a class="doc-anchor" href="#doc-nlp-unigram-lm-score">#</a> <code>nlp_unigram_lm_score</code></h3>
<p><code>nlp_unigram_lm_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_unigram_lm_score $x
# or in a pipeline:
@list |> map nlp_unigram_lm_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-unigram-subword-loss">
<h3><a class="doc-anchor" href="#doc-nlp-unigram-subword-loss">#</a> <code>nlp_unigram_subword_loss</code></h3>
<p><code>nlp_unigram_subword_loss</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_unigram_subword_loss $x
# or in a pipeline:
@list |> map nlp_unigram_subword_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-uppercase-ratio">
<h3><a class="doc-anchor" href="#doc-nlp-uppercase-ratio">#</a> <code>nlp_uppercase_ratio</code></h3>
<p><code>nlp_uppercase_ratio</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_uppercase_ratio $x
# or in a pipeline:
@list |> map nlp_uppercase_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-url-count">
<h3><a class="doc-anchor" href="#doc-nlp-url-count">#</a> <code>nlp_url_count</code></h3>
<p><code>nlp_url_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_url_count $x
# or in a pipeline:
@list |> map nlp_url_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-wer-score">
<h3><a class="doc-anchor" href="#doc-nlp-wer-score">#</a> <code>nlp_wer_score</code></h3>
<p><code>nlp_wer_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_wer_score $x
# or in a pipeline:
@list |> map nlp_wer_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-window-attn-step">
<h3><a class="doc-anchor" href="#doc-nlp-window-attn-step">#</a> <code>nlp_window_attn_step</code></h3>
<p><code>nlp_window_attn_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_window_attn_step $x
# or in a pipeline:
@list |> map nlp_window_attn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-witten-bell-step">
<h3><a class="doc-anchor" href="#doc-nlp-witten-bell-step">#</a> <code>nlp_witten_bell_step</code></h3>
<p><code>nlp_witten_bell_step</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_witten_bell_step $x
# or in a pipeline:
@list |> map nlp_witten_bell_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-word2vec-cbow-loss">
<h3><a class="doc-anchor" href="#doc-nlp-word2vec-cbow-loss">#</a> <code>nlp_word2vec_cbow_loss</code></h3>
<p><code>nlp_word2vec_cbow_loss</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_word2vec_cbow_loss $x
# or in a pipeline:
@list |> map nlp_word2vec_cbow_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-word2vec-skipgram-loss">
<h3><a class="doc-anchor" href="#doc-nlp-word2vec-skipgram-loss">#</a> <code>nlp_word2vec_skipgram_loss</code></h3>
<p><code>nlp_word2vec_skipgram_loss</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_word2vec_skipgram_loss $x
# or in a pipeline:
@list |> map nlp_word2vec_skipgram_loss |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-word-freq-value">
<h3><a class="doc-anchor" href="#doc-nlp-word-freq-value">#</a> <code>nlp_word_freq_value</code></h3>
<p><code>nlp_word_freq_value</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_word_freq_value $x
# or in a pipeline:
@list |> map nlp_word_freq_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-word-mover-dist">
<h3><a class="doc-anchor" href="#doc-nlp-word-mover-dist">#</a> <code>nlp_word_mover_dist</code></h3>
<p><code>nlp_word_mover_dist</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_word_mover_dist $x
# or in a pipeline:
@list |> map nlp_word_mover_dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-word-ngram-count">
<h3><a class="doc-anchor" href="#doc-nlp-word-ngram-count">#</a> <code>nlp_word_ngram_count</code></h3>
<p><code>nlp_word_ngram_count</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_word_ngram_count $x
# or in a pipeline:
@list |> map nlp_word_ngram_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nlp-wordpiece-score">
<h3><a class="doc-anchor" href="#doc-nlp-wordpiece-score">#</a> <code>nlp_wordpiece_score</code></h3>
<p><code>nlp_wordpiece_score</code> — batch 46 builtin.</p>
<pre><code class="lang-perl">my $result = nlp_wordpiece_score $x
# or in a pipeline:
@list |> map nlp_wordpiece_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nm-from-fst">
<h3><a class="doc-anchor" href="#doc-nm-from-fst">#</a> <code>nm_from_fst</code></h3>
<p><code>nm_from_fst</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = nm_from_fst $x
# or in a pipeline:
@list |> map nm_from_fst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nmass">
<h3><a class="doc-anchor" href="#doc-nmass">#</a> <code>nmass</code></h3>
<p><code>nmass</code> — physics constants builtin. Alias for <code>neutron_mass</code>.</p>
<pre><code class="lang-perl">my $result = nmass $x
# or in a pipeline:
@list |> map nmass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nne">
<h3><a class="doc-anchor" href="#doc-nne">#</a> <code>nne</code></h3>
<p><code>nne</code> — algebraic match builtin. Alias for <code>nnext</code>.</p>
<pre><code class="lang-perl">my $result = nne $x
# or in a pipeline:
@list |> map nne |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nnext">
<h3><a class="doc-anchor" href="#doc-nnext">#</a> <code>nnext</code></h3>
<p><code>nnext</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = nnext $x
# or in a pipeline:
@list |> map nnext |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nohtml">
<h3><a class="doc-anchor" href="#doc-nohtml">#</a> <code>nohtml</code></h3>
<p><code>nohtml</code> — string processing (uncategorized batch) builtin. Alias for <code>strip_html</code>.</p>
<pre><code class="lang-perl">my $result = nohtml $x
# or in a pipeline:
@list |> map nohtml |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-noise-model-depolarize">
<h3><a class="doc-anchor" href="#doc-noise-model-depolarize">#</a> <code>noise_model_depolarize</code></h3>
<p><code>noise_model_depolarize</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = noise_model_depolarize $x
# or in a pipeline:
@list |> map noise_model_depolarize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nominal">
<h3><a class="doc-anchor" href="#doc-nominal">#</a> <code>nominal</code></h3>
<p><code>nominal</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = nominal $x
# or in a pipeline:
@list |> map nominal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-none-match">
<h3><a class="doc-anchor" href="#doc-none-match">#</a> <code>none_match</code></h3>
<p><code>none_match</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = none_match $x
# or in a pipeline:
@list |> map none_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nonem">
<h3><a class="doc-anchor" href="#doc-nonem">#</a> <code>nonem</code></h3>
<p><code>nonem</code> — python/ruby stdlib builtin. Alias for <code>none_match</code>.</p>
<pre><code class="lang-perl">my $result = nonem $x
# or in a pipeline:
@list |> map nonem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nonempty-count">
<h3><a class="doc-anchor" href="#doc-nonempty-count">#</a> <code>nonempty_count</code></h3>
<p><code>nonempty_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = nonempty_count $x
# or in a pipeline:
@list |> map nonempty_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nonlinear-dual-step">
<h3><a class="doc-anchor" href="#doc-nonlinear-dual-step">#</a> <code>nonlinear_dual_step</code></h3>
<p><code>nonlinear_dual_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = nonlinear_dual_step $x
# or in a pipeline:
@list |> map nonlinear_dual_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nonzero">
<h3><a class="doc-anchor" href="#doc-nonzero">#</a> <code>nonzero</code></h3>
<p><code>nonzero</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = nonzero $x
# or in a pipeline:
@list |> map nonzero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nonzero-count">
<h3><a class="doc-anchor" href="#doc-nonzero-count">#</a> <code>nonzero_count</code></h3>
<p><code>nonzero_count</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = nonzero_count $x
# or in a pipeline:
@list |> map nonzero_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-noop-val">
<h3><a class="doc-anchor" href="#doc-noop-val">#</a> <code>noop_val</code></h3>
<p><code>noop_val</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = noop_val $x
# or in a pipeline:
@list |> map noop_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nop">
<h3><a class="doc-anchor" href="#doc-nop">#</a> <code>nop</code></h3>
<p><code>nop</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = nop $x
# or in a pipeline:
@list |> map nop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normal-cdf">
<h3><a class="doc-anchor" href="#doc-normal-cdf">#</a> <code>normal_cdf</code></h3>
<p><code>normal_cdf($x, $mu, $sigma)</code> (alias <code>normcdf</code>) — cumulative distribution function. Returns probability that a value is ≤ x.</p>
<pre><code class="lang-perl">p normcdf(0) # 0.5 (half below mean)
p normcdf(1.96) # ~0.975 (95% confidence bound)
</code></pre>
</article>
<article class="doc-entry" id="doc-normal-pdf">
<h3><a class="doc-anchor" href="#doc-normal-pdf">#</a> <code>normal_pdf</code></h3>
<p><code>normal_pdf($x, $mu, $sigma)</code> (alias <code>normpdf</code>) — normal/Gaussian distribution probability density function. Default: μ=0, σ=1 (standard normal).</p>
<pre><code class="lang-perl">p normpdf(0) # ~0.399 (peak of standard normal)
p normpdf(0, 100, 15) # PDF at IQ=100, mean=100, stddev=15
</code></pre>
</article>
<article class="doc-entry" id="doc-normality-chem">
<h3><a class="doc-anchor" href="#doc-normality-chem">#</a> <code>normality_chem</code></h3>
<p><code>normality_chem</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = normality_chem $x
# or in a pipeline:
@list |> map normality_chem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-array">
<h3><a class="doc-anchor" href="#doc-normalize-array">#</a> <code>normalize_array</code></h3>
<p><code>normalize_array</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = normalize_array $x
# or in a pipeline:
@list |> map normalize_array |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-list">
<h3><a class="doc-anchor" href="#doc-normalize-list">#</a> <code>normalize_list</code></h3>
<p><code>normalize_list</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = normalize_list $x
# or in a pipeline:
@list |> map normalize_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-range">
<h3><a class="doc-anchor" href="#doc-normalize-range">#</a> <code>normalize_range</code></h3>
<p><code>normalize_range</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = normalize_range $x
# or in a pipeline:
@list |> map normalize_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-signal">
<h3><a class="doc-anchor" href="#doc-normalize-signal">#</a> <code>normalize_signal</code></h3>
<p><code>normalize_signal(\@signal)</code> (alias <code>normsig</code>) — scales signal to range [-1, 1] based on its peak absolute value. Useful for audio processing.</p>
<pre><code class="lang-perl">my $norm = normsig(\@audio)
p max(map { abs } @$norm) # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-spaces">
<h3><a class="doc-anchor" href="#doc-normalize-spaces">#</a> <code>normalize_spaces</code></h3>
<p><code>normalize_spaces</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = normalize_spaces $x
# or in a pipeline:
@list |> map normalize_spaces |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-vec">
<h3><a class="doc-anchor" href="#doc-normalize-vec">#</a> <code>normalize_vec</code></h3>
<p><code>normalize_vec</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = normalize_vec $x
# or in a pipeline:
@list |> map normalize_vec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-whitespace">
<h3><a class="doc-anchor" href="#doc-normalize-whitespace">#</a> <code>normalize_whitespace</code></h3>
<p><code>normalize_whitespace</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = normalize_whitespace $x
# or in a pipeline:
@list |> map normalize_whitespace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normarr">
<h3><a class="doc-anchor" href="#doc-normarr">#</a> <code>normarr</code></h3>
<p><code>normarr</code> — matrix operations (uncategorized batch) builtin. Alias for <code>normalize_array</code>.</p>
<pre><code class="lang-perl">my $result = normarr $x
# or in a pipeline:
@list |> map normarr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-not-any">
<h3><a class="doc-anchor" href="#doc-not-any">#</a> <code>not_any</code></h3>
<p><code>not_any</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = not_any $x
# or in a pipeline:
@list |> map not_any |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-not-each">
<h3><a class="doc-anchor" href="#doc-not-each">#</a> <code>not_each</code></h3>
<p><code>not_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = not_each $x
# or in a pipeline:
@list |> map not_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-not-elem">
<h3><a class="doc-anchor" href="#doc-not-elem">#</a> <code>not_elem</code></h3>
<p><code>not_elem</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = not_elem $x
# or in a pipeline:
@list |> map not_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-not-every">
<h3><a class="doc-anchor" href="#doc-not-every">#</a> <code>not_every</code></h3>
<p><code>not_every</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = not_every $x
# or in a pipeline:
@list |> map not_every |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-notall">
<h3><a class="doc-anchor" href="#doc-notall">#</a> <code>notall</code></h3>
<p><code>notall</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = notall $x
# or in a pipeline:
@list |> map notall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-notch-filter">
<h3><a class="doc-anchor" href="#doc-notch-filter">#</a> <code>notch_filter</code></h3>
<p><code>notch_filter</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = notch_filter $x
# or in a pipeline:
@list |> map notch_filter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-note-name-from-midi">
<h3><a class="doc-anchor" href="#doc-note-name-from-midi">#</a> <code>note_name_from_midi</code></h3>
<p><code>note_name_from_midi</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = note_name_from_midi $x
# or in a pipeline:
@list |> map note_name_from_midi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-note-name-to-midi">
<h3><a class="doc-anchor" href="#doc-note-name-to-midi">#</a> <code>note_name_to_midi</code></h3>
<p><code>note_name_to_midi</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = note_name_to_midi $input
</code></pre>
</article>
<article class="doc-entry" id="doc-now">
<h3><a class="doc-anchor" href="#doc-now">#</a> <code>now</code></h3>
<p><code>now</code> — Unix epoch seconds. Returns the current time as the number of seconds since <code>1970-01-01T00:00:00Z</code>, like Perl's <code>time()</code>. Pass a timezone string (e.g. <code>now("UTC")</code> or <code>now("America/New_York")</code>) to get an ISO-8601 datetime string in that zone instead — that path forwards to <code>datetime_now_tz</code>.</p>
<pre><code class="lang-perl">p now # 1778262882
p now("UTC") # 2026-05-08T17:54:42.577935Z
my $start = now
# ... do work ...
printf "elapsed: %d s\n", now - $start
</code></pre>
</article>
<article class="doc-entry" id="doc-now-ms">
<h3><a class="doc-anchor" href="#doc-now-ms">#</a> <code>now_ms</code></h3>
<p><code>now_ms</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = now_ms $x
# or in a pipeline:
@list |> map now_ms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-now-ns">
<h3><a class="doc-anchor" href="#doc-now-ns">#</a> <code>now_ns</code></h3>
<p><code>now_ns</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = now_ns $x
# or in a pipeline:
@list |> map now_ns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-now-us">
<h3><a class="doc-anchor" href="#doc-now-us">#</a> <code>now_us</code></h3>
<p><code>now_us</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = now_us $x
# or in a pipeline:
@list |> map now_us |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nper">
<h3><a class="doc-anchor" href="#doc-nper">#</a> <code>nper</code></h3>
<p><code>nper($rate, $pmt, $pv)</code> (alias <code>num_periods</code>) — computes the number of periods needed to pay off a loan given rate, payment, and principal.</p>
<pre><code class="lang-perl">p nper(0.05/12, 500, 50000) # ~127 months
</code></pre>
</article>
<article class="doc-entry" id="doc-npv">
<h3><a class="doc-anchor" href="#doc-npv">#</a> <code>npv</code></h3>
<p><code>npv</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = npv $x
# or in a pipeline:
@list |> map npv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nrmrng">
<h3><a class="doc-anchor" href="#doc-nrmrng">#</a> <code>nrmrng</code></h3>
<p><code>nrmrng</code> — matrix operations (uncategorized batch) builtin. Alias for <code>normalize_range</code>.</p>
<pre><code class="lang-perl">my $result = nrmrng $x
# or in a pipeline:
@list |> map nrmrng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nrmsp">
<h3><a class="doc-anchor" href="#doc-nrmsp">#</a> <code>nrmsp</code></h3>
<p><code>nrmsp</code> — extended stdlib builtin. Alias for <code>normalize_spaces</code>.</p>
<pre><code class="lang-perl">my $result = nrmsp $x
# or in a pipeline:
@list |> map nrmsp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nrmv">
<h3><a class="doc-anchor" href="#doc-nrmv">#</a> <code>nrmv</code></h3>
<p><code>nrmv</code> — extended stdlib builtin. Alias for <code>normalize_vec</code>.</p>
<pre><code class="lang-perl">my $result = nrmv $x
# or in a pipeline:
@list |> map nrmv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nroot">
<h3><a class="doc-anchor" href="#doc-nroot">#</a> <code>nroot</code></h3>
<p><code>nroot</code> — extended stdlib builtin. Alias for <code>nth_root_of</code>.</p>
<pre><code class="lang-perl">my $result = nroot $x
# or in a pipeline:
@list |> map nroot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nrow">
<h3><a class="doc-anchor" href="#doc-nrow">#</a> <code>nrow</code></h3>
<p><code>nrow</code> — number of rows in a matrix.</p>
<pre><code class="lang-perl">p nrow([[1,2],[3,4],[5,6]]) # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-ns-to-ms">
<h3><a class="doc-anchor" href="#doc-ns-to-ms">#</a> <code>ns_to_ms</code></h3>
<p><code>ns_to_ms</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ns_to_ms $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ns-to-us">
<h3><a class="doc-anchor" href="#doc-ns-to-us">#</a> <code>ns_to_us</code></h3>
<p><code>ns_to_us</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ns_to_us $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ntelm">
<h3><a class="doc-anchor" href="#doc-ntelm">#</a> <code>ntelm</code></h3>
<p><code>ntelm</code> — haskell list functions builtin. Alias for <code>not_elem</code>.</p>
<pre><code class="lang-perl">my $result = ntelm $x
# or in a pipeline:
@list |> map ntelm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-largest">
<h3><a class="doc-anchor" href="#doc-nth-largest">#</a> <code>nth_largest</code></h3>
<p><code>nth_largest</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = nth_largest $x
# or in a pipeline:
@list |> map nth_largest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-prime">
<h3><a class="doc-anchor" href="#doc-nth-prime">#</a> <code>nth_prime</code></h3>
<p><code>nth_prime</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = nth_prime $x
# or in a pipeline:
@list |> map nth_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-root">
<h3><a class="doc-anchor" href="#doc-nth-root">#</a> <code>nth_root</code></h3>
<p><code>nth_root</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = nth_root $x
# or in a pipeline:
@list |> map nth_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-root-of">
<h3><a class="doc-anchor" href="#doc-nth-root-of">#</a> <code>nth_root_of</code></h3>
<p><code>nth_root_of</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = nth_root_of $x
# or in a pipeline:
@list |> map nth_root_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-smallest">
<h3><a class="doc-anchor" href="#doc-nth-smallest">#</a> <code>nth_smallest</code></h3>
<p><code>nth_smallest</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = nth_smallest $x
# or in a pipeline:
@list |> map nth_smallest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-word">
<h3><a class="doc-anchor" href="#doc-nth-word">#</a> <code>nth_word</code></h3>
<p><code>nth_word</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = nth_word $x
# or in a pipeline:
@list |> map nth_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nthp">
<h3><a class="doc-anchor" href="#doc-nthp">#</a> <code>nthp</code></h3>
<p><code>nthp</code> — number theory / primes builtin. Alias for <code>nth_prime</code>.</p>
<pre><code class="lang-perl">my $result = nthp $x
# or in a pipeline:
@list |> map nthp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nub">
<h3><a class="doc-anchor" href="#doc-nub">#</a> <code>nub</code></h3>
<p><code>nub</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = nub $x
# or in a pipeline:
@list |> map nub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nub-by">
<h3><a class="doc-anchor" href="#doc-nub-by">#</a> <code>nub_by</code></h3>
<p><code>nub_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = nub_by $x
# or in a pipeline:
@list |> map nub_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nub-count">
<h3><a class="doc-anchor" href="#doc-nub-count">#</a> <code>nub_count</code></h3>
<p><code>nub_count</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = nub_count $x
# or in a pipeline:
@list |> map nub_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nub-list">
<h3><a class="doc-anchor" href="#doc-nub-list">#</a> <code>nub_list</code></h3>
<p><code>nub_list</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = nub_list $x
# or in a pipeline:
@list |> map nub_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nubb">
<h3><a class="doc-anchor" href="#doc-nubb">#</a> <code>nubb</code></h3>
<p><code>nubb</code> — additional missing stdlib functions builtin. Alias for <code>nub_by</code>.</p>
<pre><code class="lang-perl">my $result = nubb $x
# or in a pipeline:
@list |> map nubb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nuclear-magneton">
<h3><a class="doc-anchor" href="#doc-nuclear-magneton">#</a> <code>nuclear_magneton</code></h3>
<p><code>nuclear_magneton</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = nuclear_magneton $x
# or in a pipeline:
@list |> map nuclear_magneton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nucleation-rate-constant">
<h3><a class="doc-anchor" href="#doc-nucleation-rate-constant">#</a> <code>nucleation_rate_constant</code></h3>
<p><code>nucleation_rate_constant</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = nucleation_rate_constant $x
# or in a pipeline:
@list |> map nucleation_rate_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nucleolus-lp-step">
<h3><a class="doc-anchor" href="#doc-nucleolus-lp-step">#</a> <code>nucleolus_lp_step</code></h3>
<p><code>nucleolus_lp_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = nucleolus_lp_step $x
# or in a pipeline:
@list |> map nucleolus_lp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-num-cpus">
<h3><a class="doc-anchor" href="#doc-num-cpus">#</a> <code>num_cpus</code></h3>
<p><code>num_cpus</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = num_cpus $x
# or in a pipeline:
@list |> map num_cpus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-num-divisors">
<h3><a class="doc-anchor" href="#doc-num-divisors">#</a> <code>num_divisors</code></h3>
<p><code>num_divisors</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = num_divisors $x
# or in a pipeline:
@list |> map num_divisors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-num-edges">
<h3><a class="doc-anchor" href="#doc-num-edges">#</a> <code>num_edges</code></h3>
<p><code>num_edges</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = num_edges $x
# or in a pipeline:
@list |> map num_edges |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-num-unrooted-trees">
<h3><a class="doc-anchor" href="#doc-num-unrooted-trees">#</a> <code>num_unrooted_trees</code></h3>
<p><code>num_unrooted_trees</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = num_unrooted_trees $x
# or in a pipeline:
@list |> map num_unrooted_trees |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-number-needed-to-treat">
<h3><a class="doc-anchor" href="#doc-number-needed-to-treat">#</a> <code>number_needed_to_treat</code></h3>
<p><code>number_needed_to_treat</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = number_needed_to_treat $input
</code></pre>
</article>
<article class="doc-entry" id="doc-number-to-english">
<h3><a class="doc-anchor" href="#doc-number-to-english">#</a> <code>number_to_english</code></h3>
<p><code>number_to_english</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = number_to_english $input
</code></pre>
</article>
<article class="doc-entry" id="doc-numeric-count">
<h3><a class="doc-anchor" href="#doc-numeric-count">#</a> <code>numeric_count</code></h3>
<p><code>numeric_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = numeric_count $x
# or in a pipeline:
@list |> map numeric_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-numerical-jacobian-col">
<h3><a class="doc-anchor" href="#doc-numerical-jacobian-col">#</a> <code>numerical_jacobian_col</code></h3>
<p><code>numerical_jacobian_col</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = numerical_jacobian_col $x
# or in a pipeline:
@list |> map numerical_jacobian_col |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nusselt-dittus-boelter">
<h3><a class="doc-anchor" href="#doc-nusselt-dittus-boelter">#</a> <code>nusselt_dittus_boelter</code></h3>
<p><code>nusselt_dittus_boelter</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = nusselt_dittus_boelter $x
# or in a pipeline:
@list |> map nusselt_dittus_boelter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nusselt-full-number">
<h3><a class="doc-anchor" href="#doc-nusselt-full-number">#</a> <code>nusselt_full_number</code></h3>
<p><code>nusselt_full_number</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = nusselt_full_number $x
# or in a pipeline:
@list |> map nusselt_full_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nutation-iau2000a">
<h3><a class="doc-anchor" href="#doc-nutation-iau2000a">#</a> <code>nutation_iau2000a</code></h3>
<p><code>nutation_iau2000a</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = nutation_iau2000a $x
# or in a pipeline:
@list |> map nutation_iau2000a |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nuttall-w">
<h3><a class="doc-anchor" href="#doc-nuttall-w">#</a> <code>nuttall_w</code></h3>
<p><code>nuttall_w</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = nuttall_w $x
# or in a pipeline:
@list |> map nuttall_w |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nxtp">
<h3><a class="doc-anchor" href="#doc-nxtp">#</a> <code>nxtp</code></h3>
<p><code>nxtp</code> — number theory / primes builtin. Alias for <code>next_prime</code>.</p>
<pre><code class="lang-perl">my $result = nxtp $x
# or in a pipeline:
@list |> map nxtp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nxtperm">
<h3><a class="doc-anchor" href="#doc-nxtperm">#</a> <code>nxtperm</code></h3>
<p><code>nxtperm</code> — matrix operations (uncategorized batch) builtin. Alias for <code>next_permutation</code>.</p>
<pre><code class="lang-perl">my $result = nxtperm $x
# or in a pipeline:
@list |> map nxtperm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nyquist-encirclement">
<h3><a class="doc-anchor" href="#doc-nyquist-encirclement">#</a> <code>nyquist_encirclement</code></h3>
<p><code>nyquist_encirclement</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = nyquist_encirclement $x
# or in a pipeline:
@list |> map nyquist_encirclement |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nyquist-phase">
<h3><a class="doc-anchor" href="#doc-nyquist-phase">#</a> <code>nyquist_phase</code></h3>
<p><code>nyquist_phase</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = nyquist_phase $x
# or in a pipeline:
@list |> map nyquist_phase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nysiis-phonetic">
<h3><a class="doc-anchor" href="#doc-nysiis-phonetic">#</a> <code>nysiis_phonetic</code></h3>
<p><code>nysiis_phonetic</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = nysiis_phonetic $x
# or in a pipeline:
@list |> map nysiis_phonetic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oaconvolve-step">
<h3><a class="doc-anchor" href="#doc-oaconvolve-step">#</a> <code>oaconvolve_step</code></h3>
<p><code>oaconvolve_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = oaconvolve_step $x
# or in a pipeline:
@list |> map oaconvolve_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oat-hash">
<h3><a class="doc-anchor" href="#doc-oat-hash">#</a> <code>oat_hash</code></h3>
<p><code>oat_hash</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = oat_hash $x
# or in a pipeline:
@list |> map oat_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-encoding">
<h3><a class="doc-anchor" href="#doc-object-encoding">#</a> <code>object_encoding</code></h3>
<p><code>object_encoding</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = object_encoding $x
# or in a pipeline:
@list |> map object_encoding |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-entries">
<h3><a class="doc-anchor" href="#doc-object-entries">#</a> <code>object_entries</code></h3>
<p><code>object_entries</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = object_entries $x
# or in a pipeline:
@list |> map object_entries |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-from-entries">
<h3><a class="doc-anchor" href="#doc-object-from-entries">#</a> <code>object_from_entries</code></h3>
<p><code>object_from_entries</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = object_from_entries $x
# or in a pipeline:
@list |> map object_from_entries |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-keys">
<h3><a class="doc-anchor" href="#doc-object-keys">#</a> <code>object_keys</code></h3>
<p><code>object_keys</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = object_keys $x
# or in a pipeline:
@list |> map object_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-values">
<h3><a class="doc-anchor" href="#doc-object-values">#</a> <code>object_values</code></h3>
<p><code>object_values</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = object_values $x
# or in a pipeline:
@list |> map object_values |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oct-of">
<h3><a class="doc-anchor" href="#doc-oct-of">#</a> <code>oct_of</code></h3>
<p><code>oct_of</code> — base conversion builtin. Alias for <code>to_oct</code>.</p>
<pre><code class="lang-perl">my $result = oct_of $x
# or in a pipeline:
@list |> map oct_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-octahedral-number">
<h3><a class="doc-anchor" href="#doc-octahedral-number">#</a> <code>octahedral_number</code></h3>
<p><code>octahedral_number</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = octahedral_number $x
# or in a pipeline:
@list |> map octahedral_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ocv-lithium-ion-step">
<h3><a class="doc-anchor" href="#doc-ocv-lithium-ion-step">#</a> <code>ocv_lithium_ion_step</code></h3>
<p><code>ocv_lithium_ion_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = ocv_lithium_ion_step $x
# or in a pipeline:
@list |> map ocv_lithium_ion_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-odd">
<h3><a class="doc-anchor" href="#doc-odd">#</a> <code>odd</code></h3>
<p><code>odd</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = odd $x
# or in a pipeline:
@list |> map odd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-odddyield">
<h3><a class="doc-anchor" href="#doc-odddyield">#</a> <code>odddyield</code></h3>
<p><code>odddyield</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = odddyield $x
# or in a pipeline:
@list |> map odddyield |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-odds-ratio-2x2">
<h3><a class="doc-anchor" href="#doc-odds-ratio-2x2">#</a> <code>odds_ratio_2x2</code></h3>
<p><code>odds_ratio_2x2</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = odds_ratio_2x2 $x
# or in a pipeline:
@list |> map odds_ratio_2x2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ode45-step">
<h3><a class="doc-anchor" href="#doc-ode45-step">#</a> <code>ode45_step</code></h3>
<p><code>ode45_step</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = ode45_step $x
# or in a pipeline:
@list |> map ode45_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ode-lsoda">
<h3><a class="doc-anchor" href="#doc-ode-lsoda">#</a> <code>ode_lsoda</code></h3>
<p><code>ode_lsoda</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = ode_lsoda $x
# or in a pipeline:
@list |> map ode_lsoda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oents">
<h3><a class="doc-anchor" href="#doc-oents">#</a> <code>oents</code></h3>
<p><code>oents</code> — javascript array/object methods builtin. Alias for <code>object_entries</code>.</p>
<pre><code class="lang-perl">my $result = oents $x
# or in a pipeline:
@list |> map oents |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ofents">
<h3><a class="doc-anchor" href="#doc-ofents">#</a> <code>ofents</code></h3>
<p><code>ofents</code> — javascript array/object methods builtin. Alias for <code>object_from_entries</code>.</p>
<pre><code class="lang-perl">my $result = ofents $x
# or in a pipeline:
@list |> map ofents |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-off">
<h3><a class="doc-anchor" href="#doc-off">#</a> <code>off</code></h3>
<p><code>off</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = off $x
# or in a pipeline:
@list |> map off |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-offset">
<h3><a class="doc-anchor" href="#doc-offset">#</a> <code>offset</code></h3>
<p><code>offset</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = offset $x
# or in a pipeline:
@list |> map offset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-offset-each">
<h3><a class="doc-anchor" href="#doc-offset-each">#</a> <code>offset_each</code></h3>
<p><code>offset_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = offset_each $x
# or in a pipeline:
@list |> map offset_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ohm-voltage">
<h3><a class="doc-anchor" href="#doc-ohm-voltage">#</a> <code>ohm_voltage</code></h3>
<p><code>ohm_voltage</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = ohm_voltage $x
# or in a pipeline:
@list |> map ohm_voltage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ohms-law-i">
<h3><a class="doc-anchor" href="#doc-ohms-law-i">#</a> <code>ohms_law_i</code></h3>
<p><code>ohms_law_i</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = ohms_law_i $x
# or in a pipeline:
@list |> map ohms_law_i |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ohms-law-r">
<h3><a class="doc-anchor" href="#doc-ohms-law-r">#</a> <code>ohms_law_r</code></h3>
<p><code>ohms_law_r</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = ohms_law_r $x
# or in a pipeline:
@list |> map ohms_law_r |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ohms-law-v">
<h3><a class="doc-anchor" href="#doc-ohms-law-v">#</a> <code>ohms_law_v</code></h3>
<p><code>ohms_law_v</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = ohms_law_v $x
# or in a pipeline:
@list |> map ohms_law_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-okeys">
<h3><a class="doc-anchor" href="#doc-okeys">#</a> <code>okeys</code></h3>
<p><code>okeys</code> — javascript array/object methods builtin. Alias for <code>object_keys</code>.</p>
<pre><code class="lang-perl">my $result = okeys $x
# or in a pipeline:
@list |> map okeys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oklab-to-rgb">
<h3><a class="doc-anchor" href="#doc-oklab-to-rgb">#</a> <code>oklab_to_rgb</code></h3>
<p><code>oklab_to_rgb</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = oklab_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ols-adjusted-r2">
<h3><a class="doc-anchor" href="#doc-ols-adjusted-r2">#</a> <code>ols_adjusted_r2</code></h3>
<p><code>ols_adjusted_r2</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = ols_adjusted_r2 $x
# or in a pipeline:
@list |> map ols_adjusted_r2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ols-estimator">
<h3><a class="doc-anchor" href="#doc-ols-estimator">#</a> <code>ols_estimator</code></h3>
<p><code>ols_estimator</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = ols_estimator $x
# or in a pipeline:
@list |> map ols_estimator |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ols-r-squared">
<h3><a class="doc-anchor" href="#doc-ols-r-squared">#</a> <code>ols_r_squared</code></h3>
<p><code>ols_r_squared</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = ols_r_squared $x
# or in a pipeline:
@list |> map ols_r_squared |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ols-residual-variance">
<h3><a class="doc-anchor" href="#doc-ols-residual-variance">#</a> <code>ols_residual_variance</code></h3>
<p><code>ols_residual_variance</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = ols_residual_variance $x
# or in a pipeline:
@list |> map ols_residual_variance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-omega-equation-step">
<h3><a class="doc-anchor" href="#doc-omega-equation-step">#</a> <code>omega_equation_step</code></h3>
<p><code>omega_equation_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = omega_equation_step $x
# or in a pipeline:
@list |> map omega_equation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-omega-m-at-z">
<h3><a class="doc-anchor" href="#doc-omega-m-at-z">#</a> <code>omega_m_at_z</code></h3>
<p><code>omega_m_at_z</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = omega_m_at_z $x
# or in a pipeline:
@list |> map omega_m_at_z |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-omega-ratio">
<h3><a class="doc-anchor" href="#doc-omega-ratio">#</a> <code>omega_ratio</code></h3>
<p><code>omega_ratio</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = omega_ratio $x
# or in a pipeline:
@list |> map omega_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-omit">
<h3><a class="doc-anchor" href="#doc-omit">#</a> <code>omit</code></h3>
<p><code>omit</code> — hash ops (batch 2) builtin. Alias for <code>omit_keys</code>.</p>
<pre><code class="lang-perl">my $result = omit $x
# or in a pipeline:
@list |> map omit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-omit-keys">
<h3><a class="doc-anchor" href="#doc-omit-keys">#</a> <code>omit_keys</code></h3>
<p><code>omit_keys</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = omit_keys $x
# or in a pipeline:
@list |> map omit_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-omori-aftershock">
<h3><a class="doc-anchor" href="#doc-omori-aftershock">#</a> <code>omori_aftershock</code></h3>
<p><code>omori_aftershock</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = omori_aftershock $x
# or in a pipeline:
@list |> map omori_aftershock |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-one">
<h3><a class="doc-anchor" href="#doc-one">#</a> <code>one</code></h3>
<p><code>one</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = one $x
# or in a pipeline:
@list |> map one |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-one-hot">
<h3><a class="doc-anchor" href="#doc-one-hot">#</a> <code>one_hot</code></h3>
<p><code>one_hot</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = one_hot $x
# or in a pipeline:
@list |> map one_hot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ones">
<h3><a class="doc-anchor" href="#doc-ones">#</a> <code>ones</code></h3>
<p><code>ones</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = ones $x
# or in a pipeline:
@list |> map ones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ones-mat">
<h3><a class="doc-anchor" href="#doc-ones-mat">#</a> <code>ones_mat</code></h3>
<p><code>ones_mat</code> — matrix / linear algebra builtin. Alias for <code>ones_matrix</code>.</p>
<pre><code class="lang-perl">my $result = ones_mat $x
# or in a pipeline:
@list |> map ones_mat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ones-matrix">
<h3><a class="doc-anchor" href="#doc-ones-matrix">#</a> <code>ones_matrix</code></h3>
<p><code>ones_matrix</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = ones_matrix $x
# or in a pipeline:
@list |> map ones_matrix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-only-alnum">
<h3><a class="doc-anchor" href="#doc-only-alnum">#</a> <code>only_alnum</code></h3>
<p><code>only_alnum</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = only_alnum $x
# or in a pipeline:
@list |> map only_alnum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-only-alpha">
<h3><a class="doc-anchor" href="#doc-only-alpha">#</a> <code>only_alpha</code></h3>
<p><code>only_alpha</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = only_alpha $x
# or in a pipeline:
@list |> map only_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-only-ascii">
<h3><a class="doc-anchor" href="#doc-only-ascii">#</a> <code>only_ascii</code></h3>
<p><code>only_ascii</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = only_ascii $x
# or in a pipeline:
@list |> map only_ascii |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-only-digits">
<h3><a class="doc-anchor" href="#doc-only-digits">#</a> <code>only_digits</code></h3>
<p><code>only_digits</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = only_digits $x
# or in a pipeline:
@list |> map only_digits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-onsager-relation-two-species">
<h3><a class="doc-anchor" href="#doc-onsager-relation-two-species">#</a> <code>onsager_relation_two_species</code></h3>
<p><code>onsager_relation_two_species</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = onsager_relation_two_species $x
# or in a pipeline:
@list |> map onsager_relation_two_species |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-open-pipe-harmonic">
<h3><a class="doc-anchor" href="#doc-open-pipe-harmonic">#</a> <code>open_pipe_harmonic</code></h3>
<p><code>open_pipe_harmonic</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = open_pipe_harmonic $x
# or in a pipeline:
@list |> map open_pipe_harmonic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-operad-count-two">
<h3><a class="doc-anchor" href="#doc-operad-count-two">#</a> <code>operad_count_two</code></h3>
<p><code>operad_count_two</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = operad_count_two $x
# or in a pipeline:
@list |> map operad_count_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oppenheimer-volkoff-step">
<h3><a class="doc-anchor" href="#doc-oppenheimer-volkoff-step">#</a> <code>oppenheimer_volkoff_step</code></h3>
<p><code>oppenheimer_volkoff_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = oppenheimer_volkoff_step $x
# or in a pipeline:
@list |> map oppenheimer_volkoff_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ops-plus">
<h3><a class="doc-anchor" href="#doc-ops-plus">#</a> <code>ops_plus</code></h3>
<p><code>ops_plus</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = ops_plus $x
# or in a pipeline:
@list |> map ops_plus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-optical-flow-farneback">
<h3><a class="doc-anchor" href="#doc-optical-flow-farneback">#</a> <code>optical_flow_farneback</code></h3>
<p><code>optical_flow_farneback</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = optical_flow_farneback $x
# or in a pipeline:
@list |> map optical_flow_farneback |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-optical-flow-lk">
<h3><a class="doc-anchor" href="#doc-optical-flow-lk">#</a> <code>optical_flow_lk</code></h3>
<p><code>optical_flow_lk</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = optical_flow_lk $x
# or in a pipeline:
@list |> map optical_flow_lk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-optical-flow-lk-step">
<h3><a class="doc-anchor" href="#doc-optical-flow-lk-step">#</a> <code>optical_flow_lk_step</code></h3>
<p><code>optical_flow_lk_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = optical_flow_lk_step $x
# or in a pipeline:
@list |> map optical_flow_lk_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-optical-scalars-step">
<h3><a class="doc-anchor" href="#doc-optical-scalars-step">#</a> <code>optical_scalars_step</code></h3>
<p><code>optical_scalars_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = optical_scalars_step $x
# or in a pipeline:
@list |> map optical_scalars_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-or">
<h3><a class="doc-anchor" href="#doc-or">#</a> <code>or</code></h3>
<p><code>or</code> — control flow builtin.</p>
<pre><code class="lang-perl">my $result = or $x
# or in a pipeline:
@list |> map or |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-or-list">
<h3><a class="doc-anchor" href="#doc-or-list">#</a> <code>or_list</code></h3>
<p><code>or_list</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = or_list $x
# or in a pipeline:
@list |> map or_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-or-opt-delta">
<h3><a class="doc-anchor" href="#doc-or-opt-delta">#</a> <code>or_opt_delta</code></h3>
<p><code>or_opt_delta</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = or_opt_delta $x
# or in a pipeline:
@list |> map or_opt_delta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orb-keypoints">
<h3><a class="doc-anchor" href="#doc-orb-keypoints">#</a> <code>orb_keypoints</code></h3>
<p><code>orb_keypoints</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = orb_keypoints $x
# or in a pipeline:
@list |> map orb_keypoints |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orbit-eccentric-anomaly">
<h3><a class="doc-anchor" href="#doc-orbit-eccentric-anomaly">#</a> <code>orbit_eccentric_anomaly</code></h3>
<p><code>orbit_eccentric_anomaly</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = orbit_eccentric_anomaly $x
# or in a pipeline:
@list |> map orbit_eccentric_anomaly |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orbit-kepler3">
<h3><a class="doc-anchor" href="#doc-orbit-kepler3">#</a> <code>orbit_kepler3</code></h3>
<p><code>orbit_kepler3</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = orbit_kepler3 $x
# or in a pipeline:
@list |> map orbit_kepler3 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orbital-eccentricity">
<h3><a class="doc-anchor" href="#doc-orbital-eccentricity">#</a> <code>orbital_eccentricity</code></h3>
<p><code>orbital_eccentricity</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = orbital_eccentricity $x
# or in a pipeline:
@list |> map orbital_eccentricity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orbital-period">
<h3><a class="doc-anchor" href="#doc-orbital-period">#</a> <code>orbital_period</code></h3>
<p><code>orbital_period($mass, $radius)</code> (alias <code>orbper</code>) — period for circular orbit: T = 2π√(r³/GM). Returns seconds.</p>
<pre><code class="lang-perl">my $t = orbper # ~5560 s (ISS orbital period)
p $t / 60 # ~93 minutes
</code></pre>
</article>
<article class="doc-entry" id="doc-orbital-period-au">
<h3><a class="doc-anchor" href="#doc-orbital-period-au">#</a> <code>orbital_period_au</code></h3>
<p><code>orbital_period_au</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = orbital_period_au $x
# or in a pipeline:
@list |> map orbital_period_au |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orbital-velocity">
<h3><a class="doc-anchor" href="#doc-orbital-velocity">#</a> <code>orbital_velocity</code></h3>
<p><code>orbital_velocity($mass, $radius)</code> (alias <code>orbvel</code>) — velocity for circular orbit: v = √(GM/r). Defaults to LEO around Earth.</p>
<pre><code class="lang-perl">p orbvel # ~7672 m/s (ISS orbital speed)
</code></pre>
</article>
<article class="doc-entry" id="doc-ordered-probit-threshold">
<h3><a class="doc-anchor" href="#doc-ordered-probit-threshold">#</a> <code>ordered_probit_threshold</code></h3>
<p><code>ordered_probit_threshold</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = ordered_probit_threshold $x
# or in a pipeline:
@list |> map ordered_probit_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ordered-set">
<h3><a class="doc-anchor" href="#doc-ordered-set">#</a> <code>ordered_set</code></h3>
<p><code>ordered_set</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = ordered_set $x
# or in a pipeline:
@list |> map ordered_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ordinal-date">
<h3><a class="doc-anchor" href="#doc-ordinal-date">#</a> <code>ordinal_date</code></h3>
<p><code>ordinal_date</code> — batch 10 builtin. Alias for <code>iso_ordinal_date</code>.</p>
<pre><code class="lang-perl">my $result = ordinal_date $x
# or in a pipeline:
@list |> map ordinal_date |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ordinalize">
<h3><a class="doc-anchor" href="#doc-ordinalize">#</a> <code>ordinalize</code></h3>
<p><code>ordinalize</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = ordinalize $x
# or in a pipeline:
@list |> map ordinalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ordn">
<h3><a class="doc-anchor" href="#doc-ordn">#</a> <code>ordn</code></h3>
<p><code>ordn</code> — extended stdlib builtin. Alias for <code>ordinalize</code>.</p>
<pre><code class="lang-perl">my $result = ordn $x
# or in a pipeline:
@list |> map ordn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orifice-velocity">
<h3><a class="doc-anchor" href="#doc-orifice-velocity">#</a> <code>orifice_velocity</code></h3>
<p><code>orifice_velocity</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = orifice_velocity $x
# or in a pipeline:
@list |> map orifice_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orl">
<h3><a class="doc-anchor" href="#doc-orl">#</a> <code>orl</code></h3>
<p><code>orl</code> — additional missing stdlib functions builtin. Alias for <code>or_list</code>.</p>
<pre><code class="lang-perl">my $result = orl $x
# or in a pipeline:
@list |> map orl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orthogonalize-vectors">
<h3><a class="doc-anchor" href="#doc-orthogonalize-vectors">#</a> <code>orthogonalize_vectors</code></h3>
<p><code>orthogonalize_vectors</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = orthogonalize_vectors $x
# or in a pipeline:
@list |> map orthogonalize_vectors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-acpi-state-transition">
<h3><a class="doc-anchor" href="#doc-os-acpi-state-transition">#</a> <code>os_acpi_state_transition</code></h3>
<p><code>os_acpi_state_transition</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_acpi_state_transition $x
# or in a pipeline:
@list |> map os_acpi_state_transition |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-amd-pstate-target">
<h3><a class="doc-anchor" href="#doc-os-amd-pstate-target">#</a> <code>os_amd_pstate_target</code></h3>
<p><code>os_amd_pstate_target</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_amd_pstate_target $x
# or in a pipeline:
@list |> map os_amd_pstate_target |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-anticipation-window">
<h3><a class="doc-anchor" href="#doc-os-anticipation-window">#</a> <code>os_anticipation_window</code></h3>
<p><code>os_anticipation_window</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_anticipation_window $x
# or in a pipeline:
@list |> map os_anticipation_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-apic-irq-priority">
<h3><a class="doc-anchor" href="#doc-os-apic-irq-priority">#</a> <code>os_apic_irq_priority</code></h3>
<p><code>os_apic_irq_priority</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_apic_irq_priority $x
# or in a pipeline:
@list |> map os_apic_irq_priority |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-apparmor-profile-active">
<h3><a class="doc-anchor" href="#doc-os-apparmor-profile-active">#</a> <code>os_apparmor_profile_active</code></h3>
<p><code>os_apparmor_profile_active</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_apparmor_profile_active $x
# or in a pipeline:
@list |> map os_apparmor_profile_active |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-arch">
<h3><a class="doc-anchor" href="#doc-os-arch">#</a> <code>os_arch</code></h3>
<p><code>os_arch</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = os_arch $x
# or in a pipeline:
@list |> map os_arch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-audit-event-priority">
<h3><a class="doc-anchor" href="#doc-os-audit-event-priority">#</a> <code>os_audit_event_priority</code></h3>
<p><code>os_audit_event_priority</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_audit_event_priority $x
# or in a pipeline:
@list |> map os_audit_event_priority |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-battery-capacity-pct">
<h3><a class="doc-anchor" href="#doc-os-battery-capacity-pct">#</a> <code>os_battery_capacity_pct</code></h3>
<p><code>os_battery_capacity_pct</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_battery_capacity_pct $x
# or in a pipeline:
@list |> map os_battery_capacity_pct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-buddy-order-pick">
<h3><a class="doc-anchor" href="#doc-os-buddy-order-pick">#</a> <code>os_buddy_order_pick</code></h3>
<p><code>os_buddy_order_pick</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_buddy_order_pick $x
# or in a pipeline:
@list |> map os_buddy_order_pick |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-buffer-cache-pages">
<h3><a class="doc-anchor" href="#doc-os-buffer-cache-pages">#</a> <code>os_buffer_cache_pages</code></h3>
<p><code>os_buffer_cache_pages</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_buffer_cache_pages $x
# or in a pipeline:
@list |> map os_buffer_cache_pages |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-c-state-residency">
<h3><a class="doc-anchor" href="#doc-os-c-state-residency">#</a> <code>os_c_state_residency</code></h3>
<p><code>os_c_state_residency</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_c_state_residency $x
# or in a pipeline:
@list |> map os_c_state_residency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-capability-check">
<h3><a class="doc-anchor" href="#doc-os-capability-check">#</a> <code>os_capability_check</code></h3>
<p><code>os_capability_check</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_capability_check $x
# or in a pipeline:
@list |> map os_capability_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-cfs-load-balance-step">
<h3><a class="doc-anchor" href="#doc-os-cfs-load-balance-step">#</a> <code>os_cfs_load_balance_step</code></h3>
<p><code>os_cfs_load_balance_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_cfs_load_balance_step $x
# or in a pipeline:
@list |> map os_cfs_load_balance_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-cgroup-v1-count">
<h3><a class="doc-anchor" href="#doc-os-cgroup-v1-count">#</a> <code>os_cgroup_v1_count</code></h3>
<p><code>os_cgroup_v1_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_cgroup_v1_count $x
# or in a pipeline:
@list |> map os_cgroup_v1_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-cgroup-v2-count">
<h3><a class="doc-anchor" href="#doc-os-cgroup-v2-count">#</a> <code>os_cgroup_v2_count</code></h3>
<p><code>os_cgroup_v2_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_cgroup_v2_count $x
# or in a pipeline:
@list |> map os_cgroup_v2_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-compact-memory-step">
<h3><a class="doc-anchor" href="#doc-os-compact-memory-step">#</a> <code>os_compact_memory_step</code></h3>
<p><code>os_compact_memory_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_compact_memory_step $x
# or in a pipeline:
@list |> map os_compact_memory_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-completely-fair-vruntime">
<h3><a class="doc-anchor" href="#doc-os-completely-fair-vruntime">#</a> <code>os_completely_fair_vruntime</code></h3>
<p><code>os_completely_fair_vruntime</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_completely_fair_vruntime $x
# or in a pipeline:
@list |> map os_completely_fair_vruntime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-copy-on-write-check">
<h3><a class="doc-anchor" href="#doc-os-copy-on-write-check">#</a> <code>os_copy_on_write_check</code></h3>
<p><code>os_copy_on_write_check</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_copy_on_write_check $x
# or in a pipeline:
@list |> map os_copy_on_write_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-cpu-affinity-score">
<h3><a class="doc-anchor" href="#doc-os-cpu-affinity-score">#</a> <code>os_cpu_affinity_score</code></h3>
<p><code>os_cpu_affinity_score</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_cpu_affinity_score $x
# or in a pipeline:
@list |> map os_cpu_affinity_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-cpufreq-governor-step">
<h3><a class="doc-anchor" href="#doc-os-cpufreq-governor-step">#</a> <code>os_cpufreq_governor_step</code></h3>
<p><code>os_cpufreq_governor_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_cpufreq_governor_step $x
# or in a pipeline:
@list |> map os_cpufreq_governor_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-demand-paging-step">
<h3><a class="doc-anchor" href="#doc-os-demand-paging-step">#</a> <code>os_demand_paging_step</code></h3>
<p><code>os_demand_paging_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_demand_paging_step $x
# or in a pipeline:
@list |> map os_demand_paging_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-dirty-page-threshold">
<h3><a class="doc-anchor" href="#doc-os-dirty-page-threshold">#</a> <code>os_dirty_page_threshold</code></h3>
<p><code>os_dirty_page_threshold</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_dirty_page_threshold $x
# or in a pipeline:
@list |> map os_dirty_page_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-disk-rotational-lat">
<h3><a class="doc-anchor" href="#doc-os-disk-rotational-lat">#</a> <code>os_disk_rotational_lat</code></h3>
<p><code>os_disk_rotational_lat</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_disk_rotational_lat $x
# or in a pipeline:
@list |> map os_disk_rotational_lat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-disk-seek-time">
<h3><a class="doc-anchor" href="#doc-os-disk-seek-time">#</a> <code>os_disk_seek_time</code></h3>
<p><code>os_disk_seek_time</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_disk_seek_time $x
# or in a pipeline:
@list |> map os_disk_seek_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-disk-transfer-time">
<h3><a class="doc-anchor" href="#doc-os-disk-transfer-time">#</a> <code>os_disk_transfer_time</code></h3>
<p><code>os_disk_transfer_time</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_disk_transfer_time $x
# or in a pipeline:
@list |> map os_disk_transfer_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-dmesg-severity-level">
<h3><a class="doc-anchor" href="#doc-os-dmesg-severity-level">#</a> <code>os_dmesg_severity_level</code></h3>
<p><code>os_dmesg_severity_level</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_dmesg_severity_level $x
# or in a pipeline:
@list |> map os_dmesg_severity_level |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-dvfs-step">
<h3><a class="doc-anchor" href="#doc-os-dvfs-step">#</a> <code>os_dvfs_step</code></h3>
<p><code>os_dvfs_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_dvfs_step $x
# or in a pipeline:
@list |> map os_dvfs_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-eas-energy-estimate">
<h3><a class="doc-anchor" href="#doc-os-eas-energy-estimate">#</a> <code>os_eas_energy_estimate</code></h3>
<p><code>os_eas_energy_estimate</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_eas_energy_estimate $x
# or in a pipeline:
@list |> map os_eas_energy_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-eevdf-eligible">
<h3><a class="doc-anchor" href="#doc-os-eevdf-eligible">#</a> <code>os_eevdf_eligible</code></h3>
<p><code>os_eevdf_eligible</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_eevdf_eligible $x
# or in a pipeline:
@list |> map os_eevdf_eligible |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-elevator-step">
<h3><a class="doc-anchor" href="#doc-os-elevator-step">#</a> <code>os_elevator_step</code></h3>
<p><code>os_elevator_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_elevator_step $x
# or in a pipeline:
@list |> map os_elevator_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-epoll-ctl-count">
<h3><a class="doc-anchor" href="#doc-os-epoll-ctl-count">#</a> <code>os_epoll_ctl_count</code></h3>
<p><code>os_epoll_ctl_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_epoll_ctl_count $x
# or in a pipeline:
@list |> map os_epoll_ctl_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-family">
<h3><a class="doc-anchor" href="#doc-os-family">#</a> <code>os_family</code></h3>
<p><code>os_family</code> — OS family string: <code>"unix"</code> or <code>"windows"</code>. From <code>std::env::consts::FAMILY</code>.</p>
<pre><code class="lang-perl">p os_family # unix
die "unix only" unless os_family eq "unix"
</code></pre>
</article>
<article class="doc-entry" id="doc-os-file-max-value">
<h3><a class="doc-anchor" href="#doc-os-file-max-value">#</a> <code>os_file_max_value</code></h3>
<p><code>os_file_max_value</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_file_max_value $x
# or in a pipeline:
@list |> map os_file_max_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-frequency-scaling-step">
<h3><a class="doc-anchor" href="#doc-os-frequency-scaling-step">#</a> <code>os_frequency_scaling_step</code></h3>
<p><code>os_frequency_scaling_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_frequency_scaling_step $x
# or in a pipeline:
@list |> map os_frequency_scaling_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-huge-page-threshold">
<h3><a class="doc-anchor" href="#doc-os-huge-page-threshold">#</a> <code>os_huge_page_threshold</code></h3>
<p><code>os_huge_page_threshold</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_huge_page_threshold $x
# or in a pipeline:
@list |> map os_huge_page_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-idle-state-select">
<h3><a class="doc-anchor" href="#doc-os-idle-state-select">#</a> <code>os_idle_state_select</code></h3>
<p><code>os_idle_state_select</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_idle_state_select $x
# or in a pipeline:
@list |> map os_idle_state_select |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-inotify-event-count">
<h3><a class="doc-anchor" href="#doc-os-inotify-event-count">#</a> <code>os_inotify_event_count</code></h3>
<p><code>os_inotify_event_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_inotify_event_count $x
# or in a pipeline:
@list |> map os_inotify_event_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-inotify-max-watches">
<h3><a class="doc-anchor" href="#doc-os-inotify-max-watches">#</a> <code>os_inotify_max_watches</code></h3>
<p><code>os_inotify_max_watches</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_inotify_max_watches $x
# or in a pipeline:
@list |> map os_inotify_max_watches |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-intel-pstate-target">
<h3><a class="doc-anchor" href="#doc-os-intel-pstate-target">#</a> <code>os_intel_pstate_target</code></h3>
<p><code>os_intel_pstate_target</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_intel_pstate_target $x
# or in a pipeline:
@list |> map os_intel_pstate_target |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-io-scheduler-bfq-step">
<h3><a class="doc-anchor" href="#doc-os-io-scheduler-bfq-step">#</a> <code>os_io_scheduler_bfq_step</code></h3>
<p><code>os_io_scheduler_bfq_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_io_scheduler_bfq_step $x
# or in a pipeline:
@list |> map os_io_scheduler_bfq_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-io-scheduler-cfq-step">
<h3><a class="doc-anchor" href="#doc-os-io-scheduler-cfq-step">#</a> <code>os_io_scheduler_cfq_step</code></h3>
<p><code>os_io_scheduler_cfq_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_io_scheduler_cfq_step $x
# or in a pipeline:
@list |> map os_io_scheduler_cfq_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-io-scheduler-deadline">
<h3><a class="doc-anchor" href="#doc-os-io-scheduler-deadline">#</a> <code>os_io_scheduler_deadline</code></h3>
<p><code>os_io_scheduler_deadline</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_io_scheduler_deadline $x
# or in a pipeline:
@list |> map os_io_scheduler_deadline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-io-scheduler-kyber-step">
<h3><a class="doc-anchor" href="#doc-os-io-scheduler-kyber-step">#</a> <code>os_io_scheduler_kyber_step</code></h3>
<p><code>os_io_scheduler_kyber_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_io_scheduler_kyber_step $x
# or in a pipeline:
@list |> map os_io_scheduler_kyber_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-io-scheduler-mq-deadline">
<h3><a class="doc-anchor" href="#doc-os-io-scheduler-mq-deadline">#</a> <code>os_io_scheduler_mq_deadline</code></h3>
<p><code>os_io_scheduler_mq_deadline</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_io_scheduler_mq_deadline $x
# or in a pipeline:
@list |> map os_io_scheduler_mq_deadline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-io-scheduler-noop-step">
<h3><a class="doc-anchor" href="#doc-os-io-scheduler-noop-step">#</a> <code>os_io_scheduler_noop_step</code></h3>
<p><code>os_io_scheduler_noop_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_io_scheduler_noop_step $x
# or in a pipeline:
@list |> map os_io_scheduler_noop_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-io-uring-cqe-count">
<h3><a class="doc-anchor" href="#doc-os-io-uring-cqe-count">#</a> <code>os_io_uring_cqe_count</code></h3>
<p><code>os_io_uring_cqe_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_io_uring_cqe_count $x
# or in a pipeline:
@list |> map os_io_uring_cqe_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-io-uring-sqe-count">
<h3><a class="doc-anchor" href="#doc-os-io-uring-sqe-count">#</a> <code>os_io_uring_sqe_count</code></h3>
<p><code>os_io_uring_sqe_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_io_uring_sqe_count $x
# or in a pipeline:
@list |> map os_io_uring_sqe_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-iommu-domain-step">
<h3><a class="doc-anchor" href="#doc-os-iommu-domain-step">#</a> <code>os_iommu_domain_step</code></h3>
<p><code>os_iommu_domain_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_iommu_domain_step $x
# or in a pipeline:
@list |> map os_iommu_domain_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-kasan-shadow-offset">
<h3><a class="doc-anchor" href="#doc-os-kasan-shadow-offset">#</a> <code>os_kasan_shadow_offset</code></h3>
<p><code>os_kasan_shadow_offset</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_kasan_shadow_offset $x
# or in a pipeline:
@list |> map os_kasan_shadow_offset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-kfence-alloc-index">
<h3><a class="doc-anchor" href="#doc-os-kfence-alloc-index">#</a> <code>os_kfence_alloc_index</code></h3>
<p><code>os_kfence_alloc_index</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_kfence_alloc_index $x
# or in a pipeline:
@list |> map os_kfence_alloc_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-kfence-check">
<h3><a class="doc-anchor" href="#doc-os-kfence-check">#</a> <code>os_kfence_check</code></h3>
<p><code>os_kfence_check</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_kfence_check $x
# or in a pipeline:
@list |> map os_kfence_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-kqueue-event-count">
<h3><a class="doc-anchor" href="#doc-os-kqueue-event-count">#</a> <code>os_kqueue_event_count</code></h3>
<p><code>os_kqueue_event_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_kqueue_event_count $x
# or in a pipeline:
@list |> map os_kqueue_event_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-kswapd-wake-threshold">
<h3><a class="doc-anchor" href="#doc-os-kswapd-wake-threshold">#</a> <code>os_kswapd_wake_threshold</code></h3>
<p><code>os_kswapd_wake_threshold</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_kswapd_wake_threshold $x
# or in a pipeline:
@list |> map os_kswapd_wake_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-kvm-vmcs-field-offset">
<h3><a class="doc-anchor" href="#doc-os-kvm-vmcs-field-offset">#</a> <code>os_kvm_vmcs_field_offset</code></h3>
<p><code>os_kvm_vmcs_field_offset</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_kvm_vmcs_field_offset $x
# or in a pipeline:
@list |> map os_kvm_vmcs_field_offset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-load-average-decay">
<h3><a class="doc-anchor" href="#doc-os-load-average-decay">#</a> <code>os_load_average_decay</code></h3>
<p><code>os_load_average_decay</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_load_average_decay $x
# or in a pipeline:
@list |> map os_load_average_decay |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-load-iowait-avg">
<h3><a class="doc-anchor" href="#doc-os-load-iowait-avg">#</a> <code>os_load_iowait_avg</code></h3>
<p><code>os_load_iowait_avg</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_load_iowait_avg $x
# or in a pipeline:
@list |> map os_load_iowait_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-load-proc-avg">
<h3><a class="doc-anchor" href="#doc-os-load-proc-avg">#</a> <code>os_load_proc_avg</code></h3>
<p><code>os_load_proc_avg</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_load_proc_avg $x
# or in a pipeline:
@list |> map os_load_proc_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-load-user-avg">
<h3><a class="doc-anchor" href="#doc-os-load-user-avg">#</a> <code>os_load_user_avg</code></h3>
<p><code>os_load_user_avg</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_load_user_avg $x
# or in a pipeline:
@list |> map os_load_user_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-lottery-ticket-count">
<h3><a class="doc-anchor" href="#doc-os-lottery-ticket-count">#</a> <code>os_lottery_ticket_count</code></h3>
<p><code>os_lottery_ticket_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_lottery_ticket_count $x
# or in a pipeline:
@list |> map os_lottery_ticket_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-mlfq-demote-step">
<h3><a class="doc-anchor" href="#doc-os-mlfq-demote-step">#</a> <code>os_mlfq_demote_step</code></h3>
<p><code>os_mlfq_demote_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_mlfq_demote_step $x
# or in a pipeline:
@list |> map os_mlfq_demote_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-mlfq-promote-step">
<h3><a class="doc-anchor" href="#doc-os-mlfq-promote-step">#</a> <code>os_mlfq_promote_step</code></h3>
<p><code>os_mlfq_promote_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_mlfq_promote_step $x
# or in a pipeline:
@list |> map os_mlfq_promote_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-msi-x-vector-count">
<h3><a class="doc-anchor" href="#doc-os-msi-x-vector-count">#</a> <code>os_msi_x_vector_count</code></h3>
<p><code>os_msi_x_vector_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_msi_x_vector_count $x
# or in a pipeline:
@list |> map os_msi_x_vector_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-name">
<h3><a class="doc-anchor" href="#doc-os-name">#</a> <code>os_name</code></h3>
<p><code>os_name</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = os_name $x
# or in a pipeline:
@list |> map os_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-namespace-isolation">
<h3><a class="doc-anchor" href="#doc-os-namespace-isolation">#</a> <code>os_namespace_isolation</code></h3>
<p><code>os_namespace_isolation</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_namespace_isolation $x
# or in a pipeline:
@list |> map os_namespace_isolation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-numa-node-distance">
<h3><a class="doc-anchor" href="#doc-os-numa-node-distance">#</a> <code>os_numa_node_distance</code></h3>
<p><code>os_numa_node_distance</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_numa_node_distance $x
# or in a pipeline:
@list |> map os_numa_node_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-oom-kill-score">
<h3><a class="doc-anchor" href="#doc-os-oom-kill-score">#</a> <code>os_oom_kill_score</code></h3>
<p><code>os_oom_kill_score</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_oom_kill_score $x
# or in a pipeline:
@list |> map os_oom_kill_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-oom-score-step">
<h3><a class="doc-anchor" href="#doc-os-oom-score-step">#</a> <code>os_oom_score_step</code></h3>
<p><code>os_oom_score_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_oom_score_step $x
# or in a pipeline:
@list |> map os_oom_score_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-open-files-count">
<h3><a class="doc-anchor" href="#doc-os-open-files-count">#</a> <code>os_open_files_count</code></h3>
<p><code>os_open_files_count</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_open_files_count $x
# or in a pipeline:
@list |> map os_open_files_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-p-state-voltage">
<h3><a class="doc-anchor" href="#doc-os-p-state-voltage">#</a> <code>os_p_state_voltage</code></h3>
<p><code>os_p_state_voltage</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_p_state_voltage $x
# or in a pipeline:
@list |> map os_p_state_voltage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-page-replacement-2q">
<h3><a class="doc-anchor" href="#doc-os-page-replacement-2q">#</a> <code>os_page_replacement_2q</code></h3>
<p><code>os_page_replacement_2q</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_page_replacement_2q $x
# or in a pipeline:
@list |> map os_page_replacement_2q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-page-replacement-clock">
<h3><a class="doc-anchor" href="#doc-os-page-replacement-clock">#</a> <code>os_page_replacement_clock</code></h3>
<p><code>os_page_replacement_clock</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_page_replacement_clock $x
# or in a pipeline:
@list |> map os_page_replacement_clock |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-page-replacement-lru">
<h3><a class="doc-anchor" href="#doc-os-page-replacement-lru">#</a> <code>os_page_replacement_lru</code></h3>
<p><code>os_page_replacement_lru</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_page_replacement_lru $x
# or in a pipeline:
@list |> map os_page_replacement_lru |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-pci-bus-address">
<h3><a class="doc-anchor" href="#doc-os-pci-bus-address">#</a> <code>os_pci_bus_address</code></h3>
<p><code>os_pci_bus_address</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_pci_bus_address $x
# or in a pipeline:
@list |> map os_pci_bus_address |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-per-cpu-cache-size">
<h3><a class="doc-anchor" href="#doc-os-per-cpu-cache-size">#</a> <code>os_per_cpu_cache_size</code></h3>
<p><code>os_per_cpu_cache_size</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_per_cpu_cache_size $x
# or in a pipeline:
@list |> map os_per_cpu_cache_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-pid-max-value">
<h3><a class="doc-anchor" href="#doc-os-pid-max-value">#</a> <code>os_pid_max_value</code></h3>
<p><code>os_pid_max_value</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_pid_max_value $x
# or in a pipeline:
@list |> map os_pid_max_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-powertop-score">
<h3><a class="doc-anchor" href="#doc-os-powertop-score">#</a> <code>os_powertop_score</code></h3>
<p><code>os_powertop_score</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_powertop_score $x
# or in a pipeline:
@list |> map os_powertop_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-pre-fetch-window">
<h3><a class="doc-anchor" href="#doc-os-pre-fetch-window">#</a> <code>os_pre_fetch_window</code></h3>
<p><code>os_pre_fetch_window</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_pre_fetch_window $x
# or in a pipeline:
@list |> map os_pre_fetch_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-pressure-stall-step">
<h3><a class="doc-anchor" href="#doc-os-pressure-stall-step">#</a> <code>os_pressure_stall_step</code></h3>
<p><code>os_pressure_stall_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_pressure_stall_step $x
# or in a pipeline:
@list |> map os_pressure_stall_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-priority-aging-step">
<h3><a class="doc-anchor" href="#doc-os-priority-aging-step">#</a> <code>os_priority_aging_step</code></h3>
<p><code>os_priority_aging_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_priority_aging_step $x
# or in a pipeline:
@list |> map os_priority_aging_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-psi-avg10-step">
<h3><a class="doc-anchor" href="#doc-os-psi-avg10-step">#</a> <code>os_psi_avg10_step</code></h3>
<p><code>os_psi_avg10_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_psi_avg10_step $x
# or in a pipeline:
@list |> map os_psi_avg10_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-psi-avg300-step">
<h3><a class="doc-anchor" href="#doc-os-psi-avg300-step">#</a> <code>os_psi_avg300_step</code></h3>
<p><code>os_psi_avg300_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_psi_avg300_step $x
# or in a pipeline:
@list |> map os_psi_avg300_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-psi-avg60-step">
<h3><a class="doc-anchor" href="#doc-os-psi-avg60-step">#</a> <code>os_psi_avg60_step</code></h3>
<p><code>os_psi_avg60_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_psi_avg60_step $x
# or in a pipeline:
@list |> map os_psi_avg60_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-round-robin-quantum">
<h3><a class="doc-anchor" href="#doc-os-round-robin-quantum">#</a> <code>os_round_robin_quantum</code></h3>
<p><code>os_round_robin_quantum</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_round_robin_quantum $x
# or in a pipeline:
@list |> map os_round_robin_quantum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-runqueue-depth">
<h3><a class="doc-anchor" href="#doc-os-runqueue-depth">#</a> <code>os_runqueue_depth</code></h3>
<p><code>os_runqueue_depth</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_runqueue_depth $x
# or in a pipeline:
@list |> map os_runqueue_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-seccomp-filter-step">
<h3><a class="doc-anchor" href="#doc-os-seccomp-filter-step">#</a> <code>os_seccomp_filter_step</code></h3>
<p><code>os_seccomp_filter_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_seccomp_filter_step $x
# or in a pipeline:
@list |> map os_seccomp_filter_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-selinux-context-match">
<h3><a class="doc-anchor" href="#doc-os-selinux-context-match">#</a> <code>os_selinux_context_match</code></h3>
<p><code>os_selinux_context_match</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_selinux_context_match $x
# or in a pipeline:
@list |> map os_selinux_context_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-slab-color-offset">
<h3><a class="doc-anchor" href="#doc-os-slab-color-offset">#</a> <code>os_slab_color_offset</code></h3>
<p><code>os_slab_color_offset</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_slab_color_offset $x
# or in a pipeline:
@list |> map os_slab_color_offset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-slub-object-size-round">
<h3><a class="doc-anchor" href="#doc-os-slub-object-size-round">#</a> <code>os_slub_object_size_round</code></h3>
<p><code>os_slub_object_size_round</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_slub_object_size_round $x
# or in a pipeline:
@list |> map os_slub_object_size_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-smack-label-compare">
<h3><a class="doc-anchor" href="#doc-os-smack-label-compare">#</a> <code>os_smack_label_compare</code></h3>
<p><code>os_smack_label_compare</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_smack_label_compare $x
# or in a pipeline:
@list |> map os_smack_label_compare |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-smt-threading-share">
<h3><a class="doc-anchor" href="#doc-os-smt-threading-share">#</a> <code>os_smt_threading_share</code></h3>
<p><code>os_smt_threading_share</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_smt_threading_share $x
# or in a pipeline:
@list |> map os_smt_threading_share |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-socket-max-value">
<h3><a class="doc-anchor" href="#doc-os-socket-max-value">#</a> <code>os_socket_max_value</code></h3>
<p><code>os_socket_max_value</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_socket_max_value $x
# or in a pipeline:
@list |> map os_socket_max_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-stride-pass-step">
<h3><a class="doc-anchor" href="#doc-os-stride-pass-step">#</a> <code>os_stride_pass_step</code></h3>
<p><code>os_stride_pass_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_stride_pass_step $x
# or in a pipeline:
@list |> map os_stride_pass_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-swap-pressure-score">
<h3><a class="doc-anchor" href="#doc-os-swap-pressure-score">#</a> <code>os_swap_pressure_score</code></h3>
<p><code>os_swap_pressure_score</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_swap_pressure_score $x
# or in a pipeline:
@list |> map os_swap_pressure_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-swappiness-factor">
<h3><a class="doc-anchor" href="#doc-os-swappiness-factor">#</a> <code>os_swappiness_factor</code></h3>
<p><code>os_swappiness_factor</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_swappiness_factor $x
# or in a pipeline:
@list |> map os_swappiness_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-systemd-journal-size">
<h3><a class="doc-anchor" href="#doc-os-systemd-journal-size">#</a> <code>os_systemd_journal_size</code></h3>
<p><code>os_systemd_journal_size</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_systemd_journal_size $x
# or in a pipeline:
@list |> map os_systemd_journal_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-thermal-zone-trip">
<h3><a class="doc-anchor" href="#doc-os-thermal-zone-trip">#</a> <code>os_thermal_zone_trip</code></h3>
<p><code>os_thermal_zone_trip</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_thermal_zone_trip $x
# or in a pipeline:
@list |> map os_thermal_zone_trip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-thrashing-threshold">
<h3><a class="doc-anchor" href="#doc-os-thrashing-threshold">#</a> <code>os_thrashing_threshold</code></h3>
<p><code>os_thrashing_threshold</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_thrashing_threshold $x
# or in a pipeline:
@list |> map os_thrashing_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-thread-max-value">
<h3><a class="doc-anchor" href="#doc-os-thread-max-value">#</a> <code>os_thread_max_value</code></h3>
<p><code>os_thread_max_value</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_thread_max_value $x
# or in a pipeline:
@list |> map os_thread_max_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-thread-migration-cost">
<h3><a class="doc-anchor" href="#doc-os-thread-migration-cost">#</a> <code>os_thread_migration_cost</code></h3>
<p><code>os_thread_migration_cost</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_thread_migration_cost $x
# or in a pipeline:
@list |> map os_thread_migration_cost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-throttle-temperature">
<h3><a class="doc-anchor" href="#doc-os-throttle-temperature">#</a> <code>os_throttle_temperature</code></h3>
<p><code>os_throttle_temperature</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_throttle_temperature $x
# or in a pipeline:
@list |> map os_throttle_temperature |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-transparent-hugepage">
<h3><a class="doc-anchor" href="#doc-os-transparent-hugepage">#</a> <code>os_transparent_hugepage</code></h3>
<p><code>os_transparent_hugepage</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_transparent_hugepage $x
# or in a pipeline:
@list |> map os_transparent_hugepage |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-version">
<h3><a class="doc-anchor" href="#doc-os-version">#</a> <code>os_version</code></h3>
<p><code>os_version</code> — OS kernel version/release string from <code>uname</code>. Returns <code>undef</code> on non-unix.</p>
<pre><code class="lang-perl">p os_version # 25.4.0
p "kernel: " . os_version
</code></pre>
</article>
<article class="doc-entry" id="doc-os-voltage-scaling-step">
<h3><a class="doc-anchor" href="#doc-os-voltage-scaling-step">#</a> <code>os_voltage_scaling_step</code></h3>
<p><code>os_voltage_scaling_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_voltage_scaling_step $x
# or in a pipeline:
@list |> map os_voltage_scaling_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-working-set-size">
<h3><a class="doc-anchor" href="#doc-os-working-set-size">#</a> <code>os_working_set_size</code></h3>
<p><code>os_working_set_size</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_working_set_size $x
# or in a pipeline:
@list |> map os_working_set_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-writeback-step">
<h3><a class="doc-anchor" href="#doc-os-writeback-step">#</a> <code>os_writeback_step</code></h3>
<p><code>os_writeback_step</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_writeback_step $x
# or in a pipeline:
@list |> map os_writeback_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-zero-page-optimization">
<h3><a class="doc-anchor" href="#doc-os-zero-page-optimization">#</a> <code>os_zero_page_optimization</code></h3>
<p><code>os_zero_page_optimization</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_zero_page_optimization $x
# or in a pipeline:
@list |> map os_zero_page_optimization |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-zram-compress-ratio">
<h3><a class="doc-anchor" href="#doc-os-zram-compress-ratio">#</a> <code>os_zram_compress_ratio</code></h3>
<p><code>os_zram_compress_ratio</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_zram_compress_ratio $x
# or in a pipeline:
@list |> map os_zram_compress_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-zswap-compress-ratio">
<h3><a class="doc-anchor" href="#doc-os-zswap-compress-ratio">#</a> <code>os_zswap_compress_ratio</code></h3>
<p><code>os_zswap_compress_ratio</code> — batch 50 builtin.</p>
<pre><code class="lang-perl">my $result = os_zswap_compress_ratio $x
# or in a pipeline:
@list |> map os_zswap_compress_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-osmotic-coefficient-pitzer">
<h3><a class="doc-anchor" href="#doc-osmotic-coefficient-pitzer">#</a> <code>osmotic_coefficient_pitzer</code></h3>
<p><code>osmotic_coefficient_pitzer</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = osmotic_coefficient_pitzer $x
# or in a pipeline:
@list |> map osmotic_coefficient_pitzer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-osmotic-pressure">
<h3><a class="doc-anchor" href="#doc-osmotic-pressure">#</a> <code>osmotic_pressure</code></h3>
<p><code>osmotic_pressure</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = osmotic_pressure $x
# or in a pipeline:
@list |> map osmotic_pressure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-otto-efficiency">
<h3><a class="doc-anchor" href="#doc-otto-efficiency">#</a> <code>otto_efficiency</code></h3>
<p><code>otto_efficiency</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = otto_efficiency $input
</code></pre>
</article>
<article class="doc-entry" id="doc-oursync">
<h3><a class="doc-anchor" href="#doc-oursync">#</a> <code>oursync</code></h3>
<p>Package-global counterpart of <code>mysync</code>. Same <code>Arc<Mutex></code> backing, but the binding is keyed by the package-qualified stash name (<code>Pkg::x</code>) so all packages and parallel workers share one cell.</p>
<pre><code class="lang-perl">package Counter
oursync $total = 0
fn bump { $total++ }
package main
fan 10000 { Counter::bump() }
p $Counter::total # 10000
</code></pre>
<p>Use <code>oursync</code> for cross-package shared state; use <code>mysync</code> for lexically scoped shared state.</p>
</article>
<article class="doc-entry" id="doc-out-degree-directed">
<h3><a class="doc-anchor" href="#doc-out-degree-directed">#</a> <code>out_degree_directed</code></h3>
<p><code>out_degree_directed</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = out_degree_directed $x
# or in a pipeline:
@list |> map out_degree_directed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-outer">
<h3><a class="doc-anchor" href="#doc-outer">#</a> <code>outer</code></h3>
<p><code>outer</code> — outer product of two vectors. Returns matrix where M[i][j] = v1[i] * v2[j].</p>
<pre><code class="lang-perl">my $m = outer([1,2,3], [10,20]) # [[10,20],[20,40],[30,60]]
</code></pre>
</article>
<article class="doc-entry" id="doc-outlier-iqr-q">
<h3><a class="doc-anchor" href="#doc-outlier-iqr-q">#</a> <code>outlier_iqr_q</code></h3>
<p><code>outlier_iqr_q</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = outlier_iqr_q $x
# or in a pipeline:
@list |> map outlier_iqr_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-outliers">
<h3><a class="doc-anchor" href="#doc-outliers">#</a> <code>outliers</code></h3>
<p><code>outliers</code> — statistics (extended) builtin. Alias for <code>outliers_iqr</code>.</p>
<pre><code class="lang-perl">my $result = outliers $x
# or in a pipeline:
@list |> map outliers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-outliers-iqr">
<h3><a class="doc-anchor" href="#doc-outliers-iqr">#</a> <code>outliers_iqr</code></h3>
<p><code>outliers_iqr(@data)</code> — identifies outliers using the IQR method (1.5 × IQR beyond Q1/Q3). Returns an arrayref of outlier values. Standard approach for detecting unusual data points.</p>
<pre><code class="lang-perl">my @data = (1, 2, 3, 4, 5, 100)
my $out = outliers_iqr(@data)
p @$out # (100)
</code></pre>
</article>
<article class="doc-entry" id="doc-ovals">
<h3><a class="doc-anchor" href="#doc-ovals">#</a> <code>ovals</code></h3>
<p><code>ovals</code> — javascript array/object methods builtin. Alias for <code>object_values</code>.</p>
<pre><code class="lang-perl">my $result = ovals $x
# or in a pipeline:
@list |> map ovals |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overall-efficiency-pec">
<h3><a class="doc-anchor" href="#doc-overall-efficiency-pec">#</a> <code>overall_efficiency_pec</code></h3>
<p><code>overall_efficiency_pec</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = overall_efficiency_pec $x
# or in a pipeline:
@list |> map overall_efficiency_pec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overlap-coefficient">
<h3><a class="doc-anchor" href="#doc-overlap-coefficient">#</a> <code>overlap_coefficient</code></h3>
<p><code>overlap_coefficient</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = overlap_coefficient $x
# or in a pipeline:
@list |> map overlap_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overlapcoef">
<h3><a class="doc-anchor" href="#doc-overlapcoef">#</a> <code>overlapcoef</code></h3>
<p><code>overlapcoef</code> — extended stdlib batch 3 builtin. Alias for <code>overlap_coefficient</code>.</p>
<pre><code class="lang-perl">my $result = overlapcoef $x
# or in a pipeline:
@list |> map overlapcoef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overline">
<h3><a class="doc-anchor" href="#doc-overline">#</a> <code>overline</code></h3>
<p><code>overline</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = overline $x
# or in a pipeline:
@list |> map overline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overpotential-her">
<h3><a class="doc-anchor" href="#doc-overpotential-her">#</a> <code>overpotential_her</code></h3>
<p><code>overpotential_her</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = overpotential_her $x
# or in a pipeline:
@list |> map overpotential_her |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overpotential-oer">
<h3><a class="doc-anchor" href="#doc-overpotential-oer">#</a> <code>overpotential_oer</code></h3>
<p><code>overpotential_oer</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = overpotential_oer $x
# or in a pipeline:
@list |> map overpotential_oer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-owen-t">
<h3><a class="doc-anchor" href="#doc-owen-t">#</a> <code>owen_t</code></h3>
<p><code>owen_t</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = owen_t $x
# or in a pipeline:
@list |> map owen_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-owens-t">
<h3><a class="doc-anchor" href="#doc-owens-t">#</a> <code>owens_t</code></h3>
<p><code>owens_t</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = owens_t $x
# or in a pipeline:
@list |> map owens_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oxidation-number">
<h3><a class="doc-anchor" href="#doc-oxidation-number">#</a> <code>oxidation_number</code></h3>
<p><code>oxidation_number</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = oxidation_number $x
# or in a pipeline:
@list |> map oxidation_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oz-to-g">
<h3><a class="doc-anchor" href="#doc-oz-to-g">#</a> <code>oz_to_g</code></h3>
<p><code>oz_to_g</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = oz_to_g $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ozone-dobson-total">
<h3><a class="doc-anchor" href="#doc-ozone-dobson-total">#</a> <code>ozone_dobson_total</code></h3>
<p><code>ozone_dobson_total</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = ozone_dobson_total $x
# or in a pipeline:
@list |> map ozone_dobson_total |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ozsvath-szabo-tau">
<h3><a class="doc-anchor" href="#doc-ozsvath-szabo-tau">#</a> <code>ozsvath_szabo_tau</code></h3>
<p><code>ozsvath_szabo_tau</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = ozsvath_szabo_tau $x
# or in a pipeline:
@list |> map ozsvath_szabo_tau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pa-to-atm">
<h3><a class="doc-anchor" href="#doc-pa-to-atm">#</a> <code>pa_to_atm</code></h3>
<p><code>pa_to_atm</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = pa_to_atm $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pacf">
<h3><a class="doc-anchor" href="#doc-pacf">#</a> <code>pacf</code></h3>
<p><code>pacf_fn</code> (alias <code>pacf</code>) — partial autocorrelation function via Durbin-Levinson. Like R's pacf().</p>
<pre><code class="lang-perl">my @pa = @{pacf([1,3,2,4,3,5], 3)}
</code></pre>
</article>
<article class="doc-entry" id="doc-pacf-basis">
<h3><a class="doc-anchor" href="#doc-pacf-basis">#</a> <code>pacf_basis</code></h3>
<p><code>pacf_basis</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = pacf_basis $x
# or in a pipeline:
@list |> map pacf_basis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-packrat-parse-step">
<h3><a class="doc-anchor" href="#doc-packrat-parse-step">#</a> <code>packrat_parse_step</code></h3>
<p><code>packrat_parse_step</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = packrat_parse_step $x
# or in a pipeline:
@list |> map packrat_parse_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pad-left">
<h3><a class="doc-anchor" href="#doc-pad-left">#</a> <code>pad_left</code></h3>
<p><code>pad_left</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = pad_left $x
# or in a pipeline:
@list |> map pad_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pad-number">
<h3><a class="doc-anchor" href="#doc-pad-number">#</a> <code>pad_number</code></h3>
<p><code>pad_number</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = pad_number $x
# or in a pipeline:
@list |> map pad_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pad-right">
<h3><a class="doc-anchor" href="#doc-pad-right">#</a> <code>pad_right</code></h3>
<p><code>pad_right</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = pad_right $x
# or in a pipeline:
@list |> map pad_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-page-size">
<h3><a class="doc-anchor" href="#doc-page-size">#</a> <code>page_size</code></h3>
<p><code>page_size</code> — memory page size in bytes. Uses <code>sysconf(_SC_PAGESIZE)</code> on unix.</p>
<pre><code class="lang-perl">p page_size # 16384 (Apple Silicon)
p page_size # 4096 (x86_64)
</code></pre>
</article>
<article class="doc-entry" id="doc-pagerank-damped">
<h3><a class="doc-anchor" href="#doc-pagerank-damped">#</a> <code>pagerank_damped</code></h3>
<p><code>pagerank_damped</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = pagerank_damped $x
# or in a pipeline:
@list |> map pagerank_damped |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pagerank-iter">
<h3><a class="doc-anchor" href="#doc-pagerank-iter">#</a> <code>pagerank_iter</code></h3>
<p><code>pagerank_iter</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = pagerank_iter $x
# or in a pipeline:
@list |> map pagerank_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-paired-ttest">
<h3><a class="doc-anchor" href="#doc-paired-ttest">#</a> <code>paired_ttest</code></h3>
<p><code>paired_ttest</code> (alias <code>pairedt</code>) performs a paired t-test on two matched samples. Returns [t-statistic, degrees of freedom].</p>
<pre><code class="lang-perl">my ($t, $df) = @{pairedt([85,90,78], [88,92,80])}
</code></pre>
</article>
<article class="doc-entry" id="doc-pairs-from-hash">
<h3><a class="doc-anchor" href="#doc-pairs-from-hash">#</a> <code>pairs_from_hash</code></h3>
<p><code>pairs_from_hash</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = pairs_from_hash $x
# or in a pipeline:
@list |> map pairs_from_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pairwise">
<h3><a class="doc-anchor" href="#doc-pairwise">#</a> <code>pairwise</code></h3>
<p><code>pairwise</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = pairwise $x
# or in a pipeline:
@list |> map pairwise |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pairwise-iter">
<h3><a class="doc-anchor" href="#doc-pairwise-iter">#</a> <code>pairwise_iter</code></h3>
<p><code>pairwise_iter</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = pairwise_iter $x
# or in a pipeline:
@list |> map pairwise_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-palindromic-q">
<h3><a class="doc-anchor" href="#doc-palindromic-q">#</a> <code>palindromic_q</code></h3>
<p><code>palindromic_q</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = palindromic_q $x
# or in a pipeline:
@list |> map palindromic_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pall">
<h3><a class="doc-anchor" href="#doc-pall">#</a> <code>pall</code></h3>
<p><code>pall</code> — algebraic match builtin. Alias for <code>partition_all</code>.</p>
<pre><code class="lang-perl">my $result = pall $x
# or in a pipeline:
@list |> map pall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pam250-score">
<h3><a class="doc-anchor" href="#doc-pam250-score">#</a> <code>pam250_score</code></h3>
<p><code>pam250_score</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = pam250_score $x
# or in a pipeline:
@list |> map pam250_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-panel-between-estimator">
<h3><a class="doc-anchor" href="#doc-panel-between-estimator">#</a> <code>panel_between_estimator</code></h3>
<p><code>panel_between_estimator</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = panel_between_estimator $x
# or in a pipeline:
@list |> map panel_between_estimator |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-panel-random-effects">
<h3><a class="doc-anchor" href="#doc-panel-random-effects">#</a> <code>panel_random_effects</code></h3>
<p><code>panel_random_effects</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = panel_random_effects $x
# or in a pipeline:
@list |> map panel_random_effects |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-panel-var-step">
<h3><a class="doc-anchor" href="#doc-panel-var-step">#</a> <code>panel_var_step</code></h3>
<p><code>panel_var_step</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = panel_var_step $x
# or in a pipeline:
@list |> map panel_var_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-panel-within-estimator">
<h3><a class="doc-anchor" href="#doc-panel-within-estimator">#</a> <code>panel_within_estimator</code></h3>
<p><code>panel_within_estimator</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = panel_within_estimator $x
# or in a pipeline:
@list |> map panel_within_estimator |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parabolic-d0">
<h3><a class="doc-anchor" href="#doc-parabolic-d0">#</a> <code>parabolic_d0</code></h3>
<p><code>parabolic_d0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = parabolic_d0 $x
# or in a pipeline:
@list |> map parabolic_d0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parabolic-d1">
<h3><a class="doc-anchor" href="#doc-parabolic-d1">#</a> <code>parabolic_d1</code></h3>
<p><code>parabolic_d1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = parabolic_d1 $x
# or in a pipeline:
@list |> map parabolic_d1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parallax-correction">
<h3><a class="doc-anchor" href="#doc-parallax-correction">#</a> <code>parallax_correction</code></h3>
<p><code>parallax_correction</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = parallax_correction $x
# or in a pipeline:
@list |> map parallax_correction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parallel-machine-lpt">
<h3><a class="doc-anchor" href="#doc-parallel-machine-lpt">#</a> <code>parallel_machine_lpt</code></h3>
<p><code>parallel_machine_lpt</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = parallel_machine_lpt $x
# or in a pipeline:
@list |> map parallel_machine_lpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parallel-machine-spt">
<h3><a class="doc-anchor" href="#doc-parallel-machine-spt">#</a> <code>parallel_machine_spt</code></h3>
<p><code>parallel_machine_spt</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = parallel_machine_spt $x
# or in a pipeline:
@list |> map parallel_machine_spt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parallel-transport-step">
<h3><a class="doc-anchor" href="#doc-parallel-transport-step">#</a> <code>parallel_transport_step</code></h3>
<p><code>parallel_transport_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = parallel_transport_step $x
# or in a pipeline:
@list |> map parallel_transport_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parenthesize">
<h3><a class="doc-anchor" href="#doc-parenthesize">#</a> <code>parenthesize</code></h3>
<p><code>parenthesize</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = parenthesize $x
# or in a pipeline:
@list |> map parenthesize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pareto-dominance">
<h3><a class="doc-anchor" href="#doc-pareto-dominance">#</a> <code>pareto_dominance</code></h3>
<p><code>pareto_dominance</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = pareto_dominance $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pareto-efficiency">
<h3><a class="doc-anchor" href="#doc-pareto-efficiency">#</a> <code>pareto_efficiency</code></h3>
<p><code>pareto_efficiency</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = pareto_efficiency $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pareto-pdf">
<h3><a class="doc-anchor" href="#doc-pareto-pdf">#</a> <code>pareto_pdf</code></h3>
<p><code>pareto_pdf</code> (alias <code>paretopdf</code>) evaluates the Pareto distribution PDF at x with minimum xm and shape alpha.</p>
<pre><code class="lang-perl">p paretopdf(2, 1, 3) # Pareto(1,3) at x=2
</code></pre>
</article>
<article class="doc-entry" id="doc-parse-bool">
<h3><a class="doc-anchor" href="#doc-parse-bool">#</a> <code>parse_bool</code></h3>
<p><code>parse_bool</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = parse_bool $x
# or in a pipeline:
@list |> map parse_bool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parse-float">
<h3><a class="doc-anchor" href="#doc-parse-float">#</a> <code>parse_float</code></h3>
<p><code>parse_float</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = parse_float $x
# or in a pipeline:
@list |> map parse_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parse-int">
<h3><a class="doc-anchor" href="#doc-parse-int">#</a> <code>parse_int</code></h3>
<p><code>parse_int</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = parse_int $x
# or in a pipeline:
@list |> map parse_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partial-pressure">
<h3><a class="doc-anchor" href="#doc-partial-pressure">#</a> <code>partial_pressure</code></h3>
<p><code>partial_pressure</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = partial_pressure $x
# or in a pipeline:
@list |> map partial_pressure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-particle-filter-resample">
<h3><a class="doc-anchor" href="#doc-particle-filter-resample">#</a> <code>particle_filter_resample</code></h3>
<p><code>particle_filter_resample</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = particle_filter_resample $x
# or in a pipeline:
@list |> map particle_filter_resample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-all">
<h3><a class="doc-anchor" href="#doc-partition-all">#</a> <code>partition_all</code></h3>
<p><code>partition_all</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = partition_all $x
# or in a pipeline:
@list |> map partition_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-at">
<h3><a class="doc-anchor" href="#doc-partition-at">#</a> <code>partition_at</code></h3>
<p><code>partition_at</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = partition_at $x
# or in a pipeline:
@list |> map partition_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-by">
<h3><a class="doc-anchor" href="#doc-partition-by">#</a> <code>partition_by</code></h3>
<p><code>partition_by</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = partition_by $x
# or in a pipeline:
@list |> map partition_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-either">
<h3><a class="doc-anchor" href="#doc-partition-either">#</a> <code>partition_either</code></h3>
<p><code>partition_either</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = partition_either $x
# or in a pipeline:
@list |> map partition_either |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-n">
<h3><a class="doc-anchor" href="#doc-partition-n">#</a> <code>partition_n</code></h3>
<p><code>partition_n</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = partition_n $x
# or in a pipeline:
@list |> map partition_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-number">
<h3><a class="doc-anchor" href="#doc-partition-number">#</a> <code>partition_number</code></h3>
<p><code>partition_number</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = partition_number $x
# or in a pipeline:
@list |> map partition_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-point">
<h3><a class="doc-anchor" href="#doc-partition-point">#</a> <code>partition_point</code></h3>
<p><code>partition_point</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = partition_point $x
# or in a pipeline:
@list |> map partition_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-two">
<h3><a class="doc-anchor" href="#doc-partition-two">#</a> <code>partition_two</code></h3>
<p><code>partition_two</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = partition_two $x
# or in a pipeline:
@list |> map partition_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partn">
<h3><a class="doc-anchor" href="#doc-partn">#</a> <code>partn</code></h3>
<p><code>partn</code> — go/general functional utilities builtin. Alias for <code>partition_n</code>.</p>
<pre><code class="lang-perl">my $result = partn $x
# or in a pipeline:
@list |> map partn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partn-num">
<h3><a class="doc-anchor" href="#doc-partn-num">#</a> <code>partn_num</code></h3>
<p><code>partn_num</code> — math / numeric (uncategorized batch) builtin. Alias for <code>partition_number</code>.</p>
<pre><code class="lang-perl">my $result = partn_num $x
# or in a pipeline:
@list |> map partn_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parzen-window">
<h3><a class="doc-anchor" href="#doc-parzen-window">#</a> <code>parzen_window</code></h3>
<p><code>parzen_window</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = parzen_window $x
# or in a pipeline:
@list |> map parzen_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pascal-case">
<h3><a class="doc-anchor" href="#doc-pascal-case">#</a> <code>pascal_case</code></h3>
<p><code>pascal_case</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = pascal_case $x
# or in a pipeline:
@list |> map pascal_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pascal-row">
<h3><a class="doc-anchor" href="#doc-pascal-row">#</a> <code>pascal_row</code></h3>
<p><code>pascal_row</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = pascal_row $x
# or in a pipeline:
@list |> map pascal_row |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pascals-to-bar">
<h3><a class="doc-anchor" href="#doc-pascals-to-bar">#</a> <code>pascals_to_bar</code></h3>
<p><code>pascals_to_bar</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = pascals_to_bar $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pascals-to-psi">
<h3><a class="doc-anchor" href="#doc-pascals-to-psi">#</a> <code>pascals_to_psi</code></h3>
<p><code>pascals_to_psi</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = pascals_to_psi $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pascals-triangle">
<h3><a class="doc-anchor" href="#doc-pascals-triangle">#</a> <code>pascals_triangle</code></h3>
<p><code>pascals_triangle</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = pascals_triangle $x
# or in a pipeline:
@list |> map pascals_triangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pascrow">
<h3><a class="doc-anchor" href="#doc-pascrow">#</a> <code>pascrow</code></h3>
<p><code>pascrow</code> — extended stdlib batch 3 builtin. Alias for <code>pascal_row</code>.</p>
<pre><code class="lang-perl">my $result = pascrow $x
# or in a pipeline:
@list |> map pascrow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pasctri">
<h3><a class="doc-anchor" href="#doc-pasctri">#</a> <code>pasctri</code></h3>
<p><code>pasctri</code> — math / numeric (uncategorized batch) builtin. Alias for <code>pascals_triangle</code>.</p>
<pre><code class="lang-perl">my $result = pasctri $x
# or in a pipeline:
@list |> map pasctri |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pass">
<h3><a class="doc-anchor" href="#doc-pass">#</a> <code>pass</code></h3>
<p><code>pass</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = pass $x
# or in a pipeline:
@list |> map pass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-case">
<h3><a class="doc-anchor" href="#doc-path-case">#</a> <code>path_case</code></h3>
<p><code>path_case</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = path_case $x
# or in a pipeline:
@list |> map path_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-dubins-lsl">
<h3><a class="doc-anchor" href="#doc-path-dubins-lsl">#</a> <code>path_dubins_lsl</code></h3>
<p><code>path_dubins_lsl</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = path_dubins_lsl $x
# or in a pipeline:
@list |> map path_dubins_lsl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-dubins-rsr">
<h3><a class="doc-anchor" href="#doc-path-dubins-rsr">#</a> <code>path_dubins_rsr</code></h3>
<p><code>path_dubins_rsr</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = path_dubins_rsr $x
# or in a pipeline:
@list |> map path_dubins_rsr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-ext">
<h3><a class="doc-anchor" href="#doc-path-ext">#</a> <code>path_ext</code></h3>
<p><code>path_ext</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_ext $x
# or in a pipeline:
@list |> map path_ext |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-is-abs">
<h3><a class="doc-anchor" href="#doc-path-is-abs">#</a> <code>path_is_abs</code></h3>
<p><code>path_is_abs</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = path_is_abs $x
# or in a pipeline:
@list |> map path_is_abs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-is-rel">
<h3><a class="doc-anchor" href="#doc-path-is-rel">#</a> <code>path_is_rel</code></h3>
<p><code>path_is_rel</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = path_is_rel $x
# or in a pipeline:
@list |> map path_is_rel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-join">
<h3><a class="doc-anchor" href="#doc-path-join">#</a> <code>path_join</code></h3>
<p><code>path_join</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_join $x
# or in a pipeline:
@list |> map path_join |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-parent">
<h3><a class="doc-anchor" href="#doc-path-parent">#</a> <code>path_parent</code></h3>
<p><code>path_parent</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_parent $x
# or in a pipeline:
@list |> map path_parent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-reeds-shepp">
<h3><a class="doc-anchor" href="#doc-path-reeds-shepp">#</a> <code>path_reeds_shepp</code></h3>
<p><code>path_reeds_shepp</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = path_reeds_shepp $x
# or in a pipeline:
@list |> map path_reeds_shepp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-split">
<h3><a class="doc-anchor" href="#doc-path-split">#</a> <code>path_split</code></h3>
<p><code>path_split</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_split $x
# or in a pipeline:
@list |> map path_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-stem">
<h3><a class="doc-anchor" href="#doc-path-stem">#</a> <code>path_stem</code></h3>
<p><code>path_stem</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_stem $x
# or in a pipeline:
@list |> map path_stem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pauli-decomposition-2x2">
<h3><a class="doc-anchor" href="#doc-pauli-decomposition-2x2">#</a> <code>pauli_decomposition_2x2</code></h3>
<p><code>pauli_decomposition_2x2</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = pauli_decomposition_2x2 $x
# or in a pipeline:
@list |> map pauli_decomposition_2x2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pauli-real-part">
<h3><a class="doc-anchor" href="#doc-pauli-real-part">#</a> <code>pauli_real_part</code></h3>
<p><code>pauli_real_part</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = pauli_real_part $x
# or in a pipeline:
@list |> map pauli_real_part |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pauli-string-expect">
<h3><a class="doc-anchor" href="#doc-pauli-string-expect">#</a> <code>pauli_string_expect</code></h3>
<p><code>pauli_string_expect</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = pauli_string_expect $x
# or in a pipeline:
@list |> map pauli_string_expect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pauli-y-imag">
<h3><a class="doc-anchor" href="#doc-pauli-y-imag">#</a> <code>pauli_y_imag</code></h3>
<p><code>pauli_y_imag</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = pauli_y_imag $x
# or in a pipeline:
@list |> map pauli_y_imag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-payback">
<h3><a class="doc-anchor" href="#doc-payback">#</a> <code>payback</code></h3>
<p><code>payback_period($initial, @cashflows)</code> (alias <code>payback</code>) — computes the number of periods to recover initial investment. Returns fractional periods.</p>
<pre><code class="lang-perl">p payback(1000, 300, 400, 500) # 2.6 periods
</code></pre>
</article>
<article class="doc-entry" id="doc-payback-period-simple">
<h3><a class="doc-anchor" href="#doc-payback-period-simple">#</a> <code>payback_period_simple</code></h3>
<p><code>payback_period_simple</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = payback_period_simple $x
# or in a pipeline:
@list |> map payback_period_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-payback-simple">
<h3><a class="doc-anchor" href="#doc-payback-simple">#</a> <code>payback_simple</code></h3>
<p><code>payback_simple</code> — batch 10 builtin. Alias for <code>payback_period_simple</code>.</p>
<pre><code class="lang-perl">my $result = payback_simple $x
# or in a pipeline:
@list |> map payback_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pbeta">
<h3><a class="doc-anchor" href="#doc-pbeta">#</a> <code>pbeta</code></h3>
<p><code>pbeta</code> — beta CDF (regularized incomplete beta). Args: x, a, b.</p>
<pre><code class="lang-perl">p pbeta(0.5, 2, 5) # P(X ≤ 0.5) for Beta(2,5)
</code></pre>
</article>
<article class="doc-entry" id="doc-pbinom">
<h3><a class="doc-anchor" href="#doc-pbinom">#</a> <code>pbinom</code></h3>
<p><code>pbinom</code> — binomial CDF. P(X ≤ k) for Binom(n, p). Args: k, n, p.</p>
<pre><code class="lang-perl">p pbinom(5, 10, 0.5) # P(≤5 heads in 10 flips)
</code></pre>
</article>
<article class="doc-entry" id="doc-pbkdf2-hmac-step">
<h3><a class="doc-anchor" href="#doc-pbkdf2-hmac-step">#</a> <code>pbkdf2_hmac_step</code></h3>
<p><code>pbkdf2_hmac_step</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = pbkdf2_hmac_step $x
# or in a pipeline:
@list |> map pbkdf2_hmac_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pbool">
<h3><a class="doc-anchor" href="#doc-pbool">#</a> <code>pbool</code></h3>
<p><code>pbool</code> — extended stdlib builtin. Alias for <code>parse_bool</code>.</p>
<pre><code class="lang-perl">my $result = pbool $x
# or in a pipeline:
@list |> map pbool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pby">
<h3><a class="doc-anchor" href="#doc-pby">#</a> <code>pby</code></h3>
<p><code>pby</code> — algebraic match builtin. Alias for <code>partition_by</code>.</p>
<pre><code class="lang-perl">my $result = pby $x
# or in a pipeline:
@list |> map pby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pc-case">
<h3><a class="doc-anchor" href="#doc-pc-case">#</a> <code>pc_case</code></h3>
<p><code>pc_case</code> — string (batch 2) builtin. Alias for <code>pascal_case</code>.</p>
<pre><code class="lang-perl">my $result = pc_case $x
# or in a pipeline:
@list |> map pc_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pc-to-au">
<h3><a class="doc-anchor" href="#doc-pc-to-au">#</a> <code>pc_to_au</code></h3>
<p><code>pc_to_au</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = pc_to_au $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pc-to-ly">
<h3><a class="doc-anchor" href="#doc-pc-to-ly">#</a> <code>pc_to_ly</code></h3>
<p><code>pc_to_ly</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = pc_to_ly $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pca">
<h3><a class="doc-anchor" href="#doc-pca">#</a> <code>pca</code></h3>
<p><code>prcomp</code> (alias <code>pca</code>) — Principal Component Analysis via eigendecomposition of covariance matrix. Returns eigenvalues (variance explained). Like R's prcomp().</p>
<pre><code class="lang-perl">my @var = @{pca([[1,2],[3,4],[5,6],[7,8]])}
# variance explained by each component
</code></pre>
</article>
<article class="doc-entry" id="doc-pcauchy">
<h3><a class="doc-anchor" href="#doc-pcauchy">#</a> <code>pcauchy</code></h3>
<p><code>pcauchy</code> — Cauchy CDF. P(X ≤ x). Args: x [, location, scale].</p>
<pre><code class="lang-perl">p pcauchy(0, 0, 1) # 0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-pcg32-step">
<h3><a class="doc-anchor" href="#doc-pcg32-step">#</a> <code>pcg32_step</code></h3>
<p><code>pcg32_step</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = pcg32_step $x
# or in a pipeline:
@list |> map pcg32_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pchisq">
<h3><a class="doc-anchor" href="#doc-pchisq">#</a> <code>pchisq</code></h3>
<p><code>pchisq</code> — chi-squared CDF. Args: x, df.</p>
<pre><code class="lang-perl">p pchisq(3.84, 1) # 0.95 (critical value for p=0.05)
</code></pre>
</article>
<article class="doc-entry" id="doc-pcr">
<h3><a class="doc-anchor" href="#doc-pcr">#</a> <code>pcr</code></h3>
<p><code>pcr</code> — data / network builtin. Alias for <code>par_csv_read</code>.</p>
<pre><code class="lang-perl">my $result = pcr $x
# or in a pipeline:
@list |> map pcr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pct">
<h3><a class="doc-anchor" href="#doc-pct">#</a> <code>pct</code></h3>
<p><code>pct</code> — trivial numeric / predicate builtins builtin. Alias for <code>percent</code>.</p>
<pre><code class="lang-perl">my $result = pct $x
# or in a pipeline:
@list |> map pct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pctrank">
<h3><a class="doc-anchor" href="#doc-pctrank">#</a> <code>pctrank</code></h3>
<p><code>pctrank</code> — statistics (extended) builtin. Alias for <code>percentile_rank</code>.</p>
<pre><code class="lang-perl">my $result = pctrank $x
# or in a pipeline:
@list |> map pctrank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pdo-index-step">
<h3><a class="doc-anchor" href="#doc-pdo-index-step">#</a> <code>pdo_index_step</code></h3>
<p><code>pdo_index_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = pdo_index_step $x
# or in a pipeline:
@list |> map pdo_index_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peak-detect">
<h3><a class="doc-anchor" href="#doc-peak-detect">#</a> <code>peak_detect</code></h3>
<p><code>peak_detect</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = peak_detect $x
# or in a pipeline:
@list |> map peak_detect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peak-widths-at">
<h3><a class="doc-anchor" href="#doc-peak-widths-at">#</a> <code>peak_widths_at</code></h3>
<p><code>peak_widths_at</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = peak_widths_at $x
# or in a pipeline:
@list |> map peak_widths_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peaks">
<h3><a class="doc-anchor" href="#doc-peaks">#</a> <code>peaks</code></h3>
<p><code>peaks</code> — matrix operations (uncategorized batch) builtin. Alias for <code>peak_detect</code>.</p>
<pre><code class="lang-perl">my $result = peaks $x
# or in a pipeline:
@list |> map peaks |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pearson-hash">
<h3><a class="doc-anchor" href="#doc-pearson-hash">#</a> <code>pearson_hash</code></h3>
<p><code>pearson_hash</code> — batch 9 builtin. Alias for <code>pearson_hash_byte</code>.</p>
<pre><code class="lang-perl">my $result = pearson_hash $x
# or in a pipeline:
@list |> map pearson_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pearson-hash-byte">
<h3><a class="doc-anchor" href="#doc-pearson-hash-byte">#</a> <code>pearson_hash_byte</code></h3>
<p><code>pearson_hash_byte</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = pearson_hash_byte $x
# or in a pipeline:
@list |> map pearson_hash_byte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pearson-skewness-2">
<h3><a class="doc-anchor" href="#doc-pearson-skewness-2">#</a> <code>pearson_skewness_2</code></h3>
<p><code>pearson_skewness_2</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = pearson_skewness_2 $x
# or in a pipeline:
@list |> map pearson_skewness_2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pearsonr">
<h3><a class="doc-anchor" href="#doc-pearsonr">#</a> <code>pearsonr</code></h3>
<p><code>pearsonr</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = pearsonr $x
# or in a pipeline:
@list |> map pearsonr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peclet-number-step">
<h3><a class="doc-anchor" href="#doc-peclet-number-step">#</a> <code>peclet_number_step</code></h3>
<p><code>peclet_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = peclet_number_step $x
# or in a pipeline:
@list |> map peclet_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peek-clj">
<h3><a class="doc-anchor" href="#doc-peek-clj">#</a> <code>peek_clj</code></h3>
<p><code>peek_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = peek_clj $x
# or in a pipeline:
@list |> map peek_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peeling-step-psi4">
<h3><a class="doc-anchor" href="#doc-peeling-step-psi4">#</a> <code>peeling_step_psi4</code></h3>
<p><code>peeling_step_psi4</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = peeling_step_psi4 $x
# or in a pipeline:
@list |> map peeling_step_psi4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peg-choice">
<h3><a class="doc-anchor" href="#doc-peg-choice">#</a> <code>peg_choice</code></h3>
<p><code>peg_choice</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = peg_choice $x
# or in a pipeline:
@list |> map peg_choice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peg-lookahead">
<h3><a class="doc-anchor" href="#doc-peg-lookahead">#</a> <code>peg_lookahead</code></h3>
<p><code>peg_lookahead</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = peg_lookahead $x
# or in a pipeline:
@list |> map peg_lookahead |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peg-repeat">
<h3><a class="doc-anchor" href="#doc-peg-repeat">#</a> <code>peg_repeat</code></h3>
<p><code>peg_repeat</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = peg_repeat $x
# or in a pipeline:
@list |> map peg_repeat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peg-seq">
<h3><a class="doc-anchor" href="#doc-peg-seq">#</a> <code>peg_seq</code></h3>
<p><code>peg_seq</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = peg_seq $x
# or in a pipeline:
@list |> map peg_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peith">
<h3><a class="doc-anchor" href="#doc-peith">#</a> <code>peith</code></h3>
<p><code>peith</code> — rust iterator methods builtin. Alias for <code>partition_either</code>.</p>
<pre><code class="lang-perl">my $result = peith $x
# or in a pipeline:
@list |> map peith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pell-fundamental">
<h3><a class="doc-anchor" href="#doc-pell-fundamental">#</a> <code>pell_fundamental</code></h3>
<p><code>pell_fundamental</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = pell_fundamental $x
# or in a pipeline:
@list |> map pell_fundamental |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pendper">
<h3><a class="doc-anchor" href="#doc-pendper">#</a> <code>pendper</code></h3>
<p><code>pendulum_period($length)</code> (alias <code>pendper</code>) — period T = 2π√(L/g) of a simple pendulum.</p>
<pre><code class="lang-perl">p pendper(1) # ~2.01 s (1 meter pendulum)
p pendper(0.25) # ~1.00 s (grandfather clock)
</code></pre>
</article>
<article class="doc-entry" id="doc-pendulum-freq">
<h3><a class="doc-anchor" href="#doc-pendulum-freq">#</a> <code>pendulum_freq</code></h3>
<p><code>pendulum_freq</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = pendulum_freq $x
# or in a pipeline:
@list |> map pendulum_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-penrose-diagram-factor">
<h3><a class="doc-anchor" href="#doc-penrose-diagram-factor">#</a> <code>penrose_diagram_factor</code></h3>
<p><code>penrose_diagram_factor</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = penrose_diagram_factor $x
# or in a pipeline:
@list |> map penrose_diagram_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pentagonal-number">
<h3><a class="doc-anchor" href="#doc-pentagonal-number">#</a> <code>pentagonal_number</code></h3>
<p><code>pentagonal_number</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = pentagonal_number $x
# or in a pipeline:
@list |> map pentagonal_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pentagonal-pyramidal-number">
<h3><a class="doc-anchor" href="#doc-pentagonal-pyramidal-number">#</a> <code>pentagonal_pyramidal_number</code></h3>
<p><code>pentagonal_pyramidal_number</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = pentagonal_pyramidal_number $x
# or in a pipeline:
@list |> map pentagonal_pyramidal_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pentnum">
<h3><a class="doc-anchor" href="#doc-pentnum">#</a> <code>pentnum</code></h3>
<p><code>pentnum</code> — number theory / primes builtin. Alias for <code>pentagonal_number</code>.</p>
<pre><code class="lang-perl">my $result = pentnum $x
# or in a pipeline:
@list |> map pentnum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percent">
<h3><a class="doc-anchor" href="#doc-percent">#</a> <code>percent</code></h3>
<p><code>percent</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = percent $x
# or in a pipeline:
@list |> map percent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percent-decode-url">
<h3><a class="doc-anchor" href="#doc-percent-decode-url">#</a> <code>percent_decode_url</code></h3>
<p><code>percent_decode_url</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = percent_decode_url $x
# or in a pipeline:
@list |> map percent_decode_url |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percent-encode-full">
<h3><a class="doc-anchor" href="#doc-percent-encode-full">#</a> <code>percent_encode_full</code></h3>
<p><code>percent_encode_full</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = percent_encode_full $x
# or in a pipeline:
@list |> map percent_encode_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percentile">
<h3><a class="doc-anchor" href="#doc-percentile">#</a> <code>percentile</code></h3>
<p><code>percentile</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = percentile $x
# or in a pipeline:
@list |> map percentile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percentile-cont">
<h3><a class="doc-anchor" href="#doc-percentile-cont">#</a> <code>percentile_cont</code></h3>
<p><code>percentile_cont</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = percentile_cont $x
# or in a pipeline:
@list |> map percentile_cont |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percentile-disc">
<h3><a class="doc-anchor" href="#doc-percentile-disc">#</a> <code>percentile_disc</code></h3>
<p><code>percentile_disc</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = percentile_disc $x
# or in a pipeline:
@list |> map percentile_disc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percentile-rank">
<h3><a class="doc-anchor" href="#doc-percentile-rank">#</a> <code>percentile_rank</code></h3>
<p><code>percentile_rank($value, @data)</code> — returns the percentile rank (0-100) of a value within a dataset. Indicates what percentage of the data falls below the given value. Useful for ranking and normalization.</p>
<pre><code class="lang-perl">my @scores = 1:100
p percentile_rank(50, @scores) # ~50
p percentile_rank(90, @scores) # ~90
</code></pre>
</article>
<article class="doc-entry" id="doc-percentrank">
<h3><a class="doc-anchor" href="#doc-percentrank">#</a> <code>percentrank</code></h3>
<p><code>percentrank</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = percentrank $x
# or in a pipeline:
@list |> map percentrank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perfect-numbers">
<h3><a class="doc-anchor" href="#doc-perfect-numbers">#</a> <code>perfect_numbers</code></h3>
<p><code>perfect_numbers</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = perfect_numbers $x
# or in a pipeline:
@list |> map perfect_numbers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perfnums">
<h3><a class="doc-anchor" href="#doc-perfnums">#</a> <code>perfnums</code></h3>
<p><code>perfnums</code> — number theory / primes builtin. Alias for <code>perfect_numbers</code>.</p>
<pre><code class="lang-perl">my $result = perfnums $x
# or in a pipeline:
@list |> map perfnums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perihelion-precession">
<h3><a class="doc-anchor" href="#doc-perihelion-precession">#</a> <code>perihelion_precession</code></h3>
<p><code>perihelion_precession</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = perihelion_precession $x
# or in a pipeline:
@list |> map perihelion_precession |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perimeter-rectangle">
<h3><a class="doc-anchor" href="#doc-perimeter-rectangle">#</a> <code>perimeter_rectangle</code></h3>
<p><code>perimeter_rectangle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = perimeter_rectangle $x
# or in a pipeline:
@list |> map perimeter_rectangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perimeter-triangle">
<h3><a class="doc-anchor" href="#doc-perimeter-triangle">#</a> <code>perimeter_triangle</code></h3>
<p><code>perimeter_triangle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = perimeter_triangle $x
# or in a pipeline:
@list |> map perimeter_triangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-period-of-string">
<h3><a class="doc-anchor" href="#doc-period-of-string">#</a> <code>period_of_string</code></h3>
<p><code>period_of_string</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = period_of_string $x
# or in a pipeline:
@list |> map period_of_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-periodogram-basic">
<h3><a class="doc-anchor" href="#doc-periodogram-basic">#</a> <code>periodogram_basic</code></h3>
<p><code>periodogram_basic</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = periodogram_basic $x
# or in a pipeline:
@list |> map periodogram_basic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perm">
<h3><a class="doc-anchor" href="#doc-perm">#</a> <code>perm</code></h3>
<p><code>permutations($n, $r)</code> (alias <code>perm</code>) — number of ways to arrange r items from n. Formula: n!/(n-r)!. Order matters.</p>
<pre><code class="lang-perl">p perm(5, 3) # 60 (ways to arrange 3 items from 5)
p perm(10, 2) # 90
</code></pre>
</article>
<article class="doc-entry" id="doc-perm-mul">
<h3><a class="doc-anchor" href="#doc-perm-mul">#</a> <code>perm_mul</code></h3>
<p><code>perm_mul</code> — batch 9 builtin. Alias for <code>permutation_compose</code>.</p>
<pre><code class="lang-perl">my $result = perm_mul $x
# or in a pipeline:
@list |> map perm_mul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perm-sign">
<h3><a class="doc-anchor" href="#doc-perm-sign">#</a> <code>perm_sign</code></h3>
<p><code>perm_sign</code> — batch 9 builtin. Alias for <code>permutation_parity</code>.</p>
<pre><code class="lang-perl">my $result = perm_sign $x
# or in a pipeline:
@list |> map perm_sign |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-permutation-compose">
<h3><a class="doc-anchor" href="#doc-permutation-compose">#</a> <code>permutation_compose</code></h3>
<p><code>permutation_compose</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = permutation_compose $x
# or in a pipeline:
@list |> map permutation_compose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-permutation-order">
<h3><a class="doc-anchor" href="#doc-permutation-order">#</a> <code>permutation_order</code></h3>
<p><code>permutation_order</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = permutation_order $x
# or in a pipeline:
@list |> map permutation_order |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-permutation-parity">
<h3><a class="doc-anchor" href="#doc-permutation-parity">#</a> <code>permutation_parity</code></h3>
<p><code>permutation_parity</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = permutation_parity $x
# or in a pipeline:
@list |> map permutation_parity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-permute-idx">
<h3><a class="doc-anchor" href="#doc-permute-idx">#</a> <code>permute_idx</code></h3>
<p><code>permute_idx</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = permute_idx $x
# or in a pipeline:
@list |> map permute_idx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perpetuity-value">
<h3><a class="doc-anchor" href="#doc-perpetuity-value">#</a> <code>perpetuity_value</code></h3>
<p><code>perpetuity_value</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = perpetuity_value $x
# or in a pipeline:
@list |> map perpetuity_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-persian-arithmetic-leap">
<h3><a class="doc-anchor" href="#doc-persian-arithmetic-leap">#</a> <code>persian_arithmetic_leap</code></h3>
<p><code>persian_arithmetic_leap</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = persian_arithmetic_leap $x
# or in a pipeline:
@list |> map persian_arithmetic_leap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-persist">
<h3><a class="doc-anchor" href="#doc-persist">#</a> <code>persist</code></h3>
<p><code>persist</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = persist $x
# or in a pipeline:
@list |> map persist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-personalized-pagerank">
<h3><a class="doc-anchor" href="#doc-personalized-pagerank">#</a> <code>personalized_pagerank</code></h3>
<p><code>personalized_pagerank</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = personalized_pagerank $x
# or in a pipeline:
@list |> map personalized_pagerank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-petersen-estimator">
<h3><a class="doc-anchor" href="#doc-petersen-estimator">#</a> <code>petersen_estimator</code></h3>
<p><code>petersen_estimator</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = petersen_estimator $x
# or in a pipeline:
@list |> map petersen_estimator |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peukert-capacity">
<h3><a class="doc-anchor" href="#doc-peukert-capacity">#</a> <code>peukert_capacity</code></h3>
<p><code>peukert_capacity</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = peukert_capacity $x
# or in a pipeline:
@list |> map peukert_capacity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peukert-exponent-fit">
<h3><a class="doc-anchor" href="#doc-peukert-exponent-fit">#</a> <code>peukert_exponent_fit</code></h3>
<p><code>peukert_exponent_fit</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = peukert_exponent_fit $x
# or in a pipeline:
@list |> map peukert_exponent_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pexp">
<h3><a class="doc-anchor" href="#doc-pexp">#</a> <code>pexp</code></h3>
<p><code>pexp</code> — exponential CDF. P(X ≤ x) for Exp(rate). Args: x, rate.</p>
<pre><code class="lang-perl">p pexp(1, 1) # 0.6321 (1 - e^-1)
p pexp(5, 0.5) # P(wait ≤ 5 with avg wait 2)
</code></pre>
</article>
<article class="doc-entry" id="doc-pf">
<h3><a class="doc-anchor" href="#doc-pf">#</a> <code>pf</code></h3>
<p><code>pf</code> — F-distribution CDF. Args: x, d1, d2.</p>
<pre><code class="lang-perl">p pf(4.0, 5, 10) # P(F ≤ 4) for F(5,10)
</code></pre>
</article>
<article class="doc-entry" id="doc-pfact">
<h3><a class="doc-anchor" href="#doc-pfact">#</a> <code>pfact</code></h3>
<p><code>pfact</code> — number theory / primes builtin. Alias for <code>prime_factors</code>.</p>
<pre><code class="lang-perl">my $result = pfact $x
# or in a pipeline:
@list |> map pfact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pfadd">
<h3><a class="doc-anchor" href="#doc-pfadd">#</a> <code>pfadd</code></h3>
<p><code>pfadd</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = pfadd $x
# or in a pipeline:
@list |> map pfadd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pfcount">
<h3><a class="doc-anchor" href="#doc-pfcount">#</a> <code>pfcount</code></h3>
<p><code>pfcount</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = pfcount $x
# or in a pipeline:
@list |> map pfcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pflt">
<h3><a class="doc-anchor" href="#doc-pflt">#</a> <code>pflt</code></h3>
<p><code>pflt</code> — extended stdlib builtin. Alias for <code>parse_float</code>.</p>
<pre><code class="lang-perl">my $result = pflt $x
# or in a pipeline:
@list |> map pflt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pfreq">
<h3><a class="doc-anchor" href="#doc-pfreq">#</a> <code>pfreq</code></h3>
<p><code>pfreq</code> — pipeline / string helpers builtin. Alias for <code>pfrequencies</code>.</p>
<pre><code class="lang-perl">my $result = pfreq $x
# or in a pipeline:
@list |> map pfreq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pfrequencies">
<h3><a class="doc-anchor" href="#doc-pfrequencies">#</a> <code>pfrequencies</code></h3>
<p><code>pfrequencies</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = pfrequencies $x
# or in a pipeline:
@list |> map pfrequencies |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pfrq">
<h3><a class="doc-anchor" href="#doc-pfrq">#</a> <code>pfrq</code></h3>
<p><code>pfrq</code> — pipeline / string helpers builtin. Alias for <code>pfrequencies</code>.</p>
<pre><code class="lang-perl">my $result = pfrq $x
# or in a pipeline:
@list |> map pfrq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pft">
<h3><a class="doc-anchor" href="#doc-pft">#</a> <code>pft</code></h3>
<p><code>pft</code> — data / network builtin. Alias for <code>par_fetch</code>.</p>
<pre><code class="lang-perl">my $result = pft $x
# or in a pipeline:
@list |> map pft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pga-attenuation">
<h3><a class="doc-anchor" href="#doc-pga-attenuation">#</a> <code>pga_attenuation</code></h3>
<p><code>pga_attenuation</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = pga_attenuation $x
# or in a pipeline:
@list |> map pga_attenuation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pgamma">
<h3><a class="doc-anchor" href="#doc-pgamma">#</a> <code>pgamma</code></h3>
<p><code>pgamma</code> — gamma CDF. Args: x, shape [, scale].</p>
<pre><code class="lang-perl">p pgamma(2, 2, 1) # P(X ≤ 2) for Gamma(2,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-ph-at-isoelectric">
<h3><a class="doc-anchor" href="#doc-ph-at-isoelectric">#</a> <code>ph_at_isoelectric</code></h3>
<p><code>ph_at_isoelectric</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = ph_at_isoelectric $x
# or in a pipeline:
@list |> map ph_at_isoelectric |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ph-from-h">
<h3><a class="doc-anchor" href="#doc-ph-from-h">#</a> <code>ph_from_h</code></h3>
<p><code>ph_from_h</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = ph_from_h $x
# or in a pipeline:
@list |> map ph_from_h |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-phase-flip-prob">
<h3><a class="doc-anchor" href="#doc-phase-flip-prob">#</a> <code>phase_flip_prob</code></h3>
<p><code>phase_flip_prob</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = phase_flip_prob $x
# or in a pipeline:
@list |> map phase_flip_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-phase-spectrum">
<h3><a class="doc-anchor" href="#doc-phase-spectrum">#</a> <code>phase_spectrum</code></h3>
<p><code>phase_spectrum(\@signal)</code> — computes the phase angle (in radians) at each frequency bin from the DFT.</p>
<pre><code class="lang-perl">my $phases = phase_spectrum(\@signal)
</code></pre>
</article>
<article class="doc-entry" id="doc-phasespec">
<h3><a class="doc-anchor" href="#doc-phasespec">#</a> <code>phasespec</code></h3>
<p><code>phasespec</code> — dsp / signal (extended) builtin. Alias for <code>phase_spectrum</code>.</p>
<pre><code class="lang-perl">my $result = phasespec $x
# or in a pipeline:
@list |> map phasespec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-phillips-perron">
<h3><a class="doc-anchor" href="#doc-phillips-perron">#</a> <code>phillips_perron</code></h3>
<p><code>phillips_perron</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = phillips_perron $x
# or in a pipeline:
@list |> map phillips_perron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-phonedigit">
<h3><a class="doc-anchor" href="#doc-phonedigit">#</a> <code>phonedigit</code></h3>
<p><code>phonedigit</code> — encoding / phonetics builtin. Alias for <code>phonetic_digit</code>.</p>
<pre><code class="lang-perl">my $result = phonedigit $x
# or in a pipeline:
@list |> map phonedigit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-phonetic-digit">
<h3><a class="doc-anchor" href="#doc-phonetic-digit">#</a> <code>phonetic_digit</code></h3>
<p><code>phonetic_digit</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = phonetic_digit $x
# or in a pipeline:
@list |> map phonetic_digit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-photocurrent-density">
<h3><a class="doc-anchor" href="#doc-photocurrent-density">#</a> <code>photocurrent_density</code></h3>
<p><code>photocurrent_density</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = photocurrent_density $x
# or in a pipeline:
@list |> map photocurrent_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-photon-energy">
<h3><a class="doc-anchor" href="#doc-photon-energy">#</a> <code>photon_energy</code></h3>
<p><code>photon_energy($frequency)</code> (alias <code>photonenergy</code>) — energy E = hf (Joules) of a photon.</p>
<pre><code class="lang-perl">p photonenergy(5e14) # ~3.3e-19 J (visible light)
</code></pre>
</article>
<article class="doc-entry" id="doc-photon-energy-freq">
<h3><a class="doc-anchor" href="#doc-photon-energy-freq">#</a> <code>photon_energy_freq</code></h3>
<p><code>photon_energy_freq</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = photon_energy_freq $x
# or in a pipeline:
@list |> map photon_energy_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-photon-energy-lambda">
<h3><a class="doc-anchor" href="#doc-photon-energy-lambda">#</a> <code>photon_energy_lambda</code></h3>
<p><code>photon_energy_lambda</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = photon_energy_lambda $x
# or in a pipeline:
@list |> map photon_energy_lambda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-photon-energy-wavelength">
<h3><a class="doc-anchor" href="#doc-photon-energy-wavelength">#</a> <code>photon_energy_wavelength</code></h3>
<p><code>photon_energy_wavelength</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = photon_energy_wavelength $x
# or in a pipeline:
@list |> map photon_energy_wavelength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-photon-sphere-radius">
<h3><a class="doc-anchor" href="#doc-photon-sphere-radius">#</a> <code>photon_sphere_radius</code></h3>
<p><code>photon_sphere_radius</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = photon_sphere_radius $x
# or in a pipeline:
@list |> map photon_sphere_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-photonlambda">
<h3><a class="doc-anchor" href="#doc-photonlambda">#</a> <code>photonlambda</code></h3>
<p><code>photonlambda</code> — physics formulas builtin. Alias for <code>photon_energy_wavelength</code>.</p>
<pre><code class="lang-perl">my $result = photonlambda $x
# or in a pipeline:
@list |> map photonlambda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pi">
<h3><a class="doc-anchor" href="#doc-pi">#</a> <code>pi</code></h3>
<p><code>pi</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = pi $x
# or in a pipeline:
@list |> map pi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pi-step-size">
<h3><a class="doc-anchor" href="#doc-pi-step-size">#</a> <code>pi_step_size</code></h3>
<p><code>pi_step_size</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = pi_step_size $x
# or in a pipeline:
@list |> map pi_step_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pick">
<h3><a class="doc-anchor" href="#doc-pick">#</a> <code>pick</code></h3>
<p><code>pick</code> — hash ops (batch 2) builtin. Alias for <code>pick_keys</code>.</p>
<pre><code class="lang-perl">my $result = pick $x
# or in a pipeline:
@list |> map pick |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pick-keys">
<h3><a class="doc-anchor" href="#doc-pick-keys">#</a> <code>pick_keys</code></h3>
<p><code>pick_keys</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = pick_keys $x
# or in a pipeline:
@list |> map pick_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-picks-theorem">
<h3><a class="doc-anchor" href="#doc-picks-theorem">#</a> <code>picks_theorem</code></h3>
<p><code>picks_theorem</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = picks_theorem $x
# or in a pipeline:
@list |> map picks_theorem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pid">
<h3><a class="doc-anchor" href="#doc-pid">#</a> <code>pid</code></h3>
<p><code>pid</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = pid $x
# or in a pipeline:
@list |> map pid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pid-anti-windup">
<h3><a class="doc-anchor" href="#doc-pid-anti-windup">#</a> <code>pid_anti_windup</code></h3>
<p><code>pid_anti_windup</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = pid_anti_windup $x
# or in a pipeline:
@list |> map pid_anti_windup |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pid-ziegler-nichols">
<h3><a class="doc-anchor" href="#doc-pid-ziegler-nichols">#</a> <code>pid_ziegler_nichols</code></h3>
<p><code>pid_ziegler_nichols</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = pid_ziegler_nichols $x
# or in a pipeline:
@list |> map pid_ziegler_nichols |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pielou-evenness">
<h3><a class="doc-anchor" href="#doc-pielou-evenness">#</a> <code>pielou_evenness</code></h3>
<p><code>pielou_evenness</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = pielou_evenness $x
# or in a pipeline:
@list |> map pielou_evenness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pig-latin">
<h3><a class="doc-anchor" href="#doc-pig-latin">#</a> <code>pig_latin</code></h3>
<p><code>pig_latin</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = pig_latin $x
# or in a pipeline:
@list |> map pig_latin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-piglat">
<h3><a class="doc-anchor" href="#doc-piglat">#</a> <code>piglat</code></h3>
<p><code>piglat</code> — string processing (uncategorized batch) builtin. Alias for <code>pig_latin</code>.</p>
<pre><code class="lang-perl">my $result = piglat $x
# or in a pipeline:
@list |> map piglat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pin">
<h3><a class="doc-anchor" href="#doc-pin">#</a> <code>pin</code></h3>
<p><code>pin</code> — stress testing builtin. Alias for <code>fire_and_forget</code>.</p>
<pre><code class="lang-perl">my $result = pin $x
# or in a pipeline:
@list |> map pin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pint">
<h3><a class="doc-anchor" href="#doc-pint">#</a> <code>pint</code></h3>
<p><code>pint</code> — extended stdlib builtin. Alias for <code>parse_int</code>.</p>
<pre><code class="lang-perl">my $result = pint $x
# or in a pipeline:
@list |> map pint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pipe-pressure-drop">
<h3><a class="doc-anchor" href="#doc-pipe-pressure-drop">#</a> <code>pipe_pressure_drop</code></h3>
<p><code>pipe_pressure_drop</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = pipe_pressure_drop $x
# or in a pipeline:
@list |> map pipe_pressure_drop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pipes">
<h3><a class="doc-anchor" href="#doc-pipes">#</a> <code>pipes</code></h3>
<p><code>pipes</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = pipes $x
# or in a pipeline:
@list |> map pipes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pivoted-cholesky-var">
<h3><a class="doc-anchor" href="#doc-pivoted-cholesky-var">#</a> <code>pivoted_cholesky_var</code></h3>
<p><code>pivoted_cholesky_var</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = pivoted_cholesky_var $x
# or in a pipeline:
@list |> map pivoted_cholesky_var |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pka-from-ka">
<h3><a class="doc-anchor" href="#doc-pka-from-ka">#</a> <code>pka_from_ka</code></h3>
<p><code>pka_from_ka</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = pka_from_ka $x
# or in a pipeline:
@list |> map pka_from_ka |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pkb-to-kb">
<h3><a class="doc-anchor" href="#doc-pkb-to-kb">#</a> <code>pkb_to_kb</code></h3>
<p><code>pkb_to_kb</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = pkb_to_kb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pkc">
<h3><a class="doc-anchor" href="#doc-pkc">#</a> <code>pkc</code></h3>
<p><code>pkc</code> — algebraic match builtin. Alias for <code>peek_clj</code>.</p>
<pre><code class="lang-perl">my $result = pkc $x
# or in a pipeline:
@list |> map pkc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pkcs7-pad">
<h3><a class="doc-anchor" href="#doc-pkcs7-pad">#</a> <code>pkcs7_pad</code></h3>
<p><code>pkcs7_pad</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = pkcs7_pad $x
# or in a pipeline:
@list |> map pkcs7_pad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pkcs7-unpad">
<h3><a class="doc-anchor" href="#doc-pkcs7-unpad">#</a> <code>pkcs7_unpad</code></h3>
<p><code>pkcs7_unpad</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = pkcs7_unpad $x
# or in a pipeline:
@list |> map pkcs7_unpad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plactic-class-size">
<h3><a class="doc-anchor" href="#doc-plactic-class-size">#</a> <code>plactic_class_size</code></h3>
<p><code>plactic_class_size</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = plactic_class_size $x
# or in a pipeline:
@list |> map plactic_class_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck">
<h3><a class="doc-anchor" href="#doc-planck">#</a> <code>planck</code></h3>
<p><code>planck</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = planck $x
# or in a pipeline:
@list |> map planck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-const-h">
<h3><a class="doc-anchor" href="#doc-planck-const-h">#</a> <code>planck_const_h</code></h3>
<p><code>planck_const_h</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = planck_const_h $x
# or in a pipeline:
@list |> map planck_const_h |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-constant">
<h3><a class="doc-anchor" href="#doc-planck-constant">#</a> <code>planck_constant</code></h3>
<p><code>planck_constant</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = planck_constant $x
# or in a pipeline:
@list |> map planck_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-energy">
<h3><a class="doc-anchor" href="#doc-planck-energy">#</a> <code>planck_energy</code></h3>
<p><code>planck_energy</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = planck_energy $x
# or in a pipeline:
@list |> map planck_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-mass">
<h3><a class="doc-anchor" href="#doc-planck-mass">#</a> <code>planck_mass</code></h3>
<p><code>planck_mass</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = planck_mass $x
# or in a pipeline:
@list |> map planck_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-spectral-radiance">
<h3><a class="doc-anchor" href="#doc-planck-spectral-radiance">#</a> <code>planck_spectral_radiance</code></h3>
<p><code>planck_spectral_radiance</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = planck_spectral_radiance $x
# or in a pipeline:
@list |> map planck_spectral_radiance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-temperature">
<h3><a class="doc-anchor" href="#doc-planck-temperature">#</a> <code>planck_temperature</code></h3>
<p><code>planck_temperature</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = planck_temperature $x
# or in a pipeline:
@list |> map planck_temperature |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-time">
<h3><a class="doc-anchor" href="#doc-planck-time">#</a> <code>planck_time</code></h3>
<p><code>planck_time</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = planck_time $x
# or in a pipeline:
@list |> map planck_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plastic">
<h3><a class="doc-anchor" href="#doc-plastic">#</a> <code>plastic</code></h3>
<p><code>plastic</code> — math constants builtin. Alias for <code>plastic_number</code>.</p>
<pre><code class="lang-perl">my $result = plastic $x
# or in a pipeline:
@list |> map plastic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plastic-number">
<h3><a class="doc-anchor" href="#doc-plastic-number">#</a> <code>plastic_number</code></h3>
<p><code>plastic_number</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = plastic_number $x
# or in a pipeline:
@list |> map plastic_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plethystic-substitution-value">
<h3><a class="doc-anchor" href="#doc-plethystic-substitution-value">#</a> <code>plethystic_substitution_value</code></h3>
<p><code>plethystic_substitution_value</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = plethystic_substitution_value $x
# or in a pipeline:
@list |> map plethystic_substitution_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plnorm">
<h3><a class="doc-anchor" href="#doc-plnorm">#</a> <code>plnorm</code></h3>
<p><code>plnorm</code> — log-normal CDF. P(X ≤ x) for LogN(mu, sigma). Args: x, mu, sigma.</p>
<pre><code class="lang-perl">p plnorm(1, 0, 1) # 0.5 (median of LogN(0,1))
</code></pre>
</article>
<article class="doc-entry" id="doc-plur">
<h3><a class="doc-anchor" href="#doc-plur">#</a> <code>plur</code></h3>
<p><code>plur</code> — extended stdlib builtin. Alias for <code>pluralize</code>.</p>
<pre><code class="lang-perl">my $result = plur $x
# or in a pipeline:
@list |> map plur |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plurality-winner-step">
<h3><a class="doc-anchor" href="#doc-plurality-winner-step">#</a> <code>plurality_winner_step</code></h3>
<p><code>plurality_winner_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = plurality_winner_step $x
# or in a pipeline:
@list |> map plurality_winner_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pluralize">
<h3><a class="doc-anchor" href="#doc-pluralize">#</a> <code>pluralize</code></h3>
<p><code>pluralize</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = pluralize $x
# or in a pipeline:
@list |> map pluralize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pluralize-simple">
<h3><a class="doc-anchor" href="#doc-pluralize-simple">#</a> <code>pluralize_simple</code></h3>
<p><code>pluralize_simple</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = pluralize_simple $x
# or in a pipeline:
@list |> map pluralize_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plus-polarization-amp">
<h3><a class="doc-anchor" href="#doc-plus-polarization-amp">#</a> <code>plus_polarization_amp</code></h3>
<p><code>plus_polarization_amp</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = plus_polarization_amp $x
# or in a pipeline:
@list |> map plus_polarization_amp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pmass">
<h3><a class="doc-anchor" href="#doc-pmass">#</a> <code>pmass</code></h3>
<p><code>pmass</code> — constants builtin. Alias for <code>proton_mass</code>.</p>
<pre><code class="lang-perl">my $result = pmass $x
# or in a pipeline:
@list |> map pmass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pmt">
<h3><a class="doc-anchor" href="#doc-pmt">#</a> <code>pmt</code></h3>
<p><code>pmt($rate, $nper, $pv)</code> — computes the periodic payment for a loan given interest rate, number of periods, and present value. Standard amortization formula.</p>
<pre><code class="lang-perl"># $100k loan, 5% annual rate, 30 years
p pmt(0.05/12, 360, 100000) # ~$537/month
</code></pre>
</article>
<article class="doc-entry" id="doc-pnorm">
<h3><a class="doc-anchor" href="#doc-pnorm">#</a> <code>pnorm</code></h3>
<p><code>pnorm</code> — normal CDF. P(X ≤ x) for N(mu, sigma). Args: x [, mu, sigma]. Default standard normal.</p>
<pre><code class="lang-perl">p pnorm(0) # 0.5
p pnorm(1.96) # 0.975
p pnorm(100, 90, 15) # z-score for IQ 100
</code></pre>
</article>
<article class="doc-entry" id="doc-pochhammer">
<h3><a class="doc-anchor" href="#doc-pochhammer">#</a> <code>pochhammer</code></h3>
<p><code>pochhammer</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = pochhammer $x
# or in a pipeline:
@list |> map pochhammer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-poh-from-oh">
<h3><a class="doc-anchor" href="#doc-poh-from-oh">#</a> <code>poh_from_oh</code></h3>
<p><code>poh_from_oh</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = poh_from_oh $x
# or in a pipeline:
@list |> map poh_from_oh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-poincare-duality">
<h3><a class="doc-anchor" href="#doc-poincare-duality">#</a> <code>poincare_duality</code></h3>
<p><code>poincare_duality</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = poincare_duality $x
# or in a pipeline:
@list |> map poincare_duality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-poincare-polynomial-eval">
<h3><a class="doc-anchor" href="#doc-poincare-polynomial-eval">#</a> <code>poincare_polynomial_eval</code></h3>
<p><code>poincare_polynomial_eval</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = poincare_polynomial_eval $x
# or in a pipeline:
@list |> map poincare_polynomial_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-point-distance">
<h3><a class="doc-anchor" href="#doc-point-distance">#</a> <code>point_distance</code></h3>
<p><code>point_distance</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = point_distance $x
# or in a pipeline:
@list |> map point_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-point-in-polygon">
<h3><a class="doc-anchor" href="#doc-point-in-polygon">#</a> <code>point_in_polygon</code></h3>
<p><code>point_in_polygon($x, $y, @polygon)</code> (alias <code>pip</code>) — tests if a point lies inside a polygon. Polygon is given as flat list [x1,y1,x2,y2,...]. Returns 1 if inside, 0 if outside. Uses ray-casting algorithm.</p>
<pre><code class="lang-perl">my @square = (0,0, 4,0, 4,4, 0,4)
p pip(2, 2, @square) # 1 (inside)
p pip(5, 5, @square) # 0 (outside)
</code></pre>
</article>
<article class="doc-entry" id="doc-point-in-polygon-ray">
<h3><a class="doc-anchor" href="#doc-point-in-polygon-ray">#</a> <code>point_in_polygon_ray</code></h3>
<p><code>point_in_polygon_ray</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = point_in_polygon_ray $x
# or in a pipeline:
@list |> map point_in_polygon_ray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-point-in-polygon-winding">
<h3><a class="doc-anchor" href="#doc-point-in-polygon-winding">#</a> <code>point_in_polygon_winding</code></h3>
<p><code>point_in_polygon_winding</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = point_in_polygon_winding $x
# or in a pipeline:
@list |> map point_in_polygon_winding |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pointer-width">
<h3><a class="doc-anchor" href="#doc-pointer-width">#</a> <code>pointer_width</code></h3>
<p><code>pointer_width</code> — pointer width in bits: <code>32</code> or <code>64</code>. Compile-time constant.</p>
<pre><code class="lang-perl">p pointer_width # 64
</code></pre>
</article>
<article class="doc-entry" id="doc-poisson">
<h3><a class="doc-anchor" href="#doc-poisson">#</a> <code>poisson</code></h3>
<p><code>poisson_pmf($k, $lambda)</code> (alias <code>poisson</code>) — Poisson probability mass function. P(X=k) for events with rate λ.</p>
<pre><code class="lang-perl">p poisson(3, 5) # P(X=3) when avg rate is 5
</code></pre>
</article>
<article class="doc-entry" id="doc-poisson-boltzmann-step">
<h3><a class="doc-anchor" href="#doc-poisson-boltzmann-step">#</a> <code>poisson_boltzmann_step</code></h3>
<p><code>poisson_boltzmann_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = poisson_boltzmann_step $x
# or in a pipeline:
@list |> map poisson_boltzmann_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-poisson-photon-pmf">
<h3><a class="doc-anchor" href="#doc-poisson-photon-pmf">#</a> <code>poisson_photon_pmf</code></h3>
<p><code>poisson_photon_pmf</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = poisson_photon_pmf $x
# or in a pipeline:
@list |> map poisson_photon_pmf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polar-vortex-radius">
<h3><a class="doc-anchor" href="#doc-polar-vortex-radius">#</a> <code>polar_vortex_radius</code></h3>
<p><code>polar_vortex_radius</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = polar_vortex_radius $x
# or in a pipeline:
@list |> map polar_vortex_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-policy-iteration-step">
<h3><a class="doc-anchor" href="#doc-policy-iteration-step">#</a> <code>policy_iteration_step</code></h3>
<p><code>policy_iteration_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = policy_iteration_step $x
# or in a pipeline:
@list |> map policy_iteration_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pollard-p-minus-1">
<h3><a class="doc-anchor" href="#doc-pollard-p-minus-1">#</a> <code>pollard_p_minus_1</code></h3>
<p><code>pollard_p_minus_1</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = pollard_p_minus_1 $x
# or in a pipeline:
@list |> map pollard_p_minus_1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-poly1305-block-step">
<h3><a class="doc-anchor" href="#doc-poly1305-block-step">#</a> <code>poly1305_block_step</code></h3>
<p><code>poly1305_block_step</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = poly1305_block_step $x
# or in a pipeline:
@list |> map poly1305_block_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-poly-eval">
<h3><a class="doc-anchor" href="#doc-poly-eval">#</a> <code>poly_eval</code></h3>
<p><code>poly_eval</code> (alias <code>polyval</code>) evaluates a polynomial c0 + c1·x + c2·x² + ... using Horner's method.</p>
<pre><code class="lang-perl">p polyval([1, 0, 1], 3) # 1 + 0*3 + 1*9 = 10
</code></pre>
</article>
<article class="doc-entry" id="doc-polyarea">
<h3><a class="doc-anchor" href="#doc-polyarea">#</a> <code>polyarea</code></h3>
<p><code>polyarea</code> — geometry / physics builtin. Alias for <code>polygon_area</code>.</p>
<pre><code class="lang-perl">my $result = polyarea $x
# or in a pipeline:
@list |> map polyarea |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polyfit">
<h3><a class="doc-anchor" href="#doc-polyfit">#</a> <code>polyfit</code></h3>
<p><code>polynomial_fit</code> (alias <code>polyfit</code>) performs least-squares polynomial fitting. Returns coefficients [c0, c1, ..., cn].</p>
<pre><code class="lang-perl">my $c = polyfit([0,1,2,3], [1,3,5,7], 1) # linear fit
</code></pre>
</article>
<article class="doc-entry" id="doc-polyfit-rmse">
<h3><a class="doc-anchor" href="#doc-polyfit-rmse">#</a> <code>polyfit_rmse</code></h3>
<p><code>polyfit_rmse</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = polyfit_rmse $x
# or in a pipeline:
@list |> map polyfit_rmse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygamma">
<h3><a class="doc-anchor" href="#doc-polygamma">#</a> <code>polygamma</code></h3>
<p><code>polygamma</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = polygamma $x
# or in a pipeline:
@list |> map polygamma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-area">
<h3><a class="doc-anchor" href="#doc-polygon-area">#</a> <code>polygon_area</code></h3>
<p><code>polygon_area</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = polygon_area $x
# or in a pipeline:
@list |> map polygon_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-area-signed">
<h3><a class="doc-anchor" href="#doc-polygon-area-signed">#</a> <code>polygon_area_signed</code></h3>
<p><code>polygon_area_signed</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = polygon_area_signed $x
# or in a pipeline:
@list |> map polygon_area_signed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-convex-q">
<h3><a class="doc-anchor" href="#doc-polygon-convex-q">#</a> <code>polygon_convex_q</code></h3>
<p><code>polygon_convex_q</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = polygon_convex_q $x
# or in a pipeline:
@list |> map polygon_convex_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-is-convex">
<h3><a class="doc-anchor" href="#doc-polygon-is-convex">#</a> <code>polygon_is_convex</code></h3>
<p><code>polygon_is_convex</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = polygon_is_convex $x
# or in a pipeline:
@list |> map polygon_is_convex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-perimeter">
<h3><a class="doc-anchor" href="#doc-polygon-perimeter">#</a> <code>polygon_perimeter</code></h3>
<p><code>polygon_perimeter(@points)</code> (alias <code>polyper</code>) — computes the perimeter of a polygon. Points as flat list [x1,y1,x2,y2,...]. Assumes closed polygon.</p>
<pre><code class="lang-perl">my @square = (0,0, 1,0, 1,1, 0,1)
p polyper(@square) # 4
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-winding-number">
<h3><a class="doc-anchor" href="#doc-polygon-winding-number">#</a> <code>polygon_winding_number</code></h3>
<p><code>polygon_winding_number</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = polygon_winding_number $x
# or in a pipeline:
@list |> map polygon_winding_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-winding-order">
<h3><a class="doc-anchor" href="#doc-polygon-winding-order">#</a> <code>polygon_winding_order</code></h3>
<p><code>polygon_winding_order</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = polygon_winding_order $x
# or in a pipeline:
@list |> map polygon_winding_order |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-with-holes-area">
<h3><a class="doc-anchor" href="#doc-polygon-with-holes-area">#</a> <code>polygon_with_holes_area</code></h3>
<p><code>polygon_with_holes_area</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = polygon_with_holes_area $x
# or in a pipeline:
@list |> map polygon_with_holes_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polylog-li2">
<h3><a class="doc-anchor" href="#doc-polylog-li2">#</a> <code>polylog_li2</code></h3>
<p><code>polylog_li2</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = polylog_li2 $x
# or in a pipeline:
@list |> map polylog_li2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polylog-n">
<h3><a class="doc-anchor" href="#doc-polylog-n">#</a> <code>polylog_n</code></h3>
<p><code>polylog_n</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = polylog_n $x
# or in a pipeline:
@list |> map polylog_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polynomial-jones-skein">
<h3><a class="doc-anchor" href="#doc-polynomial-jones-skein">#</a> <code>polynomial_jones_skein</code></h3>
<p><code>polynomial_jones_skein</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = polynomial_jones_skein $x
# or in a pipeline:
@list |> map polynomial_jones_skein |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polynomial-roots-dk">
<h3><a class="doc-anchor" href="#doc-polynomial-roots-dk">#</a> <code>polynomial_roots_dk</code></h3>
<p><code>polynomial_roots_dk</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = polynomial_roots_dk $x
# or in a pipeline:
@list |> map polynomial_roots_dk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polyperim">
<h3><a class="doc-anchor" href="#doc-polyperim">#</a> <code>polyperim</code></h3>
<p><code>polyperim</code> — geometry (extended) builtin. Alias for <code>polygon_perimeter</code>.</p>
<pre><code class="lang-perl">my $result = polyperim $x
# or in a pipeline:
@list |> map polyperim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pooling-test-stat">
<h3><a class="doc-anchor" href="#doc-pooling-test-stat">#</a> <code>pooling_test_stat</code></h3>
<p><code>pooling_test_stat</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = pooling_test_stat $x
# or in a pipeline:
@list |> map pooling_test_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pop-clj">
<h3><a class="doc-anchor" href="#doc-pop-clj">#</a> <code>pop_clj</code></h3>
<p><code>pop_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = pop_clj $x
# or in a pipeline:
@list |> map pop_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-popc">
<h3><a class="doc-anchor" href="#doc-popc">#</a> <code>popc</code></h3>
<p><code>popc</code> — algebraic match builtin. Alias for <code>pop_clj</code>.</p>
<pre><code class="lang-perl">my $result = popc $x
# or in a pipeline:
@list |> map popc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-popcnt">
<h3><a class="doc-anchor" href="#doc-popcnt">#</a> <code>popcnt</code></h3>
<p><code>popcnt</code> — batch 10 builtin. Alias for <code>hamming_weight</code>.</p>
<pre><code class="lang-perl">my $result = popcnt $x
# or in a pipeline:
@list |> map popcnt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-popcount">
<h3><a class="doc-anchor" href="#doc-popcount">#</a> <code>popcount</code></h3>
<p><code>popcount</code> — base conversion builtin. Alias for <code>bits_count</code>.</p>
<pre><code class="lang-perl">my $result = popcount $x
# or in a pipeline:
@list |> map popcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-porosity-active-layer">
<h3><a class="doc-anchor" href="#doc-porosity-active-layer">#</a> <code>porosity_active_layer</code></h3>
<p><code>porosity_active_layer</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = porosity_active_layer $x
# or in a pipeline:
@list |> map porosity_active_layer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-porter-stem-step">
<h3><a class="doc-anchor" href="#doc-porter-stem-step">#</a> <code>porter_stem_step</code></h3>
<p><code>porter_stem_step</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = porter_stem_step $x
# or in a pipeline:
@list |> map porter_stem_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pos-n">
<h3><a class="doc-anchor" href="#doc-pos-n">#</a> <code>pos_n</code></h3>
<p><code>pos_n</code> — trivial numeric / predicate builtins builtin. Alias for <code>positive</code>.</p>
<pre><code class="lang-perl">my $result = pos_n $x
# or in a pipeline:
@list |> map pos_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-poset-zeta-two">
<h3><a class="doc-anchor" href="#doc-poset-zeta-two">#</a> <code>poset_zeta_two</code></h3>
<p><code>poset_zeta_two</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = poset_zeta_two $x
# or in a pipeline:
@list |> map poset_zeta_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-position-of-all-matching">
<h3><a class="doc-anchor" href="#doc-position-of-all-matching">#</a> <code>position_of_all_matching</code></h3>
<p><code>position_of_all_matching</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = position_of_all_matching $x
# or in a pipeline:
@list |> map position_of_all_matching |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-positions-of">
<h3><a class="doc-anchor" href="#doc-positions-of">#</a> <code>positions_of</code></h3>
<p><code>positions_of</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = positions_of $x
# or in a pipeline:
@list |> map positions_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-positions-of-all">
<h3><a class="doc-anchor" href="#doc-positions-of-all">#</a> <code>positions_of_all</code></h3>
<p><code>positions_of_all</code> — batch 9 builtin. Alias for <code>position_of_all_matching</code>.</p>
<pre><code class="lang-perl">my $result = positions_of_all $x
# or in a pipeline:
@list |> map positions_of_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-positive">
<h3><a class="doc-anchor" href="#doc-positive">#</a> <code>positive</code></h3>
<p><code>positive</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = positive $x
# or in a pipeline:
@list |> map positive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-post-newtonian-step">
<h3><a class="doc-anchor" href="#doc-post-newtonian-step">#</a> <code>post_newtonian_step</code></h3>
<p><code>post_newtonian_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = post_newtonian_step $x
# or in a pipeline:
@list |> map post_newtonian_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-posted-price-offer-accept">
<h3><a class="doc-anchor" href="#doc-posted-price-offer-accept">#</a> <code>posted_price_offer_accept</code></h3>
<p><code>posted_price_offer_accept</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = posted_price_offer_accept $x
# or in a pipeline:
@list |> map posted_price_offer_accept |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-potential-energy">
<h3><a class="doc-anchor" href="#doc-potential-energy">#</a> <code>potential_energy</code></h3>
<p><code>potential_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = potential_energy $x
# or in a pipeline:
@list |> map potential_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-potential-temperature-step">
<h3><a class="doc-anchor" href="#doc-potential-temperature-step">#</a> <code>potential_temperature_step</code></h3>
<p><code>potential_temperature_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = potential_temperature_step $x
# or in a pipeline:
@list |> map potential_temperature_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pourbaix-line-value">
<h3><a class="doc-anchor" href="#doc-pourbaix-line-value">#</a> <code>pourbaix_line_value</code></h3>
<p><code>pourbaix_line_value</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = pourbaix_line_value $x
# or in a pipeline:
@list |> map pourbaix_line_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pow2">
<h3><a class="doc-anchor" href="#doc-pow2">#</a> <code>pow2</code></h3>
<p><code>pow2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = pow2 $x
# or in a pipeline:
@list |> map pow2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-density-battery">
<h3><a class="doc-anchor" href="#doc-power-density-battery">#</a> <code>power_density_battery</code></h3>
<p><code>power_density_battery</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = power_density_battery $x
# or in a pipeline:
@list |> map power_density_battery |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-i2r">
<h3><a class="doc-anchor" href="#doc-power-i2r">#</a> <code>power_i2r</code></h3>
<p><code>power_i2r</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = power_i2r $x
# or in a pipeline:
@list |> map power_i2r |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-law-wind-profile">
<h3><a class="doc-anchor" href="#doc-power-law-wind-profile">#</a> <code>power_law_wind_profile</code></h3>
<p><code>power_law_wind_profile</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = power_law_wind_profile $x
# or in a pipeline:
@list |> map power_law_wind_profile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-phys">
<h3><a class="doc-anchor" href="#doc-power-phys">#</a> <code>power_phys</code></h3>
<p><code>power_phys</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = power_phys $x
# or in a pipeline:
@list |> map power_phys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-residue-check">
<h3><a class="doc-anchor" href="#doc-power-residue-check">#</a> <code>power_residue_check</code></h3>
<p><code>power_residue_check</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = power_residue_check $x
# or in a pipeline:
@list |> map power_residue_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-set">
<h3><a class="doc-anchor" href="#doc-power-set">#</a> <code>power_set</code></h3>
<p><code>power_set</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = power_set $x
# or in a pipeline:
@list |> map power_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-spectrum">
<h3><a class="doc-anchor" href="#doc-power-spectrum">#</a> <code>power_spectrum</code></h3>
<p><code>power_spectrum(\@signal)</code> (alias <code>psd</code>) — computes the power spectral density (magnitude squared of DFT). Returns real values representing power at each frequency bin.</p>
<pre><code class="lang-perl">my $psd = psd(\@signal)
@$psd |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-spectrum-slope">
<h3><a class="doc-anchor" href="#doc-power-spectrum-slope">#</a> <code>power_spectrum_slope</code></h3>
<p><code>power_spectrum_slope</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = power_spectrum_slope $x
# or in a pipeline:
@list |> map power_spectrum_slope |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-vi">
<h3><a class="doc-anchor" href="#doc-power-vi">#</a> <code>power_vi</code></h3>
<p><code>power_vi</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = power_vi $x
# or in a pipeline:
@list |> map power_vi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-powers-of-seq">
<h3><a class="doc-anchor" href="#doc-powers-of-seq">#</a> <code>powers_of_seq</code></h3>
<p><code>powers_of_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = powers_of_seq $x
# or in a pipeline:
@list |> map powers_of_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-powerset">
<h3><a class="doc-anchor" href="#doc-powerset">#</a> <code>powerset</code></h3>
<p><code>powerset</code> — extended stdlib batch 3 builtin. Alias for <code>power_set</code>.</p>
<pre><code class="lang-perl">my $result = powerset $x
# or in a pipeline:
@list |> map powerset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-powspec">
<h3><a class="doc-anchor" href="#doc-powspec">#</a> <code>powspec</code></h3>
<p><code>powspec</code> — dsp / signal (extended) builtin. Alias for <code>power_spectrum</code>.</p>
<pre><code class="lang-perl">my $result = powspec $x
# or in a pipeline:
@list |> map powspec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-poynting-magnitude">
<h3><a class="doc-anchor" href="#doc-poynting-magnitude">#</a> <code>poynting_magnitude</code></h3>
<p><code>poynting_magnitude</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = poynting_magnitude $x
# or in a pipeline:
@list |> map poynting_magnitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pp-test-stat">
<h3><a class="doc-anchor" href="#doc-pp-test-stat">#</a> <code>pp_test_stat</code></h3>
<p><code>pp_test_stat</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = pp_test_stat $x
# or in a pipeline:
@list |> map pp_test_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppi">
<h3><a class="doc-anchor" href="#doc-ppi">#</a> <code>ppi</code></h3>
<p><code>ppi</code> — number theory / primes builtin. Alias for <code>prime_pi</code>.</p>
<pre><code class="lang-perl">my $result = ppi $x
# or in a pipeline:
@list |> map ppi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppid">
<h3><a class="doc-anchor" href="#doc-ppid">#</a> <code>ppid</code></h3>
<p><code>ppid</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = ppid $x
# or in a pipeline:
@list |> map ppid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppm-predict-prob">
<h3><a class="doc-anchor" href="#doc-ppm-predict-prob">#</a> <code>ppm_predict_prob</code></h3>
<p><code>ppm_predict_prob</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = ppm_predict_prob $x
# or in a pipeline:
@list |> map ppm_predict_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppmt">
<h3><a class="doc-anchor" href="#doc-ppmt">#</a> <code>ppmt</code></h3>
<p><code>ppmt</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = ppmt $x
# or in a pipeline:
@list |> map ppmt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppo-advantage-step">
<h3><a class="doc-anchor" href="#doc-ppo-advantage-step">#</a> <code>ppo_advantage_step</code></h3>
<p><code>ppo_advantage_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = ppo_advantage_step $x
# or in a pipeline:
@list |> map ppo_advantage_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppo-clip-term">
<h3><a class="doc-anchor" href="#doc-ppo-clip-term">#</a> <code>ppo_clip_term</code></h3>
<p><code>ppo_clip_term</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = ppo_clip_term $x
# or in a pipeline:
@list |> map ppo_clip_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppois">
<h3><a class="doc-anchor" href="#doc-ppois">#</a> <code>ppois</code></h3>
<p><code>ppois</code> — Poisson CDF. P(X ≤ k) for Poisson(lambda). Args: k, lambda.</p>
<pre><code class="lang-perl">p ppois(3, 2.5) # P(≤3 events when avg is 2.5)
</code></pre>
</article>
<article class="doc-entry" id="doc-ppt">
<h3><a class="doc-anchor" href="#doc-ppt">#</a> <code>ppt</code></h3>
<p><code>ppt</code> — extended stdlib builtin. Alias for <code>partition_point</code>.</p>
<pre><code class="lang-perl">my $result = ppt $x
# or in a pipeline:
@list |> map ppt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prandtl-number-step">
<h3><a class="doc-anchor" href="#doc-prandtl-number-step">#</a> <code>prandtl_number_step</code></h3>
<p><code>prandtl_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = prandtl_number_step $x
# or in a pipeline:
@list |> map prandtl_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pratt-parse-step">
<h3><a class="doc-anchor" href="#doc-pratt-parse-step">#</a> <code>pratt_parse_step</code></h3>
<p><code>pratt_parse_step</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = pratt_parse_step $x
# or in a pipeline:
@list |> map pratt_parse_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-precession-iau2006">
<h3><a class="doc-anchor" href="#doc-precession-iau2006">#</a> <code>precession_iau2006</code></h3>
<p><code>precession_iau2006</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = precession_iau2006 $x
# or in a pipeline:
@list |> map precession_iau2006 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prect">
<h3><a class="doc-anchor" href="#doc-prect">#</a> <code>prect</code></h3>
<p><code>prect</code> — geometry / physics builtin. Alias for <code>perimeter_rectangle</code>.</p>
<pre><code class="lang-perl">my $result = prect $x
# or in a pipeline:
@list |> map prect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pred">
<h3><a class="doc-anchor" href="#doc-pred">#</a> <code>pred</code></h3>
<p><code>pred</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = pred $x
# or in a pipeline:
@list |> map pred |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-predict">
<h3><a class="doc-anchor" href="#doc-predict">#</a> <code>predict</code></h3>
<p><code>predict_lm</code> (alias <code>predict</code>) — predict from a linear model at new x values.</p>
<pre><code class="lang-perl">my $model = lm([1,2,3], [2,4,6])
my @pred = @{predict($model, [4,5,6])} # [8,10,12]
</code></pre>
</article>
<article class="doc-entry" id="doc-predictor-corrector">
<h3><a class="doc-anchor" href="#doc-predictor-corrector">#</a> <code>predictor_corrector</code></h3>
<p><code>predictor_corrector</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = predictor_corrector $x
# or in a pipeline:
@list |> map predictor_corrector |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prefix-sums">
<h3><a class="doc-anchor" href="#doc-prefix-sums">#</a> <code>prefix_sums</code></h3>
<p><code>prefix_sums</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = prefix_sums $x
# or in a pipeline:
@list |> map prefix_sums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prelu">
<h3><a class="doc-anchor" href="#doc-prelu">#</a> <code>prelu</code></h3>
<p><code>prelu</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = prelu $x
# or in a pipeline:
@list |> map prelu |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-premium-net">
<h3><a class="doc-anchor" href="#doc-premium-net">#</a> <code>premium_net</code></h3>
<p><code>premium_net</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = premium_net $x
# or in a pipeline:
@list |> map premium_net |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prepend">
<h3><a class="doc-anchor" href="#doc-prepend">#</a> <code>prepend</code></h3>
<p><code>prepend</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = prepend $x
# or in a pipeline:
@list |> map prepend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-present-value">
<h3><a class="doc-anchor" href="#doc-present-value">#</a> <code>present_value</code></h3>
<p><code>present_value</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = present_value $x
# or in a pipeline:
@list |> map present_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pressure-altitude-m">
<h3><a class="doc-anchor" href="#doc-pressure-altitude-m">#</a> <code>pressure_altitude_m</code></h3>
<p><code>pressure_altitude_m</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = pressure_altitude_m $x
# or in a pipeline:
@list |> map pressure_altitude_m |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prev-prime">
<h3><a class="doc-anchor" href="#doc-prev-prime">#</a> <code>prev_prime</code></h3>
<p><code>prev_prime</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = prev_prime $x
# or in a pipeline:
@list |> map prev_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-preventive-fraction">
<h3><a class="doc-anchor" href="#doc-preventive-fraction">#</a> <code>preventive_fraction</code></h3>
<p><code>preventive_fraction</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = preventive_fraction $x
# or in a pipeline:
@list |> map preventive_fraction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prewitt-kernel-value">
<h3><a class="doc-anchor" href="#doc-prewitt-kernel-value">#</a> <code>prewitt_kernel_value</code></h3>
<p><code>prewitt_kernel_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = prewitt_kernel_value $x
# or in a pipeline:
@list |> map prewitt_kernel_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-price-disc">
<h3><a class="doc-anchor" href="#doc-price-disc">#</a> <code>price_disc</code></h3>
<p><code>price_disc</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = price_disc $x
# or in a pipeline:
@list |> map price_disc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-price-elasticity">
<h3><a class="doc-anchor" href="#doc-price-elasticity">#</a> <code>price_elasticity</code></h3>
<p><code>price_elasticity</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = price_elasticity $x
# or in a pipeline:
@list |> map price_elasticity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prim-step">
<h3><a class="doc-anchor" href="#doc-prim-step">#</a> <code>prim_step</code></h3>
<p><code>prim_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = prim_step $x
# or in a pipeline:
@list |> map prim_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prime-factors">
<h3><a class="doc-anchor" href="#doc-prime-factors">#</a> <code>prime_factors</code></h3>
<p><code>prime_factors</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = prime_factors $x
# or in a pipeline:
@list |> map prime_factors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prime-pi">
<h3><a class="doc-anchor" href="#doc-prime-pi">#</a> <code>prime_pi</code></h3>
<p><code>prime_pi</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = prime_pi $x
# or in a pipeline:
@list |> map prime_pi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-primes-seq">
<h3><a class="doc-anchor" href="#doc-primes-seq">#</a> <code>primes_seq</code></h3>
<p><code>primes_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = primes_seq $x
# or in a pipeline:
@list |> map primes_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-primes-up-to">
<h3><a class="doc-anchor" href="#doc-primes-up-to">#</a> <code>primes_up_to</code></h3>
<p><code>primes_up_to</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = primes_up_to $x
# or in a pipeline:
@list |> map primes_up_to |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-primorial-n">
<h3><a class="doc-anchor" href="#doc-primorial-n">#</a> <code>primorial_n</code></h3>
<p><code>primorial_n</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = primorial_n $x
# or in a pipeline:
@list |> map primorial_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prisoners-dilemma-payoff">
<h3><a class="doc-anchor" href="#doc-prisoners-dilemma-payoff">#</a> <code>prisoners_dilemma_payoff</code></h3>
<p><code>prisoners_dilemma_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = prisoners_dilemma_payoff $x
# or in a pipeline:
@list |> map prisoners_dilemma_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prisoners-repeated-eq">
<h3><a class="doc-anchor" href="#doc-prisoners-repeated-eq">#</a> <code>prisoners_repeated_eq</code></h3>
<p><code>prisoners_repeated_eq</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = prisoners_repeated_eq $x
# or in a pipeline:
@list |> map prisoners_repeated_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-priv">
<h3><a class="doc-anchor" href="#doc-priv">#</a> <code>priv</code></h3>
<p><code>priv</code> marks a field or method as private. Private members can only be accessed from within the class.</p>
<pre><code class="lang-perl">class Secret {
priv hidden: Int = 42
priv fn internal { }
pub fn reveal { $self->hidden } # internal access ok
}
# $obj->hidden # ERROR: field is private
</code></pre>
</article>
<article class="doc-entry" id="doc-prm-node-connect">
<h3><a class="doc-anchor" href="#doc-prm-node-connect">#</a> <code>prm_node_connect</code></h3>
<p><code>prm_node_connect</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = prm_node_connect $x
# or in a pipeline:
@list |> map prm_node_connect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-probability-density">
<h3><a class="doc-anchor" href="#doc-probability-density">#</a> <code>probability_density</code></h3>
<p><code>probability_density</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = probability_density $x
# or in a pipeline:
@list |> map probability_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-probit-log-likelihood">
<h3><a class="doc-anchor" href="#doc-probit-log-likelihood">#</a> <code>probit_log_likelihood</code></h3>
<p><code>probit_log_likelihood</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = probit_log_likelihood $x
# or in a pipeline:
@list |> map probit_log_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-proc-mem">
<h3><a class="doc-anchor" href="#doc-proc-mem">#</a> <code>proc_mem</code></h3>
<p><code>proc_mem</code> (alias <code>rss</code>) — current process resident set size (RSS) in bytes. On Linux reads <code>VmRSS</code> from <code>/proc/self/status</code>. On macOS uses <code>getrusage(RUSAGE_SELF)</code>. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p format_bytes(rss) # 18.5 MiB
my $before = rss
do_work()
p format_bytes(rss - $before) . " allocated"
</code></pre>
</article>
<article class="doc-entry" id="doc-producer-surplus">
<h3><a class="doc-anchor" href="#doc-producer-surplus">#</a> <code>producer_surplus</code></h3>
<p><code>producer_surplus</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = producer_surplus $x
# or in a pipeline:
@list |> map producer_surplus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-product-list">
<h3><a class="doc-anchor" href="#doc-product-list">#</a> <code>product_list</code></h3>
<p><code>product_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = product_list $x
# or in a pipeline:
@list |> map product_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-product-of">
<h3><a class="doc-anchor" href="#doc-product-of">#</a> <code>product_of</code></h3>
<p><code>product_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = product_of $x
# or in a pipeline:
@list |> map product_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-proj">
<h3><a class="doc-anchor" href="#doc-proj">#</a> <code>proj</code></h3>
<p><code>proj</code> — batch 11 builtin. Alias for <code>vector_project</code>.</p>
<pre><code class="lang-perl">my $result = proj $x
# or in a pipeline:
@list |> map proj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-projectile-max-height">
<h3><a class="doc-anchor" href="#doc-projectile-max-height">#</a> <code>projectile_max_height</code></h3>
<p><code>projectile_max_height($velocity, $angle)</code> (alias <code>projheight</code>) — maximum height H = v²sin²(θ)/(2g).</p>
<pre><code class="lang-perl">p projheight(100, 45) # ~255 m
p projheight(100, 90) # ~510 m (straight up)
</code></pre>
</article>
<article class="doc-entry" id="doc-projectile-range">
<h3><a class="doc-anchor" href="#doc-projectile-range">#</a> <code>projectile_range</code></h3>
<p><code>projectile_range($velocity, $angle)</code> (alias <code>projrange</code>) — horizontal range R = v²sin(2θ)/g. Angle in degrees.</p>
<pre><code class="lang-perl">p projrange(100, 45) # ~1020 m (optimal angle for range)
p projrange(100, 30) # ~884 m
</code></pre>
</article>
<article class="doc-entry" id="doc-projectile-time">
<h3><a class="doc-anchor" href="#doc-projectile-time">#</a> <code>projectile_time</code></h3>
<p><code>projectile_time</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = projectile_time $x
# or in a pipeline:
@list |> map projectile_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-projtime">
<h3><a class="doc-anchor" href="#doc-projtime">#</a> <code>projtime</code></h3>
<p><code>projtime</code> — physics formulas builtin. Alias for <code>projectile_time</code>.</p>
<pre><code class="lang-perl">my $result = projtime $x
# or in a pipeline:
@list |> map projtime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pronic-number">
<h3><a class="doc-anchor" href="#doc-pronic-number">#</a> <code>pronic_number</code></h3>
<p><code>pronic_number</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = pronic_number $x
# or in a pipeline:
@list |> map pronic_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prop-table">
<h3><a class="doc-anchor" href="#doc-prop-table">#</a> <code>prop_table</code></h3>
<p><code>prop_table</code> — convert a count matrix to proportions (each cell / total). Like R's prop.table().</p>
<pre><code class="lang-perl">p prop_table([[10,20],[30,40]]) # [[0.1,0.2],[0.3,0.4]]
</code></pre>
</article>
<article class="doc-entry" id="doc-prop-test">
<h3><a class="doc-anchor" href="#doc-prop-test">#</a> <code>prop_test</code></h3>
<p><code>prop_test</code> — one-sample proportion z-test. Returns [z-statistic, p-value]. Like R's prop.test().</p>
<pre><code class="lang-perl">my ($z, $pval) = @{proptest(55, 100, 0.5)} # test if 55/100 differs from 50%%
</code></pre>
</article>
<article class="doc-entry" id="doc-proper-motion-apply">
<h3><a class="doc-anchor" href="#doc-proper-motion-apply">#</a> <code>proper_motion_apply</code></h3>
<p><code>proper_motion_apply</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = proper_motion_apply $x
# or in a pipeline:
@list |> map proper_motion_apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-proportional-share">
<h3><a class="doc-anchor" href="#doc-proportional-share">#</a> <code>proportional_share</code></h3>
<p><code>proportional_share</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = proportional_share $x
# or in a pipeline:
@list |> map proportional_share |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-proton-mass">
<h3><a class="doc-anchor" href="#doc-proton-mass">#</a> <code>proton_mass</code></h3>
<p><code>proton_mass</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = proton_mass $x
# or in a pipeline:
@list |> map proton_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-proximal-gradient-step">
<h3><a class="doc-anchor" href="#doc-proximal-gradient-step">#</a> <code>proximal_gradient_step</code></h3>
<p><code>proximal_gradient_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = proximal_gradient_step $x
# or in a pipeline:
@list |> map proximal_gradient_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prvp">
<h3><a class="doc-anchor" href="#doc-prvp">#</a> <code>prvp</code></h3>
<p><code>prvp</code> — number theory / primes builtin. Alias for <code>prev_prime</code>.</p>
<pre><code class="lang-perl">my $result = prvp $x
# or in a pipeline:
@list |> map prvp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pseudoprime-base2">
<h3><a class="doc-anchor" href="#doc-pseudoprime-base2">#</a> <code>pseudoprime_base2</code></h3>
<p><code>pseudoprime_base2</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = pseudoprime_base2 $x
# or in a pipeline:
@list |> map pseudoprime_base2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-psi-to-pascals">
<h3><a class="doc-anchor" href="#doc-psi-to-pascals">#</a> <code>psi_to_pascals</code></h3>
<p><code>psi_to_pascals</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = psi_to_pascals $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pt">
<h3><a class="doc-anchor" href="#doc-pt">#</a> <code>pt</code></h3>
<p><code>pt</code> — Student's t CDF. Args: x, df.</p>
<pre><code class="lang-perl">p pt(1.96, 100) # ≈ 0.975
</code></pre>
</article>
<article class="doc-entry" id="doc-ptdist">
<h3><a class="doc-anchor" href="#doc-ptdist">#</a> <code>ptdist</code></h3>
<p><code>ptdist</code> — geometry / physics builtin. Alias for <code>point_distance</code>.</p>
<pre><code class="lang-perl">my $result = ptdist $x
# or in a pipeline:
@list |> map ptdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ptinpoly">
<h3><a class="doc-anchor" href="#doc-ptinpoly">#</a> <code>ptinpoly</code></h3>
<p><code>ptinpoly</code> — geometry (extended) builtin. Alias for <code>point_in_polygon</code>.</p>
<pre><code class="lang-perl">my $result = ptinpoly $x
# or in a pipeline:
@list |> map ptinpoly |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ptri">
<h3><a class="doc-anchor" href="#doc-ptri">#</a> <code>ptri</code></h3>
<p><code>ptri</code> — geometry / physics builtin. Alias for <code>perimeter_triangle</code>.</p>
<pre><code class="lang-perl">my $result = ptri $x
# or in a pipeline:
@list |> map ptri |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pttl">
<h3><a class="doc-anchor" href="#doc-pttl">#</a> <code>pttl</code></h3>
<p><code>pttl</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = pttl $x
# or in a pipeline:
@list |> map pttl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pub">
<h3><a class="doc-anchor" href="#doc-pub">#</a> <code>pub</code></h3>
<p><code>pub</code> marks a field or method as public (default visibility).</p>
<pre><code class="lang-perl">class Example {
pub name: Str # explicitly public
pub fn greet { } # explicitly public
}
</code></pre>
</article>
<article class="doc-entry" id="doc-public-goods-game-payoff">
<h3><a class="doc-anchor" href="#doc-public-goods-game-payoff">#</a> <code>public_goods_game_payoff</code></h3>
<p><code>public_goods_game_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = public_goods_game_payoff $x
# or in a pipeline:
@list |> map public_goods_game_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pulse-pressure">
<h3><a class="doc-anchor" href="#doc-pulse-pressure">#</a> <code>pulse_pressure</code></h3>
<p><code>pulse_pressure</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = pulse_pressure $x
# or in a pipeline:
@list |> map pulse_pressure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-punct">
<h3><a class="doc-anchor" href="#doc-punct">#</a> <code>punct</code></h3>
<p><code>punctuation</code> (alias <code>punct</code>) extracts all ASCII punctuation characters from a string and returns them as a list. Filters out letters, digits, whitespace — keeps only punctuation.</p>
<pre><code class="lang-perl">p join "", punctuation("Hello, world!") # ,!
"a.b-c" |> punct |> cnt |> p # 2
</code></pre>
</article>
<article class="doc-entry" id="doc-punif">
<h3><a class="doc-anchor" href="#doc-punif">#</a> <code>punif</code></h3>
<p><code>punif</code> — uniform CDF. P(X ≤ x) for Uniform(a, b). Args: x, a, b.</p>
<pre><code class="lang-perl">p punif(0.5, 0, 1) # 0.5
p punif(3, 0, 10) # 0.3
</code></pre>
</article>
<article class="doc-entry" id="doc-punycode-decode-step">
<h3><a class="doc-anchor" href="#doc-punycode-decode-step">#</a> <code>punycode_decode_step</code></h3>
<p><code>punycode_decode_step</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = punycode_decode_step $x
# or in a pipeline:
@list |> map punycode_decode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-punycode-encode">
<h3><a class="doc-anchor" href="#doc-punycode-encode">#</a> <code>punycode_encode</code></h3>
<p><code>punycode_encode</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = punycode_encode $x
# or in a pipeline:
@list |> map punycode_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pure-state-density">
<h3><a class="doc-anchor" href="#doc-pure-state-density">#</a> <code>pure_state_density</code></h3>
<p><code>pure_state_density</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = pure_state_density $x
# or in a pipeline:
@list |> map pure_state_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-purity">
<h3><a class="doc-anchor" href="#doc-purity">#</a> <code>purity</code></h3>
<p><code>purity</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = purity $x
# or in a pipeline:
@list |> map purity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-purple">
<h3><a class="doc-anchor" href="#doc-purple">#</a> <code>purple</code></h3>
<p><code>purple</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = purple $x
# or in a pipeline:
@list |> map purple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-push-relabel-relabel">
<h3><a class="doc-anchor" href="#doc-push-relabel-relabel">#</a> <code>push_relabel_relabel</code></h3>
<p><code>push_relabel_relabel</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = push_relabel_relabel $x
# or in a pipeline:
@list |> map push_relabel_relabel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-push-relabel-step">
<h3><a class="doc-anchor" href="#doc-push-relabel-step">#</a> <code>push_relabel_step</code></h3>
<p><code>push_relabel_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = push_relabel_step $x
# or in a pipeline:
@list |> map push_relabel_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pv">
<h3><a class="doc-anchor" href="#doc-pv">#</a> <code>pv</code></h3>
<p><code>pv</code> — finance (extended) builtin.</p>
<pre><code class="lang-perl">my $result = pv $x
# or in a pipeline:
@list |> map pv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pwave-velocity-depth">
<h3><a class="doc-anchor" href="#doc-pwave-velocity-depth">#</a> <code>pwave_velocity_depth</code></h3>
<p><code>pwave_velocity_depth</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = pwave_velocity_depth $x
# or in a pipeline:
@list |> map pwave_velocity_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pwd-str">
<h3><a class="doc-anchor" href="#doc-pwd-str">#</a> <code>pwd_str</code></h3>
<p><code>pwd_str</code> — more process / system builtin. Alias for <code>cwd</code>.</p>
<pre><code class="lang-perl">my $result = pwd_str $x
# or in a pipeline:
@list |> map pwd_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pweibull">
<h3><a class="doc-anchor" href="#doc-pweibull">#</a> <code>pweibull</code></h3>
<p><code>pweibull</code> — Weibull CDF. P(X ≤ x) for Weibull(shape, scale). Args: x, shape, scale.</p>
<pre><code class="lang-perl">p pweibull(1, 1, 1) # same as exponential
</code></pre>
</article>
<article class="doc-entry" id="doc-pwi">
<h3><a class="doc-anchor" href="#doc-pwi">#</a> <code>pwi</code></h3>
<p><code>pwi</code> — python/ruby stdlib builtin. Alias for <code>pairwise_iter</code>.</p>
<pre><code class="lang-perl">my $result = pwi $x
# or in a pipeline:
@list |> map pwi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pwm-score">
<h3><a class="doc-anchor" href="#doc-pwm-score">#</a> <code>pwm_score</code></h3>
<p><code>pwm_score</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = pwm_score $x
# or in a pipeline:
@list |> map pwm_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pyramid-volume">
<h3><a class="doc-anchor" href="#doc-pyramid-volume">#</a> <code>pyramid_volume</code></h3>
<p><code>pyramid_volume($base_area, $height)</code> — computes the volume of a pyramid. Returns <code>(1/3) * base_area * height</code>.</p>
<pre><code class="lang-perl">p pyramid_volume(100, 15) # 500
</code></pre>
</article>
<article class="doc-entry" id="doc-pyrvol">
<h3><a class="doc-anchor" href="#doc-pyrvol">#</a> <code>pyrvol</code></h3>
<p><code>pyrvol</code> — geometry (extended) builtin. Alias for <code>pyramid_volume</code>.</p>
<pre><code class="lang-perl">my $result = pyrvol $x
# or in a pipeline:
@list |> map pyrvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pythagorean-expectation">
<h3><a class="doc-anchor" href="#doc-pythagorean-expectation">#</a> <code>pythagorean_expectation</code></h3>
<p><code>pythagorean_expectation</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = pythagorean_expectation $x
# or in a pipeline:
@list |> map pythagorean_expectation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pythagorean-freq">
<h3><a class="doc-anchor" href="#doc-pythagorean-freq">#</a> <code>pythagorean_freq</code></h3>
<p><code>pythagorean_freq</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = pythagorean_freq $x
# or in a pipeline:
@list |> map pythagorean_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pythagorean-ratio">
<h3><a class="doc-anchor" href="#doc-pythagorean-ratio">#</a> <code>pythagorean_ratio</code></h3>
<p><code>pythagorean_ratio</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = pythagorean_ratio $x
# or in a pipeline:
@list |> map pythagorean_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-q">
<h3><a class="doc-anchor" href="#doc-q">#</a> <code>q</code></h3>
<p><code>q</code> — quoting builtin.</p>
<pre><code class="lang-perl">my $result = q $x
# or in a pipeline:
@list |> map q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-q10">
<h3><a class="doc-anchor" href="#doc-q10">#</a> <code>q10</code></h3>
<p><code>q10</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = q10 $x
# or in a pipeline:
@list |> map q10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-q-factor-rlc">
<h3><a class="doc-anchor" href="#doc-q-factor-rlc">#</a> <code>q_factor_rlc</code></h3>
<p><code>q_factor_rlc</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = q_factor_rlc $x
# or in a pipeline:
@list |> map q_factor_rlc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-q-learning-update">
<h3><a class="doc-anchor" href="#doc-q-learning-update">#</a> <code>q_learning_update</code></h3>
<p><code>q_learning_update</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = q_learning_update $x
# or in a pipeline:
@list |> map q_learning_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qaly-lifetime">
<h3><a class="doc-anchor" href="#doc-qaly-lifetime">#</a> <code>qaly_lifetime</code></h3>
<p><code>qaly_lifetime</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = qaly_lifetime $x
# or in a pipeline:
@list |> map qaly_lifetime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qaoa-step">
<h3><a class="doc-anchor" href="#doc-qaoa-step">#</a> <code>qaoa_step</code></h3>
<p><code>qaoa_step</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qaoa_step $x
# or in a pipeline:
@list |> map qaoa_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qap-lower-bound">
<h3><a class="doc-anchor" href="#doc-qap-lower-bound">#</a> <code>qap_lower_bound</code></h3>
<p><code>qap_lower_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = qap_lower_bound $x
# or in a pipeline:
@list |> map qap_lower_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qbeta">
<h3><a class="doc-anchor" href="#doc-qbeta">#</a> <code>qbeta</code></h3>
<p><code>qbeta</code> — beta quantile. Args: p, alpha, beta.</p>
<pre><code class="lang-perl">p qbeta(0.5, 2, 5) # median of Beta(2,5)
</code></pre>
</article>
<article class="doc-entry" id="doc-qbinom">
<h3><a class="doc-anchor" href="#doc-qbinom">#</a> <code>qbinom</code></h3>
<p><code>qbinom</code> — binomial quantile (smallest k where P(X≤k) ≥ p). Args: p, n, prob.</p>
<pre><code class="lang-perl">p qbinom(0.5, 10, 0.5) # median of Binom(10, 0.5) = 5
</code></pre>
</article>
<article class="doc-entry" id="doc-qbo-oscillation-step">
<h3><a class="doc-anchor" href="#doc-qbo-oscillation-step">#</a> <code>qbo_oscillation_step</code></h3>
<p><code>qbo_oscillation_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = qbo_oscillation_step $x
# or in a pipeline:
@list |> map qbo_oscillation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qbr-metric">
<h3><a class="doc-anchor" href="#doc-qbr-metric">#</a> <code>qbr_metric</code></h3>
<p><code>qbr_metric</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = qbr_metric $x
# or in a pipeline:
@list |> map qbr_metric |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qcauchy">
<h3><a class="doc-anchor" href="#doc-qcauchy">#</a> <code>qcauchy</code></h3>
<p><code>qcauchy</code> — Cauchy quantile. Args: p [, location, scale].</p>
<pre><code class="lang-perl">p qcauchy(0.75, 0, 1) # 1.0
</code></pre>
</article>
<article class="doc-entry" id="doc-qchisq">
<h3><a class="doc-anchor" href="#doc-qchisq">#</a> <code>qchisq</code></h3>
<p><code>qchisq</code> — chi-squared quantile. Args: p, df.</p>
<pre><code class="lang-perl">p qchisq(0.95, 1) # 3.84 (critical value)
p qchisq(0.95, 5) # 11.07
</code></pre>
</article>
<article class="doc-entry" id="doc-qdisc">
<h3><a class="doc-anchor" href="#doc-qdisc">#</a> <code>qdisc</code></h3>
<p><code>quadratic_discriminant($a, $b, $c)</code> (alias <code>qdisc</code>) — computes b² - 4ac. Positive = two real roots, zero = one repeated root, negative = complex roots.</p>
<pre><code class="lang-perl">p qdisc(1, -5, 6) # 1 (two distinct real roots)
p qdisc(1, 2, 1) # 0 (one repeated root)
p qdisc(1, 2, 5) # -16 (complex roots)
</code></pre>
</article>
<article class="doc-entry" id="doc-qexp">
<h3><a class="doc-anchor" href="#doc-qexp">#</a> <code>qexp</code></h3>
<p><code>qexp</code> — exponential quantile. Args: p [, rate].</p>
<pre><code class="lang-perl">p qexp(0.5, 1) # 0.693 (median of Exp(1))
</code></pre>
</article>
<article class="doc-entry" id="doc-qf">
<h3><a class="doc-anchor" href="#doc-qf">#</a> <code>qf</code></h3>
<p><code>qf</code> — F-distribution quantile. Args: p, d1, d2.</p>
<pre><code class="lang-perl">p qf(0.95, 5, 10) # critical F value
</code></pre>
</article>
<article class="doc-entry" id="doc-qft">
<h3><a class="doc-anchor" href="#doc-qft">#</a> <code>qft</code></h3>
<p><code>qft</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qft $x
# or in a pipeline:
@list |> map qft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qft-4-real">
<h3><a class="doc-anchor" href="#doc-qft-4-real">#</a> <code>qft_4_real</code></h3>
<p><code>qft_4_real</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = qft_4_real $x
# or in a pipeline:
@list |> map qft_4_real |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qgamma">
<h3><a class="doc-anchor" href="#doc-qgamma">#</a> <code>qgamma</code></h3>
<p><code>qgamma</code> — gamma quantile (inverse CDF). Args: p, shape [, scale].</p>
<pre><code class="lang-perl">p qgamma(0.95, 2, 1) # 95th percentile of Gamma(2,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-qho-ground-state">
<h3><a class="doc-anchor" href="#doc-qho-ground-state">#</a> <code>qho_ground_state</code></h3>
<p><code>qho_ground_state</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = qho_ground_state $x
# or in a pipeline:
@list |> map qho_ground_state |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qlnorm">
<h3><a class="doc-anchor" href="#doc-qlnorm">#</a> <code>qlnorm</code></h3>
<p><code>qlnorm</code> — log-normal quantile. Args: p [, mu, sigma].</p>
<pre><code class="lang-perl">p qlnorm(0.5, 0, 1) # 1.0 (median of LogN(0,1))
</code></pre>
</article>
<article class="doc-entry" id="doc-qm">
<h3><a class="doc-anchor" href="#doc-qm">#</a> <code>qm</code></h3>
<p><code>qm</code> — string builtin. Alias for <code>quotemeta</code>.</p>
<pre><code class="lang-perl">my $result = qm $x
# or in a pipeline:
@list |> map qm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qnorm">
<h3><a class="doc-anchor" href="#doc-qnorm">#</a> <code>qnorm</code></h3>
<p><code>qnorm</code> — normal quantile (inverse CDF). Returns x such that P(X ≤ x) = p. Args: p [, mu, sigma].</p>
<pre><code class="lang-perl">p qnorm(0.975) # 1.96
p qnorm(0.5) # 0.0
p qnorm(0.95, 100, 15) # 90th percentile IQ
</code></pre>
</article>
<article class="doc-entry" id="doc-qntl">
<h3><a class="doc-anchor" href="#doc-qntl">#</a> <code>qntl</code></h3>
<p><code>qntl</code> — extended stdlib builtin. Alias for <code>quantile</code>.</p>
<pre><code class="lang-perl">my $result = qntl $x
# or in a pipeline:
@list |> map qntl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qntls">
<h3><a class="doc-anchor" href="#doc-qntls">#</a> <code>qntls</code></h3>
<p><code>quantiles \@DATA, \@PROBS</code> — batch quantile lookup. Returns one element per probability in <code>\@PROBS</code>, computed via the same linear interpolation as <code>quantile</code>. Sorts the data exactly once across all probability points so callers don't pay an O(n log n) sort per quantile. Probabilities outside [0,1] are clamped.</p>
<pre><code class="lang-perl">my @d = (1..1000)
my @qs = quantiles(\@d, [0.25, 0.5, 0.75])
printf "q25=%.2f q50=%.2f q75=%.2f\n", @qs
# q25=250.75 q50=500.50 q75=750.25
</code></pre>
</article>
<article class="doc-entry" id="doc-qpe-iteration">
<h3><a class="doc-anchor" href="#doc-qpe-iteration">#</a> <code>qpe_iteration</code></h3>
<p><code>qpe_iteration</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qpe_iteration $x
# or in a pipeline:
@list |> map qpe_iteration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qpois">
<h3><a class="doc-anchor" href="#doc-qpois">#</a> <code>qpois</code></h3>
<p><code>qpois</code> — Poisson quantile (smallest k where P(X≤k) ≥ p). Args: p, lambda.</p>
<pre><code class="lang-perl">p qpois(0.5, 5) # median of Poisson(5)
</code></pre>
</article>
<article class="doc-entry" id="doc-qq">
<h3><a class="doc-anchor" href="#doc-qq">#</a> <code>qq</code></h3>
<p><code>qq</code> — quoting builtin.</p>
<pre><code class="lang-perl">my $result = qq $x
# or in a pipeline:
@list |> map qq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qroots">
<h3><a class="doc-anchor" href="#doc-qroots">#</a> <code>qroots</code></h3>
<p><code>quadratic_roots($a, $b, $c)</code> (alias <code>qroots</code>) — solves ax² + bx + c = 0. Returns [x1, x2] for real roots, undef if no real solutions (discriminant < 0).</p>
<pre><code class="lang-perl">my @roots = quadratic_roots(1, -5, 6) # [3, 2] (x² - 5x + 6 = 0)
p qroots(1, 0, -4) # [2, -2]
p qroots(1, 2, 5) # undef (complex roots)
</code></pre>
</article>
<article class="doc-entry" id="doc-qs-relation">
<h3><a class="doc-anchor" href="#doc-qs-relation">#</a> <code>qs_relation</code></h3>
<p><code>qs_relation</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = qs_relation $x
# or in a pipeline:
@list |> map qs_relation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qt">
<h3><a class="doc-anchor" href="#doc-qt">#</a> <code>qt</code></h3>
<p><code>qt</code> — Student's t quantile. Args: p, df.</p>
<pre><code class="lang-perl">p qt(0.975, 10) # ≈ 2.228 (two-tailed 5%)
</code></pre>
</article>
<article class="doc-entry" id="doc-quadratic-assignment-step">
<h3><a class="doc-anchor" href="#doc-quadratic-assignment-step">#</a> <code>quadratic_assignment_step</code></h3>
<p><code>quadratic_assignment_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = quadratic_assignment_step $x
# or in a pipeline:
@list |> map quadratic_assignment_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quadratic-mean-arr">
<h3><a class="doc-anchor" href="#doc-quadratic-mean-arr">#</a> <code>quadratic_mean_arr</code></h3>
<p><code>quadratic_mean_arr</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = quadratic_mean_arr $x
# or in a pipeline:
@list |> map quadratic_mean_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantal-response-logit">
<h3><a class="doc-anchor" href="#doc-quantal-response-logit">#</a> <code>quantal_response_logit</code></h3>
<p><code>quantal_response_logit</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = quantal_response_logit $x
# or in a pipeline:
@list |> map quantal_response_logit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantile">
<h3><a class="doc-anchor" href="#doc-quantile">#</a> <code>quantile</code></h3>
<p><code>quantile</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = quantile $x
# or in a pipeline:
@list |> map quantile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantile-p">
<h3><a class="doc-anchor" href="#doc-quantile-p">#</a> <code>quantile_p</code></h3>
<p><code>quantile_p</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = quantile_p $x
# or in a pipeline:
@list |> map quantile_p |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantize">
<h3><a class="doc-anchor" href="#doc-quantize">#</a> <code>quantize</code></h3>
<p><code>quantize</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = quantize $x
# or in a pipeline:
@list |> map quantize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quanto-adjustment">
<h3><a class="doc-anchor" href="#doc-quanto-adjustment">#</a> <code>quanto_adjustment</code></h3>
<p><code>quanto_adjustment</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = quanto_adjustment $input
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-dimension-q">
<h3><a class="doc-anchor" href="#doc-quantum-dimension-q">#</a> <code>quantum_dimension_q</code></h3>
<p><code>quantum_dimension_q</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_dimension_q $x
# or in a pipeline:
@list |> map quantum_dimension_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-dimension-su2">
<h3><a class="doc-anchor" href="#doc-quantum-dimension-su2">#</a> <code>quantum_dimension_su2</code></h3>
<p><code>quantum_dimension_su2</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_dimension_su2 $x
# or in a pipeline:
@list |> map quantum_dimension_su2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-efficiency-photo">
<h3><a class="doc-anchor" href="#doc-quantum-efficiency-photo">#</a> <code>quantum_efficiency_photo</code></h3>
<p><code>quantum_efficiency_photo</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_efficiency_photo $x
# or in a pipeline:
@list |> map quantum_efficiency_photo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-fidelity-pure">
<h3><a class="doc-anchor" href="#doc-quantum-fidelity-pure">#</a> <code>quantum_fidelity_pure</code></h3>
<p><code>quantum_fidelity_pure</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_fidelity_pure $x
# or in a pipeline:
@list |> map quantum_fidelity_pure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-fisher-info">
<h3><a class="doc-anchor" href="#doc-quantum-fisher-info">#</a> <code>quantum_fisher_info</code></h3>
<p><code>quantum_fisher_info</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_fisher_info $x
# or in a pipeline:
@list |> map quantum_fisher_info |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-invariant-eval">
<h3><a class="doc-anchor" href="#doc-quantum-invariant-eval">#</a> <code>quantum_invariant_eval</code></h3>
<p><code>quantum_invariant_eval</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_invariant_eval $x
# or in a pipeline:
@list |> map quantum_invariant_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-mutual-info">
<h3><a class="doc-anchor" href="#doc-quantum-mutual-info">#</a> <code>quantum_mutual_info</code></h3>
<p><code>quantum_mutual_info</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_mutual_info $x
# or in a pipeline:
@list |> map quantum_mutual_info |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-relative-entropy">
<h3><a class="doc-anchor" href="#doc-quantum-relative-entropy">#</a> <code>quantum_relative_entropy</code></h3>
<p><code>quantum_relative_entropy</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_relative_entropy $x
# or in a pipeline:
@list |> map quantum_relative_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-teleportation">
<h3><a class="doc-anchor" href="#doc-quantum-teleportation">#</a> <code>quantum_teleportation</code></h3>
<p><code>quantum_teleportation</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_teleportation $x
# or in a pipeline:
@list |> map quantum_teleportation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quantum-variance">
<h3><a class="doc-anchor" href="#doc-quantum-variance">#</a> <code>quantum_variance</code></h3>
<p><code>quantum_variance</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = quantum_variance $x
# or in a pipeline:
@list |> map quantum_variance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quarter-of">
<h3><a class="doc-anchor" href="#doc-quarter-of">#</a> <code>quarter_of</code></h3>
<p><code>quarter_of</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = quarter_of $x
# or in a pipeline:
@list |> map quarter_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quarter-of-year">
<h3><a class="doc-anchor" href="#doc-quarter-of-year">#</a> <code>quarter_of_year</code></h3>
<p><code>quarter_of_year</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = quarter_of_year $x
# or in a pipeline:
@list |> map quarter_of_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quartile-exc">
<h3><a class="doc-anchor" href="#doc-quartile-exc">#</a> <code>quartile_exc</code></h3>
<p><code>quartile_exc</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = quartile_exc $x
# or in a pipeline:
@list |> map quartile_exc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quartile-inc">
<h3><a class="doc-anchor" href="#doc-quartile-inc">#</a> <code>quartile_inc</code></h3>
<p><code>quartile_inc</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = quartile_inc $x
# or in a pipeline:
@list |> map quartile_inc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quartiles">
<h3><a class="doc-anchor" href="#doc-quartiles">#</a> <code>quartiles</code></h3>
<p><code>quartiles(@data)</code> — returns the three quartile values [Q1, Q2, Q3] of a dataset. Q1 is the 25th percentile, Q2 is the median (50th), Q3 is the 75th percentile. Useful for understanding data distribution and computing IQR.</p>
<pre><code class="lang-perl">my @data = 1:100
my $q = quartiles(@data)
p "Q1=$q->[0] Q2=$q->[1] Q3=$q->[2]"
</code></pre>
</article>
<article class="doc-entry" id="doc-quarts">
<h3><a class="doc-anchor" href="#doc-quarts">#</a> <code>quarts</code></h3>
<p><code>quarts</code> — statistics (extended) builtin. Alias for <code>quartiles</code>.</p>
<pre><code class="lang-perl">my $result = quarts $x
# or in a pipeline:
@list |> map quarts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quasi-geostrophic-omega">
<h3><a class="doc-anchor" href="#doc-quasi-geostrophic-omega">#</a> <code>quasi_geostrophic_omega</code></h3>
<p><code>quasi_geostrophic_omega</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = quasi_geostrophic_omega $x
# or in a pipeline:
@list |> map quasi_geostrophic_omega |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quaternion-from-imu">
<h3><a class="doc-anchor" href="#doc-quaternion-from-imu">#</a> <code>quaternion_from_imu</code></h3>
<p><code>quaternion_from_imu</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = quaternion_from_imu $x
# or in a pipeline:
@list |> map quaternion_from_imu |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-ccx">
<h3><a class="doc-anchor" href="#doc-qubit-ccx">#</a> <code>qubit_ccx</code></h3>
<p><code>qubit_ccx</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_ccx $x
# or in a pipeline:
@list |> map qubit_ccx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-cnot">
<h3><a class="doc-anchor" href="#doc-qubit-cnot">#</a> <code>qubit_cnot</code></h3>
<p><code>qubit_cnot</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_cnot $x
# or in a pipeline:
@list |> map qubit_cnot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-cz">
<h3><a class="doc-anchor" href="#doc-qubit-cz">#</a> <code>qubit_cz</code></h3>
<p><code>qubit_cz</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_cz $x
# or in a pipeline:
@list |> map qubit_cz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-h">
<h3><a class="doc-anchor" href="#doc-qubit-h">#</a> <code>qubit_h</code></h3>
<p><code>qubit_h</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_h $x
# or in a pipeline:
@list |> map qubit_h |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-measure">
<h3><a class="doc-anchor" href="#doc-qubit-measure">#</a> <code>qubit_measure</code></h3>
<p><code>qubit_measure</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_measure $x
# or in a pipeline:
@list |> map qubit_measure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-phase">
<h3><a class="doc-anchor" href="#doc-qubit-phase">#</a> <code>qubit_phase</code></h3>
<p><code>qubit_phase</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_phase $x
# or in a pipeline:
@list |> map qubit_phase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-reset">
<h3><a class="doc-anchor" href="#doc-qubit-reset">#</a> <code>qubit_reset</code></h3>
<p><code>qubit_reset</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_reset $x
# or in a pipeline:
@list |> map qubit_reset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-rx">
<h3><a class="doc-anchor" href="#doc-qubit-rx">#</a> <code>qubit_rx</code></h3>
<p><code>qubit_rx</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_rx $x
# or in a pipeline:
@list |> map qubit_rx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-ry">
<h3><a class="doc-anchor" href="#doc-qubit-ry">#</a> <code>qubit_ry</code></h3>
<p><code>qubit_ry</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_ry $x
# or in a pipeline:
@list |> map qubit_ry |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-rz">
<h3><a class="doc-anchor" href="#doc-qubit-rz">#</a> <code>qubit_rz</code></h3>
<p><code>qubit_rz</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_rz $x
# or in a pipeline:
@list |> map qubit_rz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-s">
<h3><a class="doc-anchor" href="#doc-qubit-s">#</a> <code>qubit_s</code></h3>
<p><code>qubit_s</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_s $x
# or in a pipeline:
@list |> map qubit_s |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-swap">
<h3><a class="doc-anchor" href="#doc-qubit-swap">#</a> <code>qubit_swap</code></h3>
<p><code>qubit_swap</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_swap $x
# or in a pipeline:
@list |> map qubit_swap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-t">
<h3><a class="doc-anchor" href="#doc-qubit-t">#</a> <code>qubit_t</code></h3>
<p><code>qubit_t</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_t $x
# or in a pipeline:
@list |> map qubit_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-u1">
<h3><a class="doc-anchor" href="#doc-qubit-u1">#</a> <code>qubit_u1</code></h3>
<p><code>qubit_u1</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_u1 $x
# or in a pipeline:
@list |> map qubit_u1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-u2">
<h3><a class="doc-anchor" href="#doc-qubit-u2">#</a> <code>qubit_u2</code></h3>
<p><code>qubit_u2</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_u2 $x
# or in a pipeline:
@list |> map qubit_u2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-u3">
<h3><a class="doc-anchor" href="#doc-qubit-u3">#</a> <code>qubit_u3</code></h3>
<p><code>qubit_u3</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_u3 $x
# or in a pipeline:
@list |> map qubit_u3 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-x">
<h3><a class="doc-anchor" href="#doc-qubit-x">#</a> <code>qubit_x</code></h3>
<p><code>qubit_x</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_x $x
# or in a pipeline:
@list |> map qubit_x |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-y">
<h3><a class="doc-anchor" href="#doc-qubit-y">#</a> <code>qubit_y</code></h3>
<p><code>qubit_y</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_y $x
# or in a pipeline:
@list |> map qubit_y |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qubit-z">
<h3><a class="doc-anchor" href="#doc-qubit-z">#</a> <code>qubit_z</code></h3>
<p><code>qubit_z</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = qubit_z $x
# or in a pipeline:
@list |> map qubit_z |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-queue-new">
<h3><a class="doc-anchor" href="#doc-queue-new">#</a> <code>queue_new</code></h3>
<p><code>queue_new</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = queue_new $x
# or in a pipeline:
@list |> map queue_new |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quiver-path-count">
<h3><a class="doc-anchor" href="#doc-quiver-path-count">#</a> <code>quiver_path_count</code></h3>
<p><code>quiver_path_count</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = quiver_path_count $x
# or in a pipeline:
@list |> map quiver_path_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qunif">
<h3><a class="doc-anchor" href="#doc-qunif">#</a> <code>qunif</code></h3>
<p><code>qunif</code> — uniform quantile. Args: p [, min, max].</p>
<pre><code class="lang-perl">p qunif(0.5, 0, 10) # 5.0 (median)
</code></pre>
</article>
<article class="doc-entry" id="doc-quote">
<h3><a class="doc-anchor" href="#doc-quote">#</a> <code>quote</code></h3>
<p><code>quote</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = quote $x
# or in a pipeline:
@list |> map quote |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quoted-printable-encode">
<h3><a class="doc-anchor" href="#doc-quoted-printable-encode">#</a> <code>quoted_printable_encode</code></h3>
<p><code>quoted_printable_encode</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = quoted_printable_encode $x
# or in a pipeline:
@list |> map quoted_printable_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qw">
<h3><a class="doc-anchor" href="#doc-qw">#</a> <code>qw</code></h3>
<p><code>qw</code> — quoting builtin.</p>
<pre><code class="lang-perl">my $result = qw $x
# or in a pipeline:
@list |> map qw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qweibull">
<h3><a class="doc-anchor" href="#doc-qweibull">#</a> <code>qweibull</code></h3>
<p><code>qweibull</code> — Weibull quantile. Args: p, shape [, scale].</p>
<pre><code class="lang-perl">p qweibull(0.5, 1, 1) # same as qexp
</code></pre>
</article>
<article class="doc-entry" id="doc-r0-basic">
<h3><a class="doc-anchor" href="#doc-r0-basic">#</a> <code>r0_basic</code></h3>
<p><code>r0_basic</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = r0_basic $x
# or in a pipeline:
@list |> map r0_basic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-r2d">
<h3><a class="doc-anchor" href="#doc-r2d">#</a> <code>r2d</code></h3>
<p><code>r2d</code> — trivial numeric / predicate builtins builtin. Alias for <code>rad_to_deg</code>.</p>
<pre><code class="lang-perl">my $result = r2d $x
# or in a pipeline:
@list |> map r2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-r72">
<h3><a class="doc-anchor" href="#doc-r72">#</a> <code>r72</code></h3>
<p><code>rule_of_72($rate)</code> (alias <code>r72</code>) — estimates years to double investment using the Rule of 72: 72 / (rate × 100). Quick mental math approximation.</p>
<pre><code class="lang-perl">p r72(0.06) # 12 years to double at 6%
p r72(0.10) # 7.2 years at 10%
</code></pre>
</article>
<article class="doc-entry" id="doc-r-effective-t">
<h3><a class="doc-anchor" href="#doc-r-effective-t">#</a> <code>r_effective_t</code></h3>
<p><code>r_effective_t</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = r_effective_t $x
# or in a pipeline:
@list |> map r_effective_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-r-naught-basic">
<h3><a class="doc-anchor" href="#doc-r-naught-basic">#</a> <code>r_naught_basic</code></h3>
<p><code>r_naught_basic</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = r_naught_basic $x
# or in a pipeline:
@list |> map r_naught_basic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-r-parallel">
<h3><a class="doc-anchor" href="#doc-r-parallel">#</a> <code>r_parallel</code></h3>
<p><code>r_parallel</code> — batch 12 builtin. Alias for <code>resistance_parallel</code>.</p>
<pre><code class="lang-perl">my $result = r_parallel $x
# or in a pipeline:
@list |> map r_parallel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-r-series">
<h3><a class="doc-anchor" href="#doc-r-series">#</a> <code>r_series</code></h3>
<p><code>r_series</code> — batch 12 builtin. Alias for <code>resistance_series</code>.</p>
<pre><code class="lang-perl">my $result = r_series $x
# or in a pipeline:
@list |> map r_series |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-r-squared">
<h3><a class="doc-anchor" href="#doc-r-squared">#</a> <code>r_squared</code></h3>
<p><code>r_squared</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = r_squared $x
# or in a pipeline:
@list |> map r_squared |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ra-dec-to-alt-az">
<h3><a class="doc-anchor" href="#doc-ra-dec-to-alt-az">#</a> <code>ra_dec_to_alt_az</code></h3>
<p><code>ra_dec_to_alt_az</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = ra_dec_to_alt_az $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ra-dec-to-az-alt">
<h3><a class="doc-anchor" href="#doc-ra-dec-to-az-alt">#</a> <code>ra_dec_to_az_alt</code></h3>
<p><code>ra_dec_to_az_alt</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = ra_dec_to_az_alt $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rabi-frequency">
<h3><a class="doc-anchor" href="#doc-rabi-frequency">#</a> <code>rabi_frequency</code></h3>
<p><code>rabi_frequency</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = rabi_frequency $x
# or in a pipeline:
@list |> map rabi_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rabin-karp-hash">
<h3><a class="doc-anchor" href="#doc-rabin-karp-hash">#</a> <code>rabin_karp_hash</code></h3>
<p><code>rabin_karp_hash</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = rabin_karp_hash $x
# or in a pipeline:
@list |> map rabin_karp_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rad-to-deg">
<h3><a class="doc-anchor" href="#doc-rad-to-deg">#</a> <code>rad_to_deg</code></h3>
<p><code>rad_to_deg</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = rad_to_deg $input
</code></pre>
</article>
<article class="doc-entry" id="doc-radd">
<h3><a class="doc-anchor" href="#doc-radd">#</a> <code>radd</code></h3>
<p><code>radd</code> — roman numerals builtin. Alias for <code>roman_add</code>.</p>
<pre><code class="lang-perl">my $result = radd $x
# or in a pipeline:
@list |> map radd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-radians">
<h3><a class="doc-anchor" href="#doc-radians">#</a> <code>radians</code></h3>
<p><code>radians</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = radians $x
# or in a pipeline:
@list |> map radians |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-radiation-pressure">
<h3><a class="doc-anchor" href="#doc-radiation-pressure">#</a> <code>radiation_pressure</code></h3>
<p><code>radiation_pressure</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = radiation_pressure $x
# or in a pipeline:
@list |> map radiation_pressure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-radius-bfs">
<h3><a class="doc-anchor" href="#doc-radius-bfs">#</a> <code>radius_bfs</code></h3>
<p><code>radius_bfs</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = radius_bfs $x
# or in a pipeline:
@list |> map radius_bfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ragone-point">
<h3><a class="doc-anchor" href="#doc-ragone-point">#</a> <code>ragone_point</code></h3>
<p><code>ragone_point</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = ragone_point $x
# or in a pipeline:
@list |> map ragone_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-railfence-encrypt">
<h3><a class="doc-anchor" href="#doc-railfence-encrypt">#</a> <code>railfence_encrypt</code></h3>
<p><code>railfence_encrypt</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = railfence_encrypt $x
# or in a pipeline:
@list |> map railfence_encrypt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ramachandran-phi-psi">
<h3><a class="doc-anchor" href="#doc-ramachandran-phi-psi">#</a> <code>ramachandran_phi_psi</code></h3>
<p><code>ramachandran_phi_psi</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = ramachandran_phi_psi $x
# or in a pipeline:
@list |> map ramachandran_phi_psi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ramsey-reset-test">
<h3><a class="doc-anchor" href="#doc-ramsey-reset-test">#</a> <code>ramsey_reset_test</code></h3>
<p><code>ramsey_reset_test</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = ramsey_reset_test $x
# or in a pipeline:
@list |> map ramsey_reset_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ramsey-visibility">
<h3><a class="doc-anchor" href="#doc-ramsey-visibility">#</a> <code>ramsey_visibility</code></h3>
<p><code>ramsey_visibility</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = ramsey_visibility $x
# or in a pipeline:
@list |> map ramsey_visibility |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-randles-circuit-z">
<h3><a class="doc-anchor" href="#doc-randles-circuit-z">#</a> <code>randles_circuit_z</code></h3>
<p><code>randles_circuit_z</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = randles_circuit_z $x
# or in a pipeline:
@list |> map randles_circuit_z |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-randles-sevcik-peak">
<h3><a class="doc-anchor" href="#doc-randles-sevcik-peak">#</a> <code>randles_sevcik_peak</code></h3>
<p><code>randles_sevcik_peak</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = randles_sevcik_peak $x
# or in a pipeline:
@list |> map randles_sevcik_peak |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-alpha">
<h3><a class="doc-anchor" href="#doc-random-alpha">#</a> <code>random_alpha</code></h3>
<p><code>random_alpha</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_alpha $x
# or in a pipeline:
@list |> map random_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-between">
<h3><a class="doc-anchor" href="#doc-random-between">#</a> <code>random_between</code></h3>
<p><code>random_between</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_between $x
# or in a pipeline:
@list |> map random_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-bool">
<h3><a class="doc-anchor" href="#doc-random-bool">#</a> <code>random_bool</code></h3>
<p><code>random_bool</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_bool $x
# or in a pipeline:
@list |> map random_bool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-char">
<h3><a class="doc-anchor" href="#doc-random-char">#</a> <code>random_char</code></h3>
<p><code>random_char</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = random_char $x
# or in a pipeline:
@list |> map random_char |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-choice">
<h3><a class="doc-anchor" href="#doc-random-choice">#</a> <code>random_choice</code></h3>
<p><code>random_choice</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_choice $x
# or in a pipeline:
@list |> map random_choice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-color">
<h3><a class="doc-anchor" href="#doc-random-color">#</a> <code>random_color</code></h3>
<p><code>random_color</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = random_color $x
# or in a pipeline:
@list |> map random_color |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-digit">
<h3><a class="doc-anchor" href="#doc-random-digit">#</a> <code>random_digit</code></h3>
<p><code>random_digit</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_digit $x
# or in a pipeline:
@list |> map random_digit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-float">
<h3><a class="doc-anchor" href="#doc-random-float">#</a> <code>random_float</code></h3>
<p><code>random_float</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_float $x
# or in a pipeline:
@list |> map random_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-int">
<h3><a class="doc-anchor" href="#doc-random-int">#</a> <code>random_int</code></h3>
<p><code>random_int</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_int $x
# or in a pipeline:
@list |> map random_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-sample">
<h3><a class="doc-anchor" href="#doc-random-sample">#</a> <code>random_sample</code></h3>
<p><code>random_sample</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = random_sample $x
# or in a pipeline:
@list |> map random_sample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-string">
<h3><a class="doc-anchor" href="#doc-random-string">#</a> <code>random_string</code></h3>
<p><code>random_string</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_string $x
# or in a pipeline:
@list |> map random_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-walk-drift-step">
<h3><a class="doc-anchor" href="#doc-random-walk-drift-step">#</a> <code>random_walk_drift_step</code></h3>
<p><code>random_walk_drift_step</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = random_walk_drift_step $x
# or in a pipeline:
@list |> map random_walk_drift_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-walk-hitting">
<h3><a class="doc-anchor" href="#doc-random-walk-hitting">#</a> <code>random_walk_hitting</code></h3>
<p><code>random_walk_hitting</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = random_walk_hitting $x
# or in a pipeline:
@list |> map random_walk_hitting |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-walk-innovation">
<h3><a class="doc-anchor" href="#doc-random-walk-innovation">#</a> <code>random_walk_innovation</code></h3>
<p><code>random_walk_innovation</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = random_walk_innovation $x
# or in a pipeline:
@list |> map random_walk_innovation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-coding-step">
<h3><a class="doc-anchor" href="#doc-range-coding-step">#</a> <code>range_coding_step</code></h3>
<p><code>range_coding_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = range_coding_step $x
# or in a pipeline:
@list |> map range_coding_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-compress">
<h3><a class="doc-anchor" href="#doc-range-compress">#</a> <code>range_compress</code></h3>
<p><code>range_compress</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = range_compress $x
# or in a pipeline:
@list |> map range_compress |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-decode-step">
<h3><a class="doc-anchor" href="#doc-range-decode-step">#</a> <code>range_decode_step</code></h3>
<p><code>range_decode_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = range_decode_step $x
# or in a pipeline:
@list |> map range_decode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-exclusive">
<h3><a class="doc-anchor" href="#doc-range-exclusive">#</a> <code>range_exclusive</code></h3>
<p><code>range_exclusive</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = range_exclusive $x
# or in a pipeline:
@list |> map range_exclusive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-expand">
<h3><a class="doc-anchor" href="#doc-range-expand">#</a> <code>range_expand</code></h3>
<p><code>range_expand</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = range_expand $x
# or in a pipeline:
@list |> map range_expand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-header-parse">
<h3><a class="doc-anchor" href="#doc-range-header-parse">#</a> <code>range_header_parse</code></h3>
<p><code>range_header_parse</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = range_header_parse $x
# or in a pipeline:
@list |> map range_header_parse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-inclusive">
<h3><a class="doc-anchor" href="#doc-range-inclusive">#</a> <code>range_inclusive</code></h3>
<p><code>range_inclusive</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = range_inclusive $x
# or in a pipeline:
@list |> map range_inclusive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-of">
<h3><a class="doc-anchor" href="#doc-range-of">#</a> <code>range_of</code></h3>
<p><code>range_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = range_of $x
# or in a pipeline:
@list |> map range_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-voting-score">
<h3><a class="doc-anchor" href="#doc-range-voting-score">#</a> <code>range_voting_score</code></h3>
<p><code>range_voting_score</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = range_voting_score $x
# or in a pipeline:
@list |> map range_voting_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rank">
<h3><a class="doc-anchor" href="#doc-rank">#</a> <code>rank</code></h3>
<p><code>rank</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = rank $x
# or in a pipeline:
@list |> map rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rank-avg">
<h3><a class="doc-anchor" href="#doc-rank-avg">#</a> <code>rank_avg</code></h3>
<p><code>rank_avg</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = rank_avg $x
# or in a pipeline:
@list |> map rank_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rank-eq">
<h3><a class="doc-anchor" href="#doc-rank-eq">#</a> <code>rank_eq</code></h3>
<p><code>rank_eq</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = rank_eq $x
# or in a pipeline:
@list |> map rank_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ransac-homography">
<h3><a class="doc-anchor" href="#doc-ransac-homography">#</a> <code>ransac_homography</code></h3>
<p><code>ransac_homography</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = ransac_homography $x
# or in a pipeline:
@list |> map ransac_homography |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ransac-iteration-count">
<h3><a class="doc-anchor" href="#doc-ransac-iteration-count">#</a> <code>ransac_iteration_count</code></h3>
<p><code>ransac_iteration_count</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = ransac_iteration_count $x
# or in a pipeline:
@list |> map ransac_iteration_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rao-quadratic-entropy">
<h3><a class="doc-anchor" href="#doc-rao-quadratic-entropy">#</a> <code>rao_quadratic_entropy</code></h3>
<p><code>rao_quadratic_entropy</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = rao_quadratic_entropy $x
# or in a pipeline:
@list |> map rao_quadratic_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-raoult-law">
<h3><a class="doc-anchor" href="#doc-raoult-law">#</a> <code>raoult_law</code></h3>
<p><code>raoult_law</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = raoult_law $x
# or in a pipeline:
@list |> map raoult_law |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rapid-blink">
<h3><a class="doc-anchor" href="#doc-rapid-blink">#</a> <code>rapid_blink</code></h3>
<p><code>rapid_blink</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = rapid_blink $x
# or in a pipeline:
@list |> map rapid_blink |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rate">
<h3><a class="doc-anchor" href="#doc-rate">#</a> <code>rate</code></h3>
<p><code>rate</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = rate $x
# or in a pipeline:
@list |> map rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-raychaudhuri-step">
<h3><a class="doc-anchor" href="#doc-raychaudhuri-step">#</a> <code>raychaudhuri_step</code></h3>
<p><code>raychaudhuri_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = raychaudhuri_step $x
# or in a pipeline:
@list |> map raychaudhuri_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rayleigh-criterion">
<h3><a class="doc-anchor" href="#doc-rayleigh-criterion">#</a> <code>rayleigh_criterion</code></h3>
<p><code>rayleigh_criterion</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = rayleigh_criterion $x
# or in a pipeline:
@list |> map rayleigh_criterion |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rayleigh-number-step">
<h3><a class="doc-anchor" href="#doc-rayleigh-number-step">#</a> <code>rayleigh_number_step</code></h3>
<p><code>rayleigh_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = rayleigh_number_step $x
# or in a pipeline:
@list |> map rayleigh_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rayleigh-resolution">
<h3><a class="doc-anchor" href="#doc-rayleigh-resolution">#</a> <code>rayleigh_resolution</code></h3>
<p><code>rayleigh_resolution</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = rayleigh_resolution $x
# or in a pipeline:
@list |> map rayleigh_resolution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rb">
<h3><a class="doc-anchor" href="#doc-rb">#</a> <code>rb</code></h3>
<p><code>rb</code> — filesystem extensions builtin. Alias for <code>read_bytes</code>.</p>
<pre><code class="lang-perl">my $result = rb $x
# or in a pipeline:
@list |> map rb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rbeta">
<h3><a class="doc-anchor" href="#doc-rbeta">#</a> <code>rbeta</code></h3>
<p><code>rbeta</code> — generate n random beta variates. Args: n, alpha, beta. Like R's rbeta().</p>
<pre><code class="lang-perl">my @x = @{rbeta(100, 2, 5)} # Beta(2,5)
</code></pre>
</article>
<article class="doc-entry" id="doc-rbind">
<h3><a class="doc-anchor" href="#doc-rbind">#</a> <code>rbind</code></h3>
<p><code>rbind</code> — bind matrices/vectors by rows (vertical stack). Like R's rbind().</p>
<pre><code class="lang-perl">my $m = rbind([1,2,3], [4,5,6]) # [[1,2,3],[4,5,6]]
</code></pre>
</article>
<article class="doc-entry" id="doc-rbinom">
<h3><a class="doc-anchor" href="#doc-rbinom">#</a> <code>rbinom</code></h3>
<p><code>rbinom</code> — generate n random binomial variates. Args: n, size, prob. Like R's rbinom().</p>
<pre><code class="lang-perl">my @x = @{rbinom(100, 10, 0.3)} # 100 draws from Binom(10,0.3)
</code></pre>
</article>
<article class="doc-entry" id="doc-rc-tau">
<h3><a class="doc-anchor" href="#doc-rc-tau">#</a> <code>rc_tau</code></h3>
<p><code>rc_tau</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = rc_tau $x
# or in a pipeline:
@list |> map rc_tau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rc-time-constant">
<h3><a class="doc-anchor" href="#doc-rc-time-constant">#</a> <code>rc_time_constant</code></h3>
<p><code>rc_time_constant</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = rc_time_constant $x
# or in a pipeline:
@list |> map rc_time_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rcauchy">
<h3><a class="doc-anchor" href="#doc-rcauchy">#</a> <code>rcauchy</code></h3>
<p><code>rcauchy</code> — generate n random Cauchy variates. Args: n [, location, scale].</p>
<pre><code class="lang-perl">my @x = @{rcauchy(100, 0, 1)} # standard Cauchy
</code></pre>
</article>
<article class="doc-entry" id="doc-rchisq">
<h3><a class="doc-anchor" href="#doc-rchisq">#</a> <code>rchisq</code></h3>
<p><code>rchisq</code> — generate n random chi-squared variates. Args: n, df. Like R's rchisq().</p>
<pre><code class="lang-perl">my @x = @{rchisq(100, 5)} # Chi-sq with 5 df
</code></pre>
</article>
<article class="doc-entry" id="doc-rcolor">
<h3><a class="doc-anchor" href="#doc-rcolor">#</a> <code>rcolor</code></h3>
<p><code>rcolor</code> — color operations builtin. Alias for <code>random_color</code>.</p>
<pre><code class="lang-perl">my $result = rcolor $x
# or in a pipeline:
@list |> map rcolor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rctau">
<h3><a class="doc-anchor" href="#doc-rctau">#</a> <code>rctau</code></h3>
<p><code>rctau</code> — physics formulas builtin. Alias for <code>rc_time_constant</code>.</p>
<pre><code class="lang-perl">my $result = rctau $x
# or in a pipeline:
@list |> map rctau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rdcs">
<h3><a class="doc-anchor" href="#doc-rdcs">#</a> <code>rdcs</code></h3>
<p><code>rdcs</code> — algebraic match builtin. Alias for <code>reductions</code>.</p>
<pre><code class="lang-perl">my $result = rdcs $x
# or in a pipeline:
@list |> map rdcs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rdd-estimate">
<h3><a class="doc-anchor" href="#doc-rdd-estimate">#</a> <code>rdd_estimate</code></h3>
<p><code>rdd_estimate</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = rdd_estimate $x
# or in a pipeline:
@list |> map rdd_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-escape">
<h3><a class="doc-anchor" href="#doc-re-escape">#</a> <code>re_escape</code></h3>
<p><code>re_escape</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_escape $x
# or in a pipeline:
@list |> map re_escape |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-find-all">
<h3><a class="doc-anchor" href="#doc-re-find-all">#</a> <code>re_find_all</code></h3>
<p><code>re_find_all</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_find_all $x
# or in a pipeline:
@list |> map re_find_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-groups">
<h3><a class="doc-anchor" href="#doc-re-groups">#</a> <code>re_groups</code></h3>
<p><code>re_groups</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_groups $x
# or in a pipeline:
@list |> map re_groups |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-match">
<h3><a class="doc-anchor" href="#doc-re-match">#</a> <code>re_match</code></h3>
<p><code>re_match</code> — file stat / path builtin. Alias for <code>matches_regex</code>.</p>
<pre><code class="lang-perl">my $result = re_match $x
# or in a pipeline:
@list |> map re_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-split-limit">
<h3><a class="doc-anchor" href="#doc-re-split-limit">#</a> <code>re_split_limit</code></h3>
<p><code>re_split_limit</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_split_limit $x
# or in a pipeline:
@list |> map re_split_limit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-test">
<h3><a class="doc-anchor" href="#doc-re-test">#</a> <code>re_test</code></h3>
<p><code>re_test</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_test $x
# or in a pipeline:
@list |> map re_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reaction-quotient">
<h3><a class="doc-anchor" href="#doc-reaction-quotient">#</a> <code>reaction_quotient</code></h3>
<p><code>reaction_quotient</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = reaction_quotient $x
# or in a pipeline:
@list |> map reaction_quotient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-realized-volatility">
<h3><a class="doc-anchor" href="#doc-realized-volatility">#</a> <code>realized_volatility</code></h3>
<p><code>realized_volatility</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = realized_volatility $x
# or in a pipeline:
@list |> map realized_volatility |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rearth">
<h3><a class="doc-anchor" href="#doc-rearth">#</a> <code>rearth</code></h3>
<p><code>rearth</code> — physics constants builtin. Alias for <code>earth_radius</code>.</p>
<pre><code class="lang-perl">my $result = rearth $x
# or in a pipeline:
@list |> map rearth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-received">
<h3><a class="doc-anchor" href="#doc-received">#</a> <code>received</code></h3>
<p><code>received</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = received $x
# or in a pipeline:
@list |> map received |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-recip">
<h3><a class="doc-anchor" href="#doc-recip">#</a> <code>recip</code></h3>
<p><code>recip</code> — extended stdlib builtin. Alias for <code>reciprocal_of</code>.</p>
<pre><code class="lang-perl">my $result = recip $x
# or in a pipeline:
@list |> map recip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reciprocal">
<h3><a class="doc-anchor" href="#doc-reciprocal">#</a> <code>reciprocal</code></h3>
<p><code>reciprocal</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = reciprocal $x
# or in a pipeline:
@list |> map reciprocal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reciprocal-of">
<h3><a class="doc-anchor" href="#doc-reciprocal-of">#</a> <code>reciprocal_of</code></h3>
<p><code>reciprocal_of</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = reciprocal_of $x
# or in a pipeline:
@list |> map reciprocal_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reciprocal-pdf">
<h3><a class="doc-anchor" href="#doc-reciprocal-pdf">#</a> <code>reciprocal_pdf</code></h3>
<p><code>reciprocal_pdf</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = reciprocal_pdf $x
# or in a pipeline:
@list |> map reciprocal_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-red">
<h3><a class="doc-anchor" href="#doc-red">#</a> <code>red</code></h3>
<p><code>red</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = red $x
# or in a pipeline:
@list |> map red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-red-bold">
<h3><a class="doc-anchor" href="#doc-red-bold">#</a> <code>red_bold</code></h3>
<p><code>red_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = red_bold $x
# or in a pipeline:
@list |> map red_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-redi">
<h3><a class="doc-anchor" href="#doc-redi">#</a> <code>redi</code></h3>
<p><code>redi</code> — go/general functional utilities builtin. Alias for <code>reduce_indexed</code>.</p>
<pre><code class="lang-perl">my $result = redi $x
# or in a pipeline:
@list |> map redi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-redlich-kwong-p">
<h3><a class="doc-anchor" href="#doc-redlich-kwong-p">#</a> <code>redlich_kwong_p</code></h3>
<p><code>redlich_kwong_p</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = redlich_kwong_p $x
# or in a pipeline:
@list |> map redlich_kwong_p |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-redox-potential-cell">
<h3><a class="doc-anchor" href="#doc-redox-potential-cell">#</a> <code>redox_potential_cell</code></h3>
<p><code>redox_potential_cell</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = redox_potential_cell $x
# or in a pipeline:
@list |> map redox_potential_cell |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-redr">
<h3><a class="doc-anchor" href="#doc-redr">#</a> <code>redr</code></h3>
<p><code>redr</code> — additional missing stdlib functions builtin. Alias for <code>reduce_right</code>.</p>
<pre><code class="lang-perl">my $result = redr $x
# or in a pipeline:
@list |> map redr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-redshift-from-a">
<h3><a class="doc-anchor" href="#doc-redshift-from-a">#</a> <code>redshift_from_a</code></h3>
<p><code>redshift_from_a</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = redshift_from_a $x
# or in a pipeline:
@list |> map redshift_from_a |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reduce-axis">
<h3><a class="doc-anchor" href="#doc-reduce-axis">#</a> <code>reduce_axis</code></h3>
<p><code>reduce_axis</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = reduce_axis $x
# or in a pipeline:
@list |> map reduce_axis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reduce-indexed">
<h3><a class="doc-anchor" href="#doc-reduce-indexed">#</a> <code>reduce_indexed</code></h3>
<p><code>reduce_indexed</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = reduce_indexed $x
# or in a pipeline:
@list |> map reduce_indexed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reduce-right">
<h3><a class="doc-anchor" href="#doc-reduce-right">#</a> <code>reduce_right</code></h3>
<p><code>reduce_right</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = reduce_right $x
# or in a pipeline:
@list |> map reduce_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-refaddr">
<h3><a class="doc-anchor" href="#doc-refaddr">#</a> <code>refaddr</code></h3>
<p><code>refaddr</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = refaddr $x
# or in a pipeline:
@list |> map refaddr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-refl-check">
<h3><a class="doc-anchor" href="#doc-refl-check">#</a> <code>refl_check</code></h3>
<p><code>refl_check</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = refl_check $x
# or in a pipeline:
@list |> map refl_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reflect-point">
<h3><a class="doc-anchor" href="#doc-reflect-point">#</a> <code>reflect_point</code></h3>
<p><code>reflect_point($x, $y, $axis)</code> — reflects a point across an axis. Axis can be 'x', 'y', or 'origin'. Returns the reflected coordinates.</p>
<pre><code class="lang-perl">p reflect_point(3, 4, 'x') # [3, -4]
p reflect_point(3, 4, 'y') # [-3, 4]
p reflect_point(3, 4, 'origin') # [-3, -4]
</code></pre>
</article>
<article class="doc-entry" id="doc-reflpt">
<h3><a class="doc-anchor" href="#doc-reflpt">#</a> <code>reflpt</code></h3>
<p><code>reflpt</code> — geometry (extended) builtin. Alias for <code>reflect_point</code>.</p>
<pre><code class="lang-perl">my $result = reflpt $x
# or in a pipeline:
@list |> map reflpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-refresh-stashes">
<h3><a class="doc-anchor" href="#doc-refresh-stashes">#</a> <code>refresh_stashes</code></h3>
<p><code>refresh_stashes</code> — symbol table builtin.</p>
<pre><code class="lang-perl">my $result = refresh_stashes $x
# or in a pipeline:
@list |> map refresh_stashes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reftype">
<h3><a class="doc-anchor" href="#doc-reftype">#</a> <code>reftype</code></h3>
<p><code>reftype</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = reftype $x
# or in a pipeline:
@list |> map reftype |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-compile-thompson">
<h3><a class="doc-anchor" href="#doc-regex-compile-thompson">#</a> <code>regex_compile_thompson</code></h3>
<p><code>regex_compile_thompson</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = regex_compile_thompson $x
# or in a pipeline:
@list |> map regex_compile_thompson |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-escape-simple">
<h3><a class="doc-anchor" href="#doc-regex-escape-simple">#</a> <code>regex_escape_simple</code></h3>
<p><code>regex_escape_simple</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = regex_escape_simple $x
# or in a pipeline:
@list |> map regex_escape_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-extract">
<h3><a class="doc-anchor" href="#doc-regex-extract">#</a> <code>regex_extract</code></h3>
<p><code>regex_extract</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = regex_extract $x
# or in a pipeline:
@list |> map regex_extract |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-match-dfa">
<h3><a class="doc-anchor" href="#doc-regex-match-dfa">#</a> <code>regex_match_dfa</code></h3>
<p><code>regex_match_dfa</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = regex_match_dfa $x
# or in a pipeline:
@list |> map regex_match_dfa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-replace-str">
<h3><a class="doc-anchor" href="#doc-regex-replace-str">#</a> <code>regex_replace_str</code></h3>
<p><code>regex_replace_str</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = regex_replace_str $x
# or in a pipeline:
@list |> map regex_replace_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-split-str">
<h3><a class="doc-anchor" href="#doc-regex-split-str">#</a> <code>regex_split_str</code></h3>
<p><code>regex_split_str</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = regex_split_str $x
# or in a pipeline:
@list |> map regex_split_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-to-nfa-thompson">
<h3><a class="doc-anchor" href="#doc-regex-to-nfa-thompson">#</a> <code>regex_to_nfa_thompson</code></h3>
<p><code>regex_to_nfa_thompson</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = regex_to_nfa_thompson $input
</code></pre>
</article>
<article class="doc-entry" id="doc-regexp-matches">
<h3><a class="doc-anchor" href="#doc-regexp-matches">#</a> <code>regexp_matches</code></h3>
<p><code>regexp_matches</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = regexp_matches $x
# or in a pipeline:
@list |> map regexp_matches |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regexp-replace">
<h3><a class="doc-anchor" href="#doc-regexp-replace">#</a> <code>regexp_replace</code></h3>
<p><code>regexp_replace</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = regexp_replace $x
# or in a pipeline:
@list |> map regexp_replace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regexp-split">
<h3><a class="doc-anchor" href="#doc-regexp-split">#</a> <code>regexp_split</code></h3>
<p><code>regexp_split</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = regexp_split $x
# or in a pipeline:
@list |> map regexp_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regr-intercept">
<h3><a class="doc-anchor" href="#doc-regr-intercept">#</a> <code>regr_intercept</code></h3>
<p><code>regr_intercept</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = regr_intercept $x
# or in a pipeline:
@list |> map regr_intercept |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regr-r2">
<h3><a class="doc-anchor" href="#doc-regr-r2">#</a> <code>regr_r2</code></h3>
<p><code>regr_r2</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = regr_r2 $x
# or in a pipeline:
@list |> map regr_r2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regr-slope">
<h3><a class="doc-anchor" href="#doc-regr-slope">#</a> <code>regr_slope</code></h3>
<p><code>regr_slope</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = regr_slope $x
# or in a pipeline:
@list |> map regr_slope |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regula-falsi">
<h3><a class="doc-anchor" href="#doc-regula-falsi">#</a> <code>regula_falsi</code></h3>
<p><code>regula_falsi</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = regula_falsi $x
# or in a pipeline:
@list |> map regula_falsi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regular-ngon-area">
<h3><a class="doc-anchor" href="#doc-regular-ngon-area">#</a> <code>regular_ngon_area</code></h3>
<p><code>regular_ngon_area</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = regular_ngon_area $x
# or in a pipeline:
@list |> map regular_ngon_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regular-ngon-circumradius">
<h3><a class="doc-anchor" href="#doc-regular-ngon-circumradius">#</a> <code>regular_ngon_circumradius</code></h3>
<p><code>regular_ngon_circumradius</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = regular_ngon_circumradius $x
# or in a pipeline:
@list |> map regular_ngon_circumradius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regular-ngon-inradius">
<h3><a class="doc-anchor" href="#doc-regular-ngon-inradius">#</a> <code>regular_ngon_inradius</code></h3>
<p><code>regular_ngon_inradius</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = regular_ngon_inradius $x
# or in a pipeline:
@list |> map regular_ngon_inradius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regulator-naive">
<h3><a class="doc-anchor" href="#doc-regulator-naive">#</a> <code>regulator_naive</code></h3>
<p><code>regulator_naive</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = regulator_naive $x
# or in a pipeline:
@list |> map regulator_naive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reject-if">
<h3><a class="doc-anchor" href="#doc-reject-if">#</a> <code>reject_if</code></h3>
<p><code>reject_if</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = reject_if $x
# or in a pipeline:
@list |> map reject_if |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rel-energy-pm">
<h3><a class="doc-anchor" href="#doc-rel-energy-pm">#</a> <code>rel_energy_pm</code></h3>
<p><code>rel_energy_pm</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = rel_energy_pm $x
# or in a pipeline:
@list |> map rel_energy_pm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rel-ke">
<h3><a class="doc-anchor" href="#doc-rel-ke">#</a> <code>rel_ke</code></h3>
<p><code>rel_ke</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = rel_ke $x
# or in a pipeline:
@list |> map rel_ke |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rel-momentum">
<h3><a class="doc-anchor" href="#doc-rel-momentum">#</a> <code>rel_momentum</code></h3>
<p><code>rel_momentum</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = rel_momentum $x
# or in a pipeline:
@list |> map rel_momentum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rel-total-energy">
<h3><a class="doc-anchor" href="#doc-rel-total-energy">#</a> <code>rel_total_energy</code></h3>
<p><code>rel_total_energy</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = rel_total_energy $x
# or in a pipeline:
@list |> map rel_total_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rel-velocity-add">
<h3><a class="doc-anchor" href="#doc-rel-velocity-add">#</a> <code>rel_velocity_add</code></h3>
<p><code>rel_velocity_add</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = rel_velocity_add $x
# or in a pipeline:
@list |> map rel_velocity_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relative-entropy-coherence">
<h3><a class="doc-anchor" href="#doc-relative-entropy-coherence">#</a> <code>relative_entropy_coherence</code></h3>
<p><code>relative_entropy_coherence</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = relative_entropy_coherence $x
# or in a pipeline:
@list |> map relative_entropy_coherence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relative-entropy-kl">
<h3><a class="doc-anchor" href="#doc-relative-entropy-kl">#</a> <code>relative_entropy_kl</code></h3>
<p><code>relative_entropy_kl</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = relative_entropy_kl $x
# or in a pipeline:
@list |> map relative_entropy_kl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relative-humidity-step">
<h3><a class="doc-anchor" href="#doc-relative-humidity-step">#</a> <code>relative_humidity_step</code></h3>
<p><code>relative_humidity_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = relative_humidity_step $x
# or in a pipeline:
@list |> map relative_humidity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relative-luminance">
<h3><a class="doc-anchor" href="#doc-relative-luminance">#</a> <code>relative_luminance</code></h3>
<p><code>relative_luminance</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = relative_luminance $x
# or in a pipeline:
@list |> map relative_luminance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relative-vorticity-step">
<h3><a class="doc-anchor" href="#doc-relative-vorticity-step">#</a> <code>relative_vorticity_step</code></h3>
<p><code>relative_vorticity_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = relative_vorticity_step $x
# or in a pipeline:
@list |> map relative_vorticity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relativistic-doppler">
<h3><a class="doc-anchor" href="#doc-relativistic-doppler">#</a> <code>relativistic_doppler</code></h3>
<p><code>relativistic_doppler</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = relativistic_doppler $x
# or in a pipeline:
@list |> map relativistic_doppler |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relativistic-energy">
<h3><a class="doc-anchor" href="#doc-relativistic-energy">#</a> <code>relativistic_energy</code></h3>
<p><code>relativistic_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = relativistic_energy $x
# or in a pipeline:
@list |> map relativistic_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relativistic-kinetic">
<h3><a class="doc-anchor" href="#doc-relativistic-kinetic">#</a> <code>relativistic_kinetic</code></h3>
<p><code>relativistic_kinetic</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = relativistic_kinetic $x
# or in a pipeline:
@list |> map relativistic_kinetic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relativistic-mass">
<h3><a class="doc-anchor" href="#doc-relativistic-mass">#</a> <code>relativistic_mass</code></h3>
<p><code>relativistic_mass</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = relativistic_mass $x
# or in a pipeline:
@list |> map relativistic_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relenergy">
<h3><a class="doc-anchor" href="#doc-relenergy">#</a> <code>relenergy</code></h3>
<p><code>relenergy</code> — physics formulas builtin. Alias for <code>relativistic_energy</code>.</p>
<pre><code class="lang-perl">my $result = relenergy $x
# or in a pipeline:
@list |> map relenergy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reliability-diagram">
<h3><a class="doc-anchor" href="#doc-reliability-diagram">#</a> <code>reliability_diagram</code></h3>
<p><code>reliability_diagram</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = reliability_diagram $x
# or in a pipeline:
@list |> map reliability_diagram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relmass">
<h3><a class="doc-anchor" href="#doc-relmass">#</a> <code>relmass</code></h3>
<p><code>relmass</code> — physics formulas builtin. Alias for <code>relativistic_mass</code>.</p>
<pre><code class="lang-perl">my $result = relmass $x
# or in a pipeline:
@list |> map relmass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relu">
<h3><a class="doc-anchor" href="#doc-relu">#</a> <code>relu</code></h3>
<p><code>relu</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = relu $x
# or in a pipeline:
@list |> map relu |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relu-grad">
<h3><a class="doc-anchor" href="#doc-relu-grad">#</a> <code>relu_grad</code></h3>
<p><code>relu_grad</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = relu_grad $x
# or in a pipeline:
@list |> map relu_grad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remc">
<h3><a class="doc-anchor" href="#doc-remc">#</a> <code>remc</code></h3>
<p><code>remc</code> — algebraic match builtin. Alias for <code>remove_clj</code>.</p>
<pre><code class="lang-perl">my $result = remc $x
# or in a pipeline:
@list |> map remc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remez-design">
<h3><a class="doc-anchor" href="#doc-remez-design">#</a> <code>remez_design</code></h3>
<p><code>remez_design</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = remez_design $x
# or in a pipeline:
@list |> map remez_design |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-all-str">
<h3><a class="doc-anchor" href="#doc-remove-all-str">#</a> <code>remove_all_str</code></h3>
<p><code>remove_all_str</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = remove_all_str $x
# or in a pipeline:
@list |> map remove_all_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-at">
<h3><a class="doc-anchor" href="#doc-remove-at">#</a> <code>remove_at</code></h3>
<p><code>remove_at</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = remove_at $x
# or in a pipeline:
@list |> map remove_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-clj">
<h3><a class="doc-anchor" href="#doc-remove-clj">#</a> <code>remove_clj</code></h3>
<p><code>remove_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = remove_clj $x
# or in a pipeline:
@list |> map remove_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-consonants">
<h3><a class="doc-anchor" href="#doc-remove-consonants">#</a> <code>remove_consonants</code></h3>
<p><code>remove_consonants</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = remove_consonants $x
# or in a pipeline:
@list |> map remove_consonants |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-elem">
<h3><a class="doc-anchor" href="#doc-remove-elem">#</a> <code>remove_elem</code></h3>
<p><code>remove_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = remove_elem $x
# or in a pipeline:
@list |> map remove_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-first-elem">
<h3><a class="doc-anchor" href="#doc-remove-first-elem">#</a> <code>remove_first_elem</code></h3>
<p><code>remove_first_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = remove_first_elem $x
# or in a pipeline:
@list |> map remove_first_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-keys">
<h3><a class="doc-anchor" href="#doc-remove-keys">#</a> <code>remove_keys</code></h3>
<p><code>remove_keys</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = remove_keys $x
# or in a pipeline:
@list |> map remove_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-str">
<h3><a class="doc-anchor" href="#doc-remove-str">#</a> <code>remove_str</code></h3>
<p><code>remove_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = remove_str $x
# or in a pipeline:
@list |> map remove_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-vowels">
<h3><a class="doc-anchor" href="#doc-remove-vowels">#</a> <code>remove_vowels</code></h3>
<p><code>remove_vowels</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = remove_vowels $x
# or in a pipeline:
@list |> map remove_vowels |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-whitespace">
<h3><a class="doc-anchor" href="#doc-remove-whitespace">#</a> <code>remove_whitespace</code></h3>
<p><code>remove_whitespace</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = remove_whitespace $x
# or in a pipeline:
@list |> map remove_whitespace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-renamenx">
<h3><a class="doc-anchor" href="#doc-renamenx">#</a> <code>renamenx</code></h3>
<p><code>renamenx</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = renamenx $x
# or in a pipeline:
@list |> map renamenx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-renyi-divergence-step">
<h3><a class="doc-anchor" href="#doc-renyi-divergence-step">#</a> <code>renyi_divergence_step</code></h3>
<p><code>renyi_divergence_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = renyi_divergence_step $x
# or in a pipeline:
@list |> map renyi_divergence_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rep">
<h3><a class="doc-anchor" href="#doc-rep">#</a> <code>rep</code></h3>
<p><code>rep</code> — r base builtin. Alias for <code>rep_fn</code>.</p>
<pre><code class="lang-perl">my $result = rep $x
# or in a pipeline:
@list |> map rep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rep-fn">
<h3><a class="doc-anchor" href="#doc-rep-fn">#</a> <code>rep_fn</code></h3>
<p><code>rep_fn</code> — repeat a value N times. Like R's rep().</p>
<pre><code class="lang-perl">my @r = @{rep_fn(0, 10)} # ten zeros
my @s = @{rep_fn("x", 5)} # five "x"s
</code></pre>
</article>
<article class="doc-entry" id="doc-repa">
<h3><a class="doc-anchor" href="#doc-repa">#</a> <code>repa</code></h3>
<p><code>repa</code> — javascript array/object methods builtin. Alias for <code>replace_at</code>.</p>
<pre><code class="lang-perl">my $result = repa $x
# or in a pipeline:
@list |> map repa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repdigit">
<h3><a class="doc-anchor" href="#doc-repdigit">#</a> <code>repdigit</code></h3>
<p><code>repdigit</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = repdigit $x
# or in a pipeline:
@list |> map repdigit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeat">
<h3><a class="doc-anchor" href="#doc-repeat">#</a> <code>repeat</code></h3>
<p><code>repeat</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = repeat $x
# or in a pipeline:
@list |> map repeat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeat-elem">
<h3><a class="doc-anchor" href="#doc-repeat-elem">#</a> <code>repeat_elem</code></h3>
<p><code>repeat_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = repeat_elem $x
# or in a pipeline:
@list |> map repeat_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeat-list">
<h3><a class="doc-anchor" href="#doc-repeat-list">#</a> <code>repeat_list</code></h3>
<p><code>repeat_list</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = repeat_list $x
# or in a pipeline:
@list |> map repeat_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeat-string">
<h3><a class="doc-anchor" href="#doc-repeat-string">#</a> <code>repeat_string</code></h3>
<p><code>repeat_string</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = repeat_string $x
# or in a pipeline:
@list |> map repeat_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeated-game-avg-payoff">
<h3><a class="doc-anchor" href="#doc-repeated-game-avg-payoff">#</a> <code>repeated_game_avg_payoff</code></h3>
<p><code>repeated_game_avg_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = repeated_game_avg_payoff $x
# or in a pipeline:
@list |> map repeated_game_avg_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeatedly">
<h3><a class="doc-anchor" href="#doc-repeatedly">#</a> <code>repeatedly</code></h3>
<p><code>repeatedly</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = repeatedly $x
# or in a pipeline:
@list |> map repeatedly |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-all-str">
<h3><a class="doc-anchor" href="#doc-replace-all-str">#</a> <code>replace_all_str</code></h3>
<p><code>replace_all_str</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = replace_all_str $x
# or in a pipeline:
@list |> map replace_all_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-at">
<h3><a class="doc-anchor" href="#doc-replace-at">#</a> <code>replace_at</code></h3>
<p><code>replace_at</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = replace_at $x
# or in a pipeline:
@list |> map replace_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-at-index">
<h3><a class="doc-anchor" href="#doc-replace-at-index">#</a> <code>replace_at_index</code></h3>
<p><code>replace_at_index</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = replace_at_index $x
# or in a pipeline:
@list |> map replace_at_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-first">
<h3><a class="doc-anchor" href="#doc-replace-first">#</a> <code>replace_first</code></h3>
<p><code>replace_first</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = replace_first $x
# or in a pipeline:
@list |> map replace_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-n-times">
<h3><a class="doc-anchor" href="#doc-replace-n-times">#</a> <code>replace_n_times</code></h3>
<p><code>replace_n_times</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = replace_n_times $x
# or in a pipeline:
@list |> map replace_n_times |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-regex">
<h3><a class="doc-anchor" href="#doc-replace-regex">#</a> <code>replace_regex</code></h3>
<p><code>replace_regex</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = replace_regex $x
# or in a pipeline:
@list |> map replace_regex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replicate-val">
<h3><a class="doc-anchor" href="#doc-replicate-val">#</a> <code>replicate_val</code></h3>
<p><code>replicate_val</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = replicate_val $x
# or in a pipeline:
@list |> map replicate_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replicator-dynamics-step">
<h3><a class="doc-anchor" href="#doc-replicator-dynamics-step">#</a> <code>replicator_dynamics_step</code></h3>
<p><code>replicator_dynamics_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = replicator_dynamics_step $x
# or in a pipeline:
@list |> map replicator_dynamics_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repln">
<h3><a class="doc-anchor" href="#doc-repln">#</a> <code>repln</code></h3>
<p><code>repln</code> — extended stdlib builtin. Alias for <code>replace_n_times</code>.</p>
<pre><code class="lang-perl">my $result = repln $x
# or in a pipeline:
@list |> map repln |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replre">
<h3><a class="doc-anchor" href="#doc-replre">#</a> <code>replre</code></h3>
<p><code>replre</code> — extended stdlib builtin. Alias for <code>replace_regex</code>.</p>
<pre><code class="lang-perl">my $result = replre $x
# or in a pipeline:
@list |> map replre |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-representation-dim-step">
<h3><a class="doc-anchor" href="#doc-representation-dim-step">#</a> <code>representation_dim_step</code></h3>
<p><code>representation_dim_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = representation_dim_step $x
# or in a pipeline:
@list |> map representation_dim_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repunit">
<h3><a class="doc-anchor" href="#doc-repunit">#</a> <code>repunit</code></h3>
<p><code>repunit</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = repunit $x
# or in a pipeline:
@list |> map repunit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repv">
<h3><a class="doc-anchor" href="#doc-repv">#</a> <code>repv</code></h3>
<p><code>repv</code> — haskell list functions builtin. Alias for <code>replicate_val</code>.</p>
<pre><code class="lang-perl">my $result = repv $x
# or in a pipeline:
@list |> map repv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resample">
<h3><a class="doc-anchor" href="#doc-resample">#</a> <code>resample</code></h3>
<p><code>resample(\@signal, $factor)</code> — resamples signal by a rational factor. Factor > 1 upsamples, factor < 1 downsamples. Uses linear interpolation.</p>
<pre><code class="lang-perl">my $up = resample(\@signal, 2) # double sample rate
my $down = resample(\@signal, 0.5) # halve sample rate
</code></pre>
</article>
<article class="doc-entry" id="doc-resample-linear">
<h3><a class="doc-anchor" href="#doc-resample-linear">#</a> <code>resample_linear</code></h3>
<p><code>resample_linear</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = resample_linear $x
# or in a pipeline:
@list |> map resample_linear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resample-nearest">
<h3><a class="doc-anchor" href="#doc-resample-nearest">#</a> <code>resample_nearest</code></h3>
<p><code>resample_nearest</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = resample_nearest $x
# or in a pipeline:
@list |> map resample_nearest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resample-poly-step">
<h3><a class="doc-anchor" href="#doc-resample-poly-step">#</a> <code>resample_poly_step</code></h3>
<p><code>resample_poly_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = resample_poly_step $x
# or in a pipeline:
@list |> map resample_poly_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reserve-prospective">
<h3><a class="doc-anchor" href="#doc-reserve-prospective">#</a> <code>reserve_prospective</code></h3>
<p><code>reserve_prospective</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = reserve_prospective $x
# or in a pipeline:
@list |> map reserve_prospective |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reserve-retrospective">
<h3><a class="doc-anchor" href="#doc-reserve-retrospective">#</a> <code>reserve_retrospective</code></h3>
<p><code>reserve_retrospective</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = reserve_retrospective $x
# or in a pipeline:
@list |> map reserve_retrospective |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reservoir-sample">
<h3><a class="doc-anchor" href="#doc-reservoir-sample">#</a> <code>reservoir_sample</code></h3>
<p><code>reservoir_sample</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = reservoir_sample $x
# or in a pipeline:
@list |> map reservoir_sample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reset">
<h3><a class="doc-anchor" href="#doc-reset">#</a> <code>reset</code></h3>
<p><code>reset</code> — process / system builtin.</p>
<pre><code class="lang-perl">my $result = reset $x
# or in a pipeline:
@list |> map reset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resfreq">
<h3><a class="doc-anchor" href="#doc-resfreq">#</a> <code>resfreq</code></h3>
<p><code>resfreq</code> — physics formulas builtin. Alias for <code>resonant_frequency</code>.</p>
<pre><code class="lang-perl">my $result = resfreq $x
# or in a pipeline:
@list |> map resfreq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reshape-dim">
<h3><a class="doc-anchor" href="#doc-reshape-dim">#</a> <code>reshape_dim</code></h3>
<p><code>reshape_dim</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = reshape_dim $x
# or in a pipeline:
@list |> map reshape_dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-residuals-compute">
<h3><a class="doc-anchor" href="#doc-residuals-compute">#</a> <code>residuals_compute</code></h3>
<p><code>residuals_compute</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = residuals_compute $x
# or in a pipeline:
@list |> map residuals_compute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resistance-parallel">
<h3><a class="doc-anchor" href="#doc-resistance-parallel">#</a> <code>resistance_parallel</code></h3>
<p><code>resistance_parallel</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = resistance_parallel $x
# or in a pipeline:
@list |> map resistance_parallel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resistance-series">
<h3><a class="doc-anchor" href="#doc-resistance-series">#</a> <code>resistance_series</code></h3>
<p><code>resistance_series</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = resistance_series $x
# or in a pipeline:
@list |> map resistance_series |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resolution-step">
<h3><a class="doc-anchor" href="#doc-resolution-step">#</a> <code>resolution_step</code></h3>
<p><code>resolution_step</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = resolution_step $x
# or in a pipeline:
@list |> map resolution_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resonance-count">
<h3><a class="doc-anchor" href="#doc-resonance-count">#</a> <code>resonance_count</code></h3>
<p><code>resonance_count</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = resonance_count $x
# or in a pipeline:
@list |> map resonance_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resonant-frequency">
<h3><a class="doc-anchor" href="#doc-resonant-frequency">#</a> <code>resonant_frequency</code></h3>
<p><code>resonant_frequency</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = resonant_frequency $x
# or in a pipeline:
@list |> map resonant_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rest">
<h3><a class="doc-anchor" href="#doc-rest">#</a> <code>rest</code></h3>
<p><code>rest</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = rest $x
# or in a pipeline:
@list |> map rest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rest-energy">
<h3><a class="doc-anchor" href="#doc-rest-energy">#</a> <code>rest_energy</code></h3>
<p><code>rest_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = rest_energy $x
# or in a pipeline:
@list |> map rest_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-restenergy">
<h3><a class="doc-anchor" href="#doc-restenergy">#</a> <code>restenergy</code></h3>
<p><code>restenergy</code> — physics formulas builtin. Alias for <code>rest_energy</code>.</p>
<pre><code class="lang-perl">my $result = restenergy $x
# or in a pipeline:
@list |> map restenergy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rev">
<h3><a class="doc-anchor" href="#doc-rev">#</a> <code>rev</code></h3>
<p><code>rev</code> — short aliases builtin.</p>
<pre><code class="lang-perl">my $result = rev $x
# or in a pipeline:
@list |> map rev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rev-str">
<h3><a class="doc-anchor" href="#doc-rev-str">#</a> <code>rev_str</code></h3>
<p><code>rev_str</code> — trivial string ops builtin. Alias for <code>reverse_str</code>.</p>
<pre><code class="lang-perl">my $result = rev_str $x
# or in a pipeline:
@list |> map rev_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rev-vec">
<h3><a class="doc-anchor" href="#doc-rev-vec">#</a> <code>rev_vec</code></h3>
<p><code>rev_vec</code> — r base builtin.</p>
<pre><code class="lang-perl">my $result = rev_vec $x
# or in a pipeline:
@list |> map rev_vec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-revenue-equivalence-check">
<h3><a class="doc-anchor" href="#doc-revenue-equivalence-check">#</a> <code>revenue_equivalence_check</code></h3>
<p><code>revenue_equivalence_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = revenue_equivalence_check $x
# or in a pipeline:
@list |> map revenue_equivalence_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-delete-step">
<h3><a class="doc-anchor" href="#doc-reverse-delete-step">#</a> <code>reverse_delete_step</code></h3>
<p><code>reverse_delete_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = reverse_delete_step $x
# or in a pipeline:
@list |> map reverse_delete_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-each">
<h3><a class="doc-anchor" href="#doc-reverse-each">#</a> <code>reverse_each</code></h3>
<p><code>reverse_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = reverse_each $x
# or in a pipeline:
@list |> map reverse_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-each-word">
<h3><a class="doc-anchor" href="#doc-reverse-each-word">#</a> <code>reverse_each_word</code></h3>
<p><code>reverse_each_word</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = reverse_each_word $x
# or in a pipeline:
@list |> map reverse_each_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-list">
<h3><a class="doc-anchor" href="#doc-reverse-list">#</a> <code>reverse_list</code></h3>
<p><code>reverse_list</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = reverse_list $x
# or in a pipeline:
@list |> map reverse_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-str">
<h3><a class="doc-anchor" href="#doc-reverse-str">#</a> <code>reverse_str</code></h3>
<p><code>reverse_str</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = reverse_str $x
# or in a pipeline:
@list |> map reverse_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-transcribe">
<h3><a class="doc-anchor" href="#doc-reverse-transcribe">#</a> <code>reverse_transcribe</code></h3>
<p><code>reverse_transcribe</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = reverse_transcribe $x
# or in a pipeline:
@list |> map reverse_transcribe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-words">
<h3><a class="doc-anchor" href="#doc-reverse-words">#</a> <code>reverse_words</code></h3>
<p><code>reverse_words</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = reverse_words $x
# or in a pipeline:
@list |> map reverse_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-revwords">
<h3><a class="doc-anchor" href="#doc-revwords">#</a> <code>revwords</code></h3>
<p><code>revwords</code> — string processing (uncategorized batch) builtin. Alias for <code>reverse_each_word</code>.</p>
<pre><code class="lang-perl">my $result = revwords $x
# or in a pipeline:
@list |> map revwords |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rexp">
<h3><a class="doc-anchor" href="#doc-rexp">#</a> <code>rexp</code></h3>
<p><code>rexp</code> — generate n random exponential variates. Args: n [, rate]. Like R's rexp().</p>
<pre><code class="lang-perl">my @x = @{rexp(100, 0.5)} # rate=0.5 (mean=2)
</code></pre>
</article>
<article class="doc-entry" id="doc-reynolds-full-number">
<h3><a class="doc-anchor" href="#doc-reynolds-full-number">#</a> <code>reynolds_full_number</code></h3>
<p><code>reynolds_full_number</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = reynolds_full_number $x
# or in a pipeline:
@list |> map reynolds_full_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rf">
<h3><a class="doc-anchor" href="#doc-rf">#</a> <code>rf</code></h3>
<p><code>rf</code> — generate n random F variates. Args: n, d1, d2. Like R's rf().</p>
<pre><code class="lang-perl">my @x = @{rf(100, 5, 10)} # F(5,10)
</code></pre>
</article>
<article class="doc-entry" id="doc-rfact">
<h3><a class="doc-anchor" href="#doc-rfact">#</a> <code>rfact</code></h3>
<p><code>rfact</code> — math formulas builtin. Alias for <code>rising_factorial</code>.</p>
<pre><code class="lang-perl">my $result = rfact $x
# or in a pipeline:
@list |> map rfact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rfc3339">
<h3><a class="doc-anchor" href="#doc-rfc3339">#</a> <code>rfc3339</code></h3>
<p><code>rfc3339</code> — batch 10 builtin. Alias for <code>rfc3339_format</code>.</p>
<pre><code class="lang-perl">my $result = rfc3339 $x
# or in a pipeline:
@list |> map rfc3339 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rfc3339-format">
<h3><a class="doc-anchor" href="#doc-rfc3339-format">#</a> <code>rfc3339_format</code></h3>
<p><code>rfc3339_format</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = rfc3339_format $x
# or in a pipeline:
@list |> map rfc3339_format |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rfc3339-parse">
<h3><a class="doc-anchor" href="#doc-rfc3339-parse">#</a> <code>rfc3339_parse</code></h3>
<p><code>rfc3339_parse</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = rfc3339_parse $x
# or in a pipeline:
@list |> map rfc3339_parse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rg-radius-of-gyration">
<h3><a class="doc-anchor" href="#doc-rg-radius-of-gyration">#</a> <code>rg_radius_of_gyration</code></h3>
<p><code>rg_radius_of_gyration</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = rg_radius_of_gyration $x
# or in a pipeline:
@list |> map rg_radius_of_gyration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rgamma">
<h3><a class="doc-anchor" href="#doc-rgamma">#</a> <code>rgamma</code></h3>
<p><code>rgamma</code> — generate n random gamma variates. Args: n, shape [, scale]. Like R's rgamma().</p>
<pre><code class="lang-perl">my @x = @{rgamma(100, 2, 1)} # Gamma(2,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb">
<h3><a class="doc-anchor" href="#doc-rgb">#</a> <code>rgb</code></h3>
<p><code>rgb</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = rgb $x
# or in a pipeline:
@list |> map rgb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb2hsl">
<h3><a class="doc-anchor" href="#doc-rgb2hsl">#</a> <code>rgb2hsl</code></h3>
<p><code>rgb2hsl</code> — color operations builtin. Alias for <code>rgb_to_hsl</code>.</p>
<pre><code class="lang-perl">my $result = rgb2hsl $x
# or in a pipeline:
@list |> map rgb2hsl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb2hsv">
<h3><a class="doc-anchor" href="#doc-rgb2hsv">#</a> <code>rgb2hsv</code></h3>
<p><code>rgb2hsv</code> — color operations builtin. Alias for <code>rgb_to_hsv</code>.</p>
<pre><code class="lang-perl">my $result = rgb2hsv $x
# or in a pipeline:
@list |> map rgb2hsv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-cmyk">
<h3><a class="doc-anchor" href="#doc-rgb-to-cmyk">#</a> <code>rgb_to_cmyk</code></h3>
<p><code>rgb_to_cmyk</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_cmyk $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-hex">
<h3><a class="doc-anchor" href="#doc-rgb-to-hex">#</a> <code>rgb_to_hex</code></h3>
<p><code>rgb_to_hex</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_hex $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-hsl">
<h3><a class="doc-anchor" href="#doc-rgb-to-hsl">#</a> <code>rgb_to_hsl</code></h3>
<p><code>rgb_to_hsl</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_hsl $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-hsv">
<h3><a class="doc-anchor" href="#doc-rgb-to-hsv">#</a> <code>rgb_to_hsv</code></h3>
<p><code>rgb_to_hsv</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_hsv $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-oklab">
<h3><a class="doc-anchor" href="#doc-rgb-to-oklab">#</a> <code>rgb_to_oklab</code></h3>
<p><code>rgb_to_oklab</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_oklab $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-xyz">
<h3><a class="doc-anchor" href="#doc-rgb-to-xyz">#</a> <code>rgb_to_xyz</code></h3>
<p><code>rgb_to_xyz</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_xyz $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-yiq">
<h3><a class="doc-anchor" href="#doc-rgb-to-yiq">#</a> <code>rgb_to_yiq</code></h3>
<p><code>rgb_to_yiq</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_yiq $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-yuv">
<h3><a class="doc-anchor" href="#doc-rgb-to-yuv">#</a> <code>rgb_to_yuv</code></h3>
<p><code>rgb_to_yuv</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_yuv $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-yuv601">
<h3><a class="doc-anchor" href="#doc-rgb-to-yuv601">#</a> <code>rgb_to_yuv601</code></h3>
<p><code>rgb_to_yuv601</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_yuv601 $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgeom">
<h3><a class="doc-anchor" href="#doc-rgeom">#</a> <code>rgeom</code></h3>
<p><code>rgeom</code> — generate n random geometric variates. Args: n, prob.</p>
<pre><code class="lang-perl">my @x = @{rgeom(100, 0.3)} # trials until first success
</code></pre>
</article>
<article class="doc-entry" id="doc-rho">
<h3><a class="doc-anchor" href="#doc-rho">#</a> <code>rho</code></h3>
<p><code>spearman</code> (aliases <code>spearman_corr</code>, <code>rho</code>) computes Spearman's rank correlation coefficient between two samples.</p>
<pre><code class="lang-perl">p rho([1,2,3,4,5], [5,6,7,8,7]) # ~0.82
</code></pre>
</article>
<article class="doc-entry" id="doc-rhumb-line-bearing">
<h3><a class="doc-anchor" href="#doc-rhumb-line-bearing">#</a> <code>rhumb_line_bearing</code></h3>
<p><code>rhumb_line_bearing</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = rhumb_line_bearing $x
# or in a pipeline:
@list |> map rhumb_line_bearing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ricci-identity-step">
<h3><a class="doc-anchor" href="#doc-ricci-identity-step">#</a> <code>ricci_identity_step</code></h3>
<p><code>ricci_identity_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = ricci_identity_step $x
# or in a pipeline:
@list |> map ricci_identity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ricci-tensor-step-zero">
<h3><a class="doc-anchor" href="#doc-ricci-tensor-step-zero">#</a> <code>ricci_tensor_step_zero</code></h3>
<p><code>ricci_tensor_step_zero</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = ricci_tensor_step_zero $x
# or in a pipeline:
@list |> map ricci_tensor_step_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-richardson-number-step">
<h3><a class="doc-anchor" href="#doc-richardson-number-step">#</a> <code>richardson_number_step</code></h3>
<p><code>richardson_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = richardson_number_step $x
# or in a pipeline:
@list |> map richardson_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-richter-local-ml">
<h3><a class="doc-anchor" href="#doc-richter-local-ml">#</a> <code>richter_local_ml</code></h3>
<p><code>richter_local_ml</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = richter_local_ml $x
# or in a pipeline:
@list |> map richter_local_ml |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ricker-wavelet">
<h3><a class="doc-anchor" href="#doc-ricker-wavelet">#</a> <code>ricker_wavelet</code></h3>
<p><code>ricker_wavelet</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = ricker_wavelet $x
# or in a pipeline:
@list |> map ricker_wavelet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ridders">
<h3><a class="doc-anchor" href="#doc-ridders">#</a> <code>ridders</code></h3>
<p><code>ridders</code> — batch 19 builtin. Alias for <code>ridders_root</code>.</p>
<pre><code class="lang-perl">my $result = ridders $x
# or in a pipeline:
@list |> map ridders |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ridders-root">
<h3><a class="doc-anchor" href="#doc-ridders-root">#</a> <code>ridders_root</code></h3>
<p><code>ridders_root</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = ridders_root $x
# or in a pipeline:
@list |> map ridders_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ridx">
<h3><a class="doc-anchor" href="#doc-ridx">#</a> <code>ridx</code></h3>
<p><code>ridx</code> — python/ruby stdlib builtin. Alias for <code>rindex_fn</code>.</p>
<pre><code class="lang-perl">my $result = ridx $x
# or in a pipeline:
@list |> map ridx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-riemann-curvature-normal-form">
<h3><a class="doc-anchor" href="#doc-riemann-curvature-normal-form">#</a> <code>riemann_curvature_normal_form</code></h3>
<p><code>riemann_curvature_normal_form</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = riemann_curvature_normal_form $x
# or in a pipeline:
@list |> map riemann_curvature_normal_form |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-riemann-tensor-step-zero">
<h3><a class="doc-anchor" href="#doc-riemann-tensor-step-zero">#</a> <code>riemann_tensor_step_zero</code></h3>
<p><code>riemann_tensor_step_zero</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = riemann_tensor_step_zero $x
# or in a pipeline:
@list |> map riemann_tensor_step_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-riemann-xi">
<h3><a class="doc-anchor" href="#doc-riemann-xi">#</a> <code>riemann_xi</code></h3>
<p><code>riemann_xi</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = riemann_xi $x
# or in a pipeline:
@list |> map riemann_xi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-riffle">
<h3><a class="doc-anchor" href="#doc-riffle">#</a> <code>riffle</code></h3>
<p><code>riffle</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = riffle $x
# or in a pipeline:
@list |> map riffle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-right-str">
<h3><a class="doc-anchor" href="#doc-right-str">#</a> <code>right_str</code></h3>
<p><code>right_str</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = right_str $x
# or in a pipeline:
@list |> map right_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rindex-fn">
<h3><a class="doc-anchor" href="#doc-rindex-fn">#</a> <code>rindex_fn</code></h3>
<p><code>rindex_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = rindex_fn $x
# or in a pipeline:
@list |> map rindex_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rising-factorial">
<h3><a class="doc-anchor" href="#doc-rising-factorial">#</a> <code>rising_factorial</code></h3>
<p><code>rising_factorial</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = rising_factorial $x
# or in a pipeline:
@list |> map rising_factorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-risk-ratio-2x2">
<h3><a class="doc-anchor" href="#doc-risk-ratio-2x2">#</a> <code>risk_ratio_2x2</code></h3>
<p><code>risk_ratio_2x2</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = risk_ratio_2x2 $x
# or in a pipeline:
@list |> map risk_ratio_2x2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rjt">
<h3><a class="doc-anchor" href="#doc-rjt">#</a> <code>rjt</code></h3>
<p><code>rjt</code> — extended stdlib builtin. Alias for <code>rjust_text</code>.</p>
<pre><code class="lang-perl">my $result = rjt $x
# or in a pipeline:
@list |> map rjt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rjust">
<h3><a class="doc-anchor" href="#doc-rjust">#</a> <code>rjust</code></h3>
<p><code>rjust</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = rjust $x
# or in a pipeline:
@list |> map rjust |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rjust-text">
<h3><a class="doc-anchor" href="#doc-rjust-text">#</a> <code>rjust_text</code></h3>
<p><code>rjust_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = rjust_text $x
# or in a pipeline:
@list |> map rjust_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rk4">
<h3><a class="doc-anchor" href="#doc-rk4">#</a> <code>rk4</code></h3>
<p><code>rk4</code> (aliases <code>runge_kutta</code>, <code>rk4_ode</code>) solves an ODE dy/dt = f(t,y) using 4th-order Runge-Kutta. Returns [[t,y], ...].</p>
<pre><code class="lang-perl"># dy/dt = -y, y(0) = 1 → y = e^(-t)
my $sol = rk4(fn { -$_[1] }, 0, 1, 0.1, 100)
</code></pre>
</article>
<article class="doc-entry" id="doc-rk45-cash-karp">
<h3><a class="doc-anchor" href="#doc-rk45-cash-karp">#</a> <code>rk45_cash_karp</code></h3>
<p><code>rk45_cash_karp</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = rk45_cash_karp $x
# or in a pipeline:
@list |> map rk45_cash_karp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rk4-single">
<h3><a class="doc-anchor" href="#doc-rk4-single">#</a> <code>rk4_single</code></h3>
<p><code>rk4_single</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = rk4_single $x
# or in a pipeline:
@list |> map rk4_single |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rk-combine">
<h3><a class="doc-anchor" href="#doc-rk-combine">#</a> <code>rk_combine</code></h3>
<p><code>rk_combine</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = rk_combine $x
# or in a pipeline:
@list |> map rk_combine |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rkck">
<h3><a class="doc-anchor" href="#doc-rkck">#</a> <code>rkck</code></h3>
<p><code>rkck</code> — batch 19 builtin. Alias for <code>rk45_cash_karp</code>.</p>
<pre><code class="lang-perl">my $result = rkck $x
# or in a pipeline:
@list |> map rkck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rkf45-error">
<h3><a class="doc-anchor" href="#doc-rkf45-error">#</a> <code>rkf45_error</code></h3>
<p><code>rkf45_error</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = rkf45_error $x
# or in a pipeline:
@list |> map rkf45_error |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rl-tau">
<h3><a class="doc-anchor" href="#doc-rl-tau">#</a> <code>rl_tau</code></h3>
<p><code>rl_tau</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = rl_tau $x
# or in a pipeline:
@list |> map rl_tau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rl-time-constant">
<h3><a class="doc-anchor" href="#doc-rl-time-constant">#</a> <code>rl_time_constant</code></h3>
<p><code>rl_time_constant</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = rl_time_constant $x
# or in a pipeline:
@list |> map rl_time_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rld">
<h3><a class="doc-anchor" href="#doc-rld">#</a> <code>rld</code></h3>
<p><code>rld</code> — collection more builtin. Alias for <code>run_length_decode</code>.</p>
<pre><code class="lang-perl">my $result = rld $x
# or in a pipeline:
@list |> map rld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rld-str">
<h3><a class="doc-anchor" href="#doc-rld-str">#</a> <code>rld_str</code></h3>
<p><code>rld_str</code> — matrix operations (uncategorized batch) builtin. Alias for <code>run_length_decode_str</code>.</p>
<pre><code class="lang-perl">my $result = rld_str $x
# or in a pipeline:
@list |> map rld_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rle">
<h3><a class="doc-anchor" href="#doc-rle">#</a> <code>rle</code></h3>
<p><code>rle</code> — collection more builtin. Alias for <code>run_length_encode</code>.</p>
<pre><code class="lang-perl">my $result = rle $x
# or in a pipeline:
@list |> map rle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rle-str">
<h3><a class="doc-anchor" href="#doc-rle-str">#</a> <code>rle_str</code></h3>
<p><code>rle_str</code> — matrix operations (uncategorized batch) builtin. Alias for <code>run_length_encode_str</code>.</p>
<pre><code class="lang-perl">my $result = rle_str $x
# or in a pipeline:
@list |> map rle_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rlnorm">
<h3><a class="doc-anchor" href="#doc-rlnorm">#</a> <code>rlnorm</code></h3>
<p><code>rlnorm</code> — generate n random log-normal variates. Args: n [, mu, sigma].</p>
<pre><code class="lang-perl">my @x = @{rlnorm(100, 0, 1)} # LogN(0,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-rltau">
<h3><a class="doc-anchor" href="#doc-rltau">#</a> <code>rltau</code></h3>
<p><code>rltau</code> — physics formulas builtin. Alias for <code>rl_time_constant</code>.</p>
<pre><code class="lang-perl">my $result = rltau $x
# or in a pipeline:
@list |> map rltau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmall">
<h3><a class="doc-anchor" href="#doc-rmall">#</a> <code>rmall</code></h3>
<p><code>rmall</code> — extended stdlib builtin. Alias for <code>remove_all_str</code>.</p>
<pre><code class="lang-perl">my $result = rmall $x
# or in a pipeline:
@list |> map rmall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmcons">
<h3><a class="doc-anchor" href="#doc-rmcons">#</a> <code>rmcons</code></h3>
<p><code>rmcons</code> — string processing (uncategorized batch) builtin. Alias for <code>remove_consonants</code>.</p>
<pre><code class="lang-perl">my $result = rmcons $x
# or in a pipeline:
@list |> map rmcons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rms">
<h3><a class="doc-anchor" href="#doc-rms">#</a> <code>rms</code></h3>
<p><code>rms</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = rms $x
# or in a pipeline:
@list |> map rms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmse">
<h3><a class="doc-anchor" href="#doc-rmse">#</a> <code>rmse</code></h3>
<p><code>rmse</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = rmse $x
# or in a pipeline:
@list |> map rmse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmvowel">
<h3><a class="doc-anchor" href="#doc-rmvowel">#</a> <code>rmvowel</code></h3>
<p><code>rmvowel</code> — string processing (uncategorized batch) builtin. Alias for <code>remove_vowels</code>.</p>
<pre><code class="lang-perl">my $result = rmvowel $x
# or in a pipeline:
@list |> map rmvowel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmws">
<h3><a class="doc-anchor" href="#doc-rmws">#</a> <code>rmws</code></h3>
<p><code>rmws</code> — extended stdlib builtin. Alias for <code>remove_whitespace</code>.</p>
<pre><code class="lang-perl">my $result = rmws $x
# or in a pipeline:
@list |> map rmws |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rngcmp">
<h3><a class="doc-anchor" href="#doc-rngcmp">#</a> <code>rngcmp</code></h3>
<p><code>rngcmp</code> — matrix operations (uncategorized batch) builtin. Alias for <code>range_compress</code>.</p>
<pre><code class="lang-perl">my $result = rngcmp $x
# or in a pipeline:
@list |> map rngcmp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rngexp">
<h3><a class="doc-anchor" href="#doc-rngexp">#</a> <code>rngexp</code></h3>
<p><code>rngexp</code> — matrix operations (uncategorized batch) builtin. Alias for <code>range_expand</code>.</p>
<pre><code class="lang-perl">my $result = rngexp $x
# or in a pipeline:
@list |> map rngexp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rnk">
<h3><a class="doc-anchor" href="#doc-rnk">#</a> <code>rnk</code></h3>
<p><code>rnk</code> — extended stdlib builtin. Alias for <code>rank</code>.</p>
<pre><code class="lang-perl">my $result = rnk $x
# or in a pipeline:
@list |> map rnk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rnorm">
<h3><a class="doc-anchor" href="#doc-rnorm">#</a> <code>rnorm</code></h3>
<p><code>rnorm</code> — generate n random normal variates. Args: n [, mu, sigma]. Like R's rnorm().</p>
<pre><code class="lang-perl">my @x = @{rnorm(1000)} # 1000 standard normal
my @y = @{rnorm(100, 50, 10)} # mean=50, sd=10
</code></pre>
</article>
<article class="doc-entry" id="doc-roberts-kernel-value">
<h3><a class="doc-anchor" href="#doc-roberts-kernel-value">#</a> <code>roberts_kernel_value</code></h3>
<p><code>roberts_kernel_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = roberts_kernel_value $x
# or in a pipeline:
@list |> map roberts_kernel_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-robinson-project">
<h3><a class="doc-anchor" href="#doc-robinson-project">#</a> <code>robinson_project</code></h3>
<p><code>robinson_project</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = robinson_project $x
# or in a pipeline:
@list |> map robinson_project |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-robinson-schensted-pair">
<h3><a class="doc-anchor" href="#doc-robinson-schensted-pair">#</a> <code>robinson_schensted_pair</code></h3>
<p><code>robinson_schensted_pair</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = robinson_schensted_pair $x
# or in a pipeline:
@list |> map robinson_schensted_pair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-robust-scale">
<h3><a class="doc-anchor" href="#doc-robust-scale">#</a> <code>robust_scale</code></h3>
<p><code>robust_scale</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = robust_scale $x
# or in a pipeline:
@list |> map robust_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-robust-se-huber-white">
<h3><a class="doc-anchor" href="#doc-robust-se-huber-white">#</a> <code>robust_se_huber_white</code></h3>
<p><code>robust_se_huber_white</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = robust_se_huber_white $x
# or in a pipeline:
@list |> map robust_se_huber_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roche-limit-fluid">
<h3><a class="doc-anchor" href="#doc-roche-limit-fluid">#</a> <code>roche_limit_fluid</code></h3>
<p><code>roche_limit_fluid</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = roche_limit_fluid $x
# or in a pipeline:
@list |> map roche_limit_fluid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roche-limit-rigid">
<h3><a class="doc-anchor" href="#doc-roche-limit-rigid">#</a> <code>roche_limit_rigid</code></h3>
<p><code>roche_limit_rigid</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = roche_limit_rigid $x
# or in a pipeline:
@list |> map roche_limit_rigid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roi">
<h3><a class="doc-anchor" href="#doc-roi">#</a> <code>roi</code></h3>
<p><code>roi</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = roi $x
# or in a pipeline:
@list |> map roi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roll-n">
<h3><a class="doc-anchor" href="#doc-roll-n">#</a> <code>roll_n</code></h3>
<p><code>roll_n</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = roll_n $x
# or in a pipeline:
@list |> map roll_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman">
<h3><a class="doc-anchor" href="#doc-roman">#</a> <code>roman</code></h3>
<p><code>roman</code> — roman numerals builtin. Alias for <code>int_to_roman</code>.</p>
<pre><code class="lang-perl">my $result = roman $x
# or in a pipeline:
@list |> map roman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman-add">
<h3><a class="doc-anchor" href="#doc-roman-add">#</a> <code>roman_add</code></h3>
<p><code>roman_add</code> — roman numerals builtin.</p>
<pre><code class="lang-perl">my $result = roman_add $x
# or in a pipeline:
@list |> map roman_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman-decode">
<h3><a class="doc-anchor" href="#doc-roman-decode">#</a> <code>roman_decode</code></h3>
<p><code>roman_decode</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = roman_decode $x
# or in a pipeline:
@list |> map roman_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman-encode">
<h3><a class="doc-anchor" href="#doc-roman-encode">#</a> <code>roman_encode</code></h3>
<p><code>roman_encode</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = roman_encode $x
# or in a pipeline:
@list |> map roman_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman-numeral-list">
<h3><a class="doc-anchor" href="#doc-roman-numeral-list">#</a> <code>roman_numeral_list</code></h3>
<p><code>roman_numeral_list</code> — roman numerals builtin.</p>
<pre><code class="lang-perl">my $result = roman_numeral_list $x
# or in a pipeline:
@list |> map roman_numeral_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman-to-int">
<h3><a class="doc-anchor" href="#doc-roman-to-int">#</a> <code>roman_to_int</code></h3>
<p><code>roman_to_int</code> — roman numerals builtin.</p>
<pre><code class="lang-perl">my $result = roman_to_int $input
</code></pre>
</article>
<article class="doc-entry" id="doc-romanlist">
<h3><a class="doc-anchor" href="#doc-romanlist">#</a> <code>romanlist</code></h3>
<p><code>romanlist</code> — roman numerals builtin. Alias for <code>roman_numeral_list</code>.</p>
<pre><code class="lang-perl">my $result = romanlist $x
# or in a pipeline:
@list |> map romanlist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-romberg-quad">
<h3><a class="doc-anchor" href="#doc-romberg-quad">#</a> <code>romberg_quad</code></h3>
<p><code>romberg_quad</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = romberg_quad $x
# or in a pipeline:
@list |> map romberg_quad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roommate-match-step">
<h3><a class="doc-anchor" href="#doc-roommate-match-step">#</a> <code>roommate_match_step</code></h3>
<p><code>roommate_match_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = roommate_match_step $x
# or in a pipeline:
@list |> map roommate_match_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-root-brentq">
<h3><a class="doc-anchor" href="#doc-root-brentq">#</a> <code>root_brentq</code></h3>
<p><code>root_brentq</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = root_brentq $x
# or in a pipeline:
@list |> map root_brentq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-root-newton">
<h3><a class="doc-anchor" href="#doc-root-newton">#</a> <code>root_newton</code></h3>
<p><code>root_newton</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = root_newton $x
# or in a pipeline:
@list |> map root_newton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-root-secant">
<h3><a class="doc-anchor" href="#doc-root-secant">#</a> <code>root_secant</code></h3>
<p><code>root_secant</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = root_secant $x
# or in a pipeline:
@list |> map root_secant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-root-system-count">
<h3><a class="doc-anchor" href="#doc-root-system-count">#</a> <code>root_system_count</code></h3>
<p><code>root_system_count</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = root_system_count $x
# or in a pipeline:
@list |> map root_system_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ros2-step">
<h3><a class="doc-anchor" href="#doc-ros2-step">#</a> <code>ros2_step</code></h3>
<p><code>ros2_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = ros2_step $x
# or in a pipeline:
@list |> map ros2_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rot13">
<h3><a class="doc-anchor" href="#doc-rot13">#</a> <code>rot13</code></h3>
<p><code>rot13</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = rot13 $x
# or in a pipeline:
@list |> map rot13 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rot47">
<h3><a class="doc-anchor" href="#doc-rot47">#</a> <code>rot47</code></h3>
<p><code>rot47</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = rot47 $x
# or in a pipeline:
@list |> map rot47 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rotate">
<h3><a class="doc-anchor" href="#doc-rotate">#</a> <code>rotate</code></h3>
<p><code>rotate</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = rotate $x
# or in a pipeline:
@list |> map rotate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rotate-axis">
<h3><a class="doc-anchor" href="#doc-rotate-axis">#</a> <code>rotate_axis</code></h3>
<p><code>rotate_axis</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = rotate_axis $x
# or in a pipeline:
@list |> map rotate_axis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rotate-point">
<h3><a class="doc-anchor" href="#doc-rotate-point">#</a> <code>rotate_point</code></h3>
<p><code>rotate_point</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = rotate_point $x
# or in a pipeline:
@list |> map rotate_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roulette-wheel-select-index">
<h3><a class="doc-anchor" href="#doc-roulette-wheel-select-index">#</a> <code>roulette_wheel_select_index</code></h3>
<p><code>roulette_wheel_select_index</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = roulette_wheel_select_index $x
# or in a pipeline:
@list |> map roulette_wheel_select_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-round">
<h3><a class="doc-anchor" href="#doc-round">#</a> <code>round</code></h3>
<p><code>round</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = round $x
# or in a pipeline:
@list |> map round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-round-each">
<h3><a class="doc-anchor" href="#doc-round-each">#</a> <code>round_each</code></h3>
<p><code>round_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = round_each $x
# or in a pipeline:
@list |> map round_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-round-to">
<h3><a class="doc-anchor" href="#doc-round-to">#</a> <code>round_to</code></h3>
<p><code>round_to</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = round_to $x
# or in a pipeline:
@list |> map round_to |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rowmeans">
<h3><a class="doc-anchor" href="#doc-rowmeans">#</a> <code>rowMeans</code></h3>
<p><code>row_means</code> (alias <code>rowMeans</code>) — mean of each row. Like R's rowMeans().</p>
<pre><code class="lang-perl">p rowMeans([[2,4],[6,8]]) # [3, 7]
</code></pre>
</article>
<article class="doc-entry" id="doc-rowsums">
<h3><a class="doc-anchor" href="#doc-rowsums">#</a> <code>rowSums</code></h3>
<p><code>row_sums</code> (alias <code>rowSums</code>) — sum of each row in a matrix. Like R's rowSums().</p>
<pre><code class="lang-perl">p row_sums([[1,2,3],[4,5,6]]) # [6, 15]
</code></pre>
</article>
<article class="doc-entry" id="doc-rpad">
<h3><a class="doc-anchor" href="#doc-rpad">#</a> <code>rpad</code></h3>
<p><code>rpad</code> — trivial string ops builtin. Alias for <code>pad_right</code>.</p>
<pre><code class="lang-perl">my $result = rpad $x
# or in a pipeline:
@list |> map rpad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rpn">
<h3><a class="doc-anchor" href="#doc-rpn">#</a> <code>rpn</code></h3>
<p><code>rpn</code> — algorithms / puzzles builtin. Alias for <code>eval_rpn</code>.</p>
<pre><code class="lang-perl">my $result = rpn $x
# or in a pipeline:
@list |> map rpn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rpois">
<h3><a class="doc-anchor" href="#doc-rpois">#</a> <code>rpois</code></h3>
<p><code>rpois</code> — generate n random Poisson variates. Args: n, lambda. Like R's rpois().</p>
<pre><code class="lang-perl">my @x = @{rpois(100, 5)} # Poisson with mean 5
</code></pre>
</article>
<article class="doc-entry" id="doc-rptd">
<h3><a class="doc-anchor" href="#doc-rptd">#</a> <code>rptd</code></h3>
<p><code>rptd</code> — algebraic match builtin. Alias for <code>repeatedly</code>.</p>
<pre><code class="lang-perl">my $result = rptd $x
# or in a pipeline:
@list |> map rptd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rpush">
<h3><a class="doc-anchor" href="#doc-rpush">#</a> <code>rpush</code></h3>
<p><code>rpush</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = rpush $x
# or in a pipeline:
@list |> map rpush |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rrt-extend">
<h3><a class="doc-anchor" href="#doc-rrt-extend">#</a> <code>rrt_extend</code></h3>
<p><code>rrt_extend</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = rrt_extend $x
# or in a pipeline:
@list |> map rrt_extend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rrt-star-rewire">
<h3><a class="doc-anchor" href="#doc-rrt-star-rewire">#</a> <code>rrt_star_rewire</code></h3>
<p><code>rrt_star_rewire</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = rrt_star_rewire $x
# or in a pipeline:
@list |> map rrt_star_rewire |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rrule-next-occurrence">
<h3><a class="doc-anchor" href="#doc-rrule-next-occurrence">#</a> <code>rrule_next_occurrence</code></h3>
<p><code>rrule_next_occurrence</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = rrule_next_occurrence $x
# or in a pipeline:
@list |> map rrule_next_occurrence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-d-from-e">
<h3><a class="doc-anchor" href="#doc-rsa-d-from-e">#</a> <code>rsa_d_from_e</code></h3>
<p><code>rsa_d_from_e</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = rsa_d_from_e $x
# or in a pipeline:
@list |> map rsa_d_from_e |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-decrypt-pkcs1">
<h3><a class="doc-anchor" href="#doc-rsa-decrypt-pkcs1">#</a> <code>rsa_decrypt_pkcs1</code></h3>
<p><code>rsa_decrypt_pkcs1</code> decrypts RSA-PKCS1v15 ciphertext.</p>
<pre><code class="lang-perl">my $plain = rsa_decrypt_pkcs1($priv, $cipher)
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-encrypt-pkcs1">
<h3><a class="doc-anchor" href="#doc-rsa-encrypt-pkcs1">#</a> <code>rsa_encrypt_pkcs1</code></h3>
<p><code>rsa_encrypt_pkcs1</code> encrypts with legacy RSA-PKCS1v15 padding. Only for compatibility with old systems — prefer OAEP.</p>
<pre><code class="lang-perl">my $cipher = rsa_encrypt_pkcs1($pub, "data")
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-encrypt-simple">
<h3><a class="doc-anchor" href="#doc-rsa-encrypt-simple">#</a> <code>rsa_encrypt_simple</code></h3>
<p><code>rsa_encrypt_simple</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = rsa_encrypt_simple $x
# or in a pipeline:
@list |> map rsa_encrypt_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rsamp">
<h3><a class="doc-anchor" href="#doc-rsamp">#</a> <code>rsamp</code></h3>
<p><code>rsamp</code> — matrix operations (uncategorized batch) builtin. Alias for <code>reservoir_sample</code>.</p>
<pre><code class="lang-perl">my $result = rsamp $x
# or in a pipeline:
@list |> map rsamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rsk-size">
<h3><a class="doc-anchor" href="#doc-rsk-size">#</a> <code>rsk_size</code></h3>
<p><code>rsk_size</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = rsk_size $x
# or in a pipeline:
@list |> map rsk_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rst">
<h3><a class="doc-anchor" href="#doc-rst">#</a> <code>rst</code></h3>
<p><code>rst</code> — algebraic match builtin. Alias for <code>rest</code>.</p>
<pre><code class="lang-perl">my $result = rst $x
# or in a pipeline:
@list |> map rst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rsun">
<h3><a class="doc-anchor" href="#doc-rsun">#</a> <code>rsun</code></h3>
<p><code>rsun</code> — physics constants builtin. Alias for <code>sun_radius</code>.</p>
<pre><code class="lang-perl">my $result = rsun $x
# or in a pipeline:
@list |> map rsun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rt">
<h3><a class="doc-anchor" href="#doc-rt">#</a> <code>rt</code></h3>
<p><code>rt</code> — generate n random Student's t variates. Args: n, df. Like R's rt().</p>
<pre><code class="lang-perl">my @x = @{rt(100, 10)} # t with 10 df
</code></pre>
</article>
<article class="doc-entry" id="doc-rt-effective">
<h3><a class="doc-anchor" href="#doc-rt-effective">#</a> <code>rt_effective</code></h3>
<p><code>rt_effective</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = rt_effective $x
# or in a pipeline:
@list |> map rt_effective |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rt-serial-interval">
<h3><a class="doc-anchor" href="#doc-rt-serial-interval">#</a> <code>rt_serial_interval</code></h3>
<p><code>rt_serial_interval</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = rt_serial_interval $x
# or in a pipeline:
@list |> map rt_serial_interval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ruin-probability-lundberg">
<h3><a class="doc-anchor" href="#doc-ruin-probability-lundberg">#</a> <code>ruin_probability_lundberg</code></h3>
<p><code>ruin_probability_lundberg</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = ruin_probability_lundberg $x
# or in a pipeline:
@list |> map ruin_probability_lundberg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-run-length-decode">
<h3><a class="doc-anchor" href="#doc-run-length-decode">#</a> <code>run_length_decode</code></h3>
<p><code>run_length_decode</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = run_length_decode $x
# or in a pipeline:
@list |> map run_length_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-run-length-decode-str">
<h3><a class="doc-anchor" href="#doc-run-length-decode-str">#</a> <code>run_length_decode_str</code></h3>
<p><code>run_length_decode_str</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = run_length_decode_str $x
# or in a pipeline:
@list |> map run_length_decode_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-run-length-encode">
<h3><a class="doc-anchor" href="#doc-run-length-encode">#</a> <code>run_length_encode</code></h3>
<p><code>run_length_encode</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = run_length_encode $x
# or in a pipeline:
@list |> map run_length_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-run-length-encode-str">
<h3><a class="doc-anchor" href="#doc-run-length-encode-str">#</a> <code>run_length_encode_str</code></h3>
<p><code>run_length_encode_str</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = run_length_encode_str $x
# or in a pipeline:
@list |> map run_length_encode_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-run-off-triangle-step">
<h3><a class="doc-anchor" href="#doc-run-off-triangle-step">#</a> <code>run_off_triangle_step</code></h3>
<p><code>run_off_triangle_step</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = run_off_triangle_step $x
# or in a pipeline:
@list |> map run_off_triangle_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-runif">
<h3><a class="doc-anchor" href="#doc-runif">#</a> <code>runif</code></h3>
<p><code>runif</code> — generate n random uniform variates. Args: n [, min, max]. Like R's runif().</p>
<pre><code class="lang-perl">my @x = @{runif(100, 0, 1)} # 100 uniform [0,1]
</code></pre>
</article>
<article class="doc-entry" id="doc-running-max">
<h3><a class="doc-anchor" href="#doc-running-max">#</a> <code>running_max</code></h3>
<p><code>running_max</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = running_max $x
# or in a pipeline:
@list |> map running_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-running-mean">
<h3><a class="doc-anchor" href="#doc-running-mean">#</a> <code>running_mean</code></h3>
<p><code>running_mean</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = running_mean $x
# or in a pipeline:
@list |> map running_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-running-min">
<h3><a class="doc-anchor" href="#doc-running-min">#</a> <code>running_min</code></h3>
<p><code>running_min</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = running_min $x
# or in a pipeline:
@list |> map running_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-running-reduce">
<h3><a class="doc-anchor" href="#doc-running-reduce">#</a> <code>running_reduce</code></h3>
<p><code>running_reduce</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = running_reduce $x
# or in a pipeline:
@list |> map running_reduce |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-running-variance">
<h3><a class="doc-anchor" href="#doc-running-variance">#</a> <code>running_variance</code></h3>
<p><code>running_variance</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = running_variance $x
# or in a pipeline:
@list |> map running_variance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-runred">
<h3><a class="doc-anchor" href="#doc-runred">#</a> <code>runred</code></h3>
<p><code>runred</code> — additional missing stdlib functions builtin. Alias for <code>running_reduce</code>.</p>
<pre><code class="lang-perl">my $result = runred $x
# or in a pipeline:
@list |> map runred |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rweibull">
<h3><a class="doc-anchor" href="#doc-rweibull">#</a> <code>rweibull</code></h3>
<p><code>rweibull</code> — generate n random Weibull variates. Args: n, shape [, scale].</p>
<pre><code class="lang-perl">my @x = @{rweibull(100, 2, 1)} # Weibull(2,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-rx-gate">
<h3><a class="doc-anchor" href="#doc-rx-gate">#</a> <code>rx_gate</code></h3>
<p><code>rx_gate</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = rx_gate $x
# or in a pipeline:
@list |> map rx_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rxn-q">
<h3><a class="doc-anchor" href="#doc-rxn-q">#</a> <code>rxn_q</code></h3>
<p><code>rxn_q</code> — batch 21 builtin. Alias for <code>reaction_quotient</code>.</p>
<pre><code class="lang-perl">my $result = rxn_q $x
# or in a pipeline:
@list |> map rxn_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ry-gate">
<h3><a class="doc-anchor" href="#doc-ry-gate">#</a> <code>ry_gate</code></h3>
<p><code>ry_gate</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = ry_gate $x
# or in a pipeline:
@list |> map ry_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rydberg">
<h3><a class="doc-anchor" href="#doc-rydberg">#</a> <code>rydberg</code></h3>
<p><code>rydberg</code> — physics constants builtin. Alias for <code>rydberg_constant</code>.</p>
<pre><code class="lang-perl">my $result = rydberg $x
# or in a pipeline:
@list |> map rydberg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rydberg-constant">
<h3><a class="doc-anchor" href="#doc-rydberg-constant">#</a> <code>rydberg_constant</code></h3>
<p><code>rydberg_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = rydberg_constant $x
# or in a pipeline:
@list |> map rydberg_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rydberg-lambda">
<h3><a class="doc-anchor" href="#doc-rydberg-lambda">#</a> <code>rydberg_lambda</code></h3>
<p><code>rydberg_lambda</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = rydberg_lambda $x
# or in a pipeline:
@list |> map rydberg_lambda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ryu-takayanagi-step">
<h3><a class="doc-anchor" href="#doc-ryu-takayanagi-step">#</a> <code>ryu_takayanagi_step</code></h3>
<p><code>ryu_takayanagi_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = ryu_takayanagi_step $x
# or in a pipeline:
@list |> map ryu_takayanagi_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rz-gate">
<h3><a class="doc-anchor" href="#doc-rz-gate">#</a> <code>rz_gate</code></h3>
<p><code>rz_gate</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = rz_gate $x
# or in a pipeline:
@list |> map rz_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s1">
<h3><a class="doc-anchor" href="#doc-s1">#</a> <code>s1</code></h3>
<p><code>s1</code> — crypto / encoding builtin. Alias for <code>sha1</code>.</p>
<pre><code class="lang-perl">my $result = s1 $x
# or in a pipeline:
@list |> map s1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s224">
<h3><a class="doc-anchor" href="#doc-s224">#</a> <code>s224</code></h3>
<p><code>s224</code> — crypto / encoding builtin. Alias for <code>sha224</code>.</p>
<pre><code class="lang-perl">my $result = s224 $x
# or in a pipeline:
@list |> map s224 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s256">
<h3><a class="doc-anchor" href="#doc-s256">#</a> <code>s256</code></h3>
<p><code>s256</code> — crypto / encoding builtin. Alias for <code>sha256</code>.</p>
<pre><code class="lang-perl">my $result = s256 $x
# or in a pipeline:
@list |> map s256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s2-cell-at-lat-lng">
<h3><a class="doc-anchor" href="#doc-s2-cell-at-lat-lng">#</a> <code>s2_cell_at_lat_lng</code></h3>
<p><code>s2_cell_at_lat_lng</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = s2_cell_at_lat_lng $x
# or in a pipeline:
@list |> map s2_cell_at_lat_lng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s2-cell-id">
<h3><a class="doc-anchor" href="#doc-s2-cell-id">#</a> <code>s2_cell_id</code></h3>
<p><code>s2_cell_id</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = s2_cell_id $x
# or in a pipeline:
@list |> map s2_cell_id |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s2-cell-neighbors">
<h3><a class="doc-anchor" href="#doc-s2-cell-neighbors">#</a> <code>s2_cell_neighbors</code></h3>
<p><code>s2_cell_neighbors</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = s2_cell_neighbors $x
# or in a pipeline:
@list |> map s2_cell_neighbors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s2c">
<h3><a class="doc-anchor" href="#doc-s2c">#</a> <code>s2c</code></h3>
<p><code>s2c</code> — string processing (uncategorized batch) builtin. Alias for <code>snake_to_camel</code>.</p>
<pre><code class="lang-perl">my $result = s2c $x
# or in a pipeline:
@list |> map s2c |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s384">
<h3><a class="doc-anchor" href="#doc-s384">#</a> <code>s384</code></h3>
<p><code>s384</code> — crypto / encoding builtin. Alias for <code>sha384</code>.</p>
<pre><code class="lang-perl">my $result = s384 $x
# or in a pipeline:
@list |> map s384 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s512">
<h3><a class="doc-anchor" href="#doc-s512">#</a> <code>s512</code></h3>
<p><code>s512</code> — crypto / encoding builtin. Alias for <code>sha512</code>.</p>
<pre><code class="lang-perl">my $result = s512 $x
# or in a pipeline:
@list |> map s512 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s-to-m">
<h3><a class="doc-anchor" href="#doc-s-to-m">#</a> <code>s_to_m</code></h3>
<p><code>s_to_m</code> — unit conversions builtin. Alias for <code>seconds_to_minutes</code>.</p>
<pre><code class="lang-perl">my $result = s_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-s-to-ms">
<h3><a class="doc-anchor" href="#doc-s-to-ms">#</a> <code>s_to_ms</code></h3>
<p><code>s_to_ms</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = s_to_ms $input
</code></pre>
</article>
<article class="doc-entry" id="doc-sa-accept-prob">
<h3><a class="doc-anchor" href="#doc-sa-accept-prob">#</a> <code>sa_accept_prob</code></h3>
<p><code>sa_accept_prob</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = sa_accept_prob $x
# or in a pipeline:
@list |> map sa_accept_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sa-boltzmann-temp">
<h3><a class="doc-anchor" href="#doc-sa-boltzmann-temp">#</a> <code>sa_boltzmann_temp</code></h3>
<p><code>sa_boltzmann_temp</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = sa_boltzmann_temp $x
# or in a pipeline:
@list |> map sa_boltzmann_temp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sa-cauchy-temp">
<h3><a class="doc-anchor" href="#doc-sa-cauchy-temp">#</a> <code>sa_cauchy_temp</code></h3>
<p><code>sa_cauchy_temp</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = sa_cauchy_temp $x
# or in a pipeline:
@list |> map sa_cauchy_temp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sa-geometric-temp">
<h3><a class="doc-anchor" href="#doc-sa-geometric-temp">#</a> <code>sa_geometric_temp</code></h3>
<p><code>sa_geometric_temp</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = sa_geometric_temp $x
# or in a pipeline:
@list |> map sa_geometric_temp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sabr-implied-vol">
<h3><a class="doc-anchor" href="#doc-sabr-implied-vol">#</a> <code>sabr_implied_vol</code></h3>
<p><code>sabr_implied_vol</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = sabr_implied_vol $x
# or in a pipeline:
@list |> map sabr_implied_vol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sadd">
<h3><a class="doc-anchor" href="#doc-sadd">#</a> <code>sadd</code></h3>
<p><code>sadd</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = sadd $x
# or in a pipeline:
@list |> map sadd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-saddle-point-check">
<h3><a class="doc-anchor" href="#doc-saddle-point-check">#</a> <code>saddle_point_check</code></h3>
<p><code>saddle_point_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = saddle_point_check $x
# or in a pipeline:
@list |> map saddle_point_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-safe-div">
<h3><a class="doc-anchor" href="#doc-safe-div">#</a> <code>safe_div</code></h3>
<p><code>safe_div</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = safe_div $x
# or in a pipeline:
@list |> map safe_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-safe-log">
<h3><a class="doc-anchor" href="#doc-safe-log">#</a> <code>safe_log</code></h3>
<p><code>safe_log</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = safe_log $x
# or in a pipeline:
@list |> map safe_log |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-safe-mod">
<h3><a class="doc-anchor" href="#doc-safe-mod">#</a> <code>safe_mod</code></h3>
<p><code>safe_mod</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = safe_mod $x
# or in a pipeline:
@list |> map safe_mod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-safe-sqrt">
<h3><a class="doc-anchor" href="#doc-safe-sqrt">#</a> <code>safe_sqrt</code></h3>
<p><code>safe_sqrt</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = safe_sqrt $x
# or in a pipeline:
@list |> map safe_sqrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-salloc">
<h3><a class="doc-anchor" href="#doc-salloc">#</a> <code>salloc</code></h3>
<p><code>salloc</code> — stress / telemetry extensions builtin. Alias for <code>stress_alloc</code>.</p>
<pre><code class="lang-perl">my $result = salloc $x
# or in a pipeline:
@list |> map salloc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-salt-activity-coefficient">
<h3><a class="doc-anchor" href="#doc-salt-activity-coefficient">#</a> <code>salt_activity_coefficient</code></h3>
<p><code>salt_activity_coefficient</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = salt_activity_coefficient $x
# or in a pipeline:
@list |> map salt_activity_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sample-n">
<h3><a class="doc-anchor" href="#doc-sample-n">#</a> <code>sample_n</code></h3>
<p><code>sample_n</code> — collection (batch 2) builtin. Alias for <code>random_sample</code>.</p>
<pre><code class="lang-perl">my $result = sample_n $x
# or in a pipeline:
@list |> map sample_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sample-one">
<h3><a class="doc-anchor" href="#doc-sample-one">#</a> <code>sample_one</code></h3>
<p><code>sample_one</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = sample_one $x
# or in a pipeline:
@list |> map sample_one |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sample-stddev">
<h3><a class="doc-anchor" href="#doc-sample-stddev">#</a> <code>sample_stddev</code></h3>
<p><code>sample_stddev</code> — statistics (extended) builtin.</p>
<pre><code class="lang-perl">my $result = sample_stddev $x
# or in a pipeline:
@list |> map sample_stddev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sample-variance">
<h3><a class="doc-anchor" href="#doc-sample-variance">#</a> <code>sample_variance</code></h3>
<p><code>sample_variance</code> — statistics (extended) builtin.</p>
<pre><code class="lang-perl">my $result = sample_variance $x
# or in a pipeline:
@list |> map sample_variance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sampn">
<h3><a class="doc-anchor" href="#doc-sampn">#</a> <code>sampn</code></h3>
<p><code>sampn</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = sampn $x
# or in a pipeline:
@list |> map sampn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sapply">
<h3><a class="doc-anchor" href="#doc-sapply">#</a> <code>sapply</code></h3>
<p><code>sapply</code> — apply a function to each element, return a vector. Like R's sapply().</p>
<pre><code class="lang-perl">my @sq = @{sapply([1,2,3,4], fn { $_[0] ** 2 })} # [1,4,9,16]
</code></pre>
</article>
<article class="doc-entry" id="doc-sarimax-fit">
<h3><a class="doc-anchor" href="#doc-sarimax-fit">#</a> <code>sarimax_fit</code></h3>
<p><code>sarimax_fit</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = sarimax_fit $x
# or in a pipeline:
@list |> map sarimax_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-saros-cycle">
<h3><a class="doc-anchor" href="#doc-saros-cycle">#</a> <code>saros_cycle</code></h3>
<p><code>saros_cycle</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = saros_cycle $x
# or in a pipeline:
@list |> map saros_cycle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sarsa-update">
<h3><a class="doc-anchor" href="#doc-sarsa-update">#</a> <code>sarsa_update</code></h3>
<p><code>sarsa_update</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = sarsa_update $x
# or in a pipeline:
@list |> map sarsa_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sat01">
<h3><a class="doc-anchor" href="#doc-sat01">#</a> <code>sat01</code></h3>
<p><code>sat01</code> — trig / math (batch 2) builtin. Alias for <code>saturate</code>.</p>
<pre><code class="lang-perl">my $result = sat01 $x
# or in a pipeline:
@list |> map sat01 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-saturate">
<h3><a class="doc-anchor" href="#doc-saturate">#</a> <code>saturate</code></h3>
<p><code>saturate</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = saturate $x
# or in a pipeline:
@list |> map saturate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-saturation-equivalent-pt">
<h3><a class="doc-anchor" href="#doc-saturation-equivalent-pt">#</a> <code>saturation_equivalent_pt</code></h3>
<p><code>saturation_equivalent_pt</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = saturation_equivalent_pt $x
# or in a pipeline:
@list |> map saturation_equivalent_pt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-saturation-vapor-pressure">
<h3><a class="doc-anchor" href="#doc-saturation-vapor-pressure">#</a> <code>saturation_vapor_pressure</code></h3>
<p><code>saturation_vapor_pressure</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = saturation_vapor_pressure $x
# or in a pipeline:
@list |> map saturation_vapor_pressure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-save-pct">
<h3><a class="doc-anchor" href="#doc-save-pct">#</a> <code>save_pct</code></h3>
<p><code>save_pct</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = save_pct $x
# or in a pipeline:
@list |> map save_pct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-savgol-coef">
<h3><a class="doc-anchor" href="#doc-savgol-coef">#</a> <code>savgol_coef</code></h3>
<p><code>savgol_coef</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = savgol_coef $x
# or in a pipeline:
@list |> map savgol_coef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sbranch">
<h3><a class="doc-anchor" href="#doc-sbranch">#</a> <code>sbranch</code></h3>
<p><code>sbranch</code> — stress / telemetry extensions builtin. Alias for <code>stress_branch</code>.</p>
<pre><code class="lang-perl">my $result = sbranch $x
# or in a pipeline:
@list |> map sbranch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scalar-curvature-step">
<h3><a class="doc-anchor" href="#doc-scalar-curvature-step">#</a> <code>scalar_curvature_step</code></h3>
<p><code>scalar_curvature_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = scalar_curvature_step $x
# or in a pipeline:
@list |> map scalar_curvature_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scale">
<h3><a class="doc-anchor" href="#doc-scale">#</a> <code>scale</code></h3>
<p><code>scale</code> — standardize a vector: (x - mean) / sd. Like R's scale().</p>
<pre><code class="lang-perl">my @z = @{scale([10,20,30])} # [-1, 0, 1]
</code></pre>
</article>
<article class="doc-entry" id="doc-scale-each">
<h3><a class="doc-anchor" href="#doc-scale-each">#</a> <code>scale_each</code></h3>
<p><code>scale_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = scale_each $x
# or in a pipeline:
@list |> map scale_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scale-factor">
<h3><a class="doc-anchor" href="#doc-scale-factor">#</a> <code>scale_factor</code></h3>
<p><code>scale_factor</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = scale_factor $x
# or in a pipeline:
@list |> map scale_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scale-pitches-major">
<h3><a class="doc-anchor" href="#doc-scale-pitches-major">#</a> <code>scale_pitches_major</code></h3>
<p><code>scale_pitches_major</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = scale_pitches_major $x
# or in a pipeline:
@list |> map scale_pitches_major |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scale-pitches-minor">
<h3><a class="doc-anchor" href="#doc-scale-pitches-minor">#</a> <code>scale_pitches_minor</code></h3>
<p><code>scale_pitches_minor</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = scale_pitches_minor $x
# or in a pipeline:
@list |> map scale_pitches_minor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scale-point">
<h3><a class="doc-anchor" href="#doc-scale-point">#</a> <code>scale_point</code></h3>
<p><code>scale_point($x, $y, $sx, $sy)</code> — scales a 2D point by factors sx and sy from the origin. Returns [$x*$sx, $y*$sy]. Use for geometric transformations.</p>
<pre><code class="lang-perl">my $p = scale_point(2, 3, 2, 2)
p @$p # (4, 6)
</code></pre>
</article>
<article class="doc-entry" id="doc-scale-to-intervals">
<h3><a class="doc-anchor" href="#doc-scale-to-intervals">#</a> <code>scale_to_intervals</code></h3>
<p><code>scale_to_intervals</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = scale_to_intervals $input
</code></pre>
</article>
<article class="doc-entry" id="doc-scalept">
<h3><a class="doc-anchor" href="#doc-scalept">#</a> <code>scalept</code></h3>
<p><code>scalept</code> — geometry (extended) builtin. Alias for <code>scale_point</code>.</p>
<pre><code class="lang-perl">my $result = scalept $x
# or in a pipeline:
@list |> map scalept |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scan">
<h3><a class="doc-anchor" href="#doc-scan">#</a> <code>scan</code></h3>
<p><code>scan</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = scan $x
# or in a pipeline:
@list |> map scan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scan-axis">
<h3><a class="doc-anchor" href="#doc-scan-axis">#</a> <code>scan_axis</code></h3>
<p><code>scan_axis</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = scan_axis $x
# or in a pipeline:
@list |> map scan_axis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scan-left">
<h3><a class="doc-anchor" href="#doc-scan-left">#</a> <code>scan_left</code></h3>
<p><code>scan_left</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = scan_left $x
# or in a pipeline:
@list |> map scan_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scanl">
<h3><a class="doc-anchor" href="#doc-scanl">#</a> <code>scanl</code></h3>
<p><code>scanl</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = scanl $x
# or in a pipeline:
@list |> map scanl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scanr">
<h3><a class="doc-anchor" href="#doc-scanr">#</a> <code>scanr</code></h3>
<p><code>scanr</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = scanr $x
# or in a pipeline:
@list |> map scanr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scard">
<h3><a class="doc-anchor" href="#doc-scard">#</a> <code>scard</code></h3>
<p><code>scard</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = scard $x
# or in a pipeline:
@list |> map scard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scentroid">
<h3><a class="doc-anchor" href="#doc-scentroid">#</a> <code>scentroid</code></h3>
<p><code>spectral_centroid(\@spectrum)</code> (alias <code>scentroid</code>) — computes the spectral centroid (center of mass) of a spectrum. Indicates the 'brightness' of a sound. Returns frequency bin index.</p>
<pre><code class="lang-perl">my $psd = psd(\@signal)
p scentroid($psd) # brightness measure
</code></pre>
</article>
<article class="doc-entry" id="doc-schmidt-number-step">
<h3><a class="doc-anchor" href="#doc-schmidt-number-step">#</a> <code>schmidt_number_step</code></h3>
<p><code>schmidt_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = schmidt_number_step $x
# or in a pipeline:
@list |> map schmidt_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-school-choice-match">
<h3><a class="doc-anchor" href="#doc-school-choice-match">#</a> <code>school_choice_match</code></h3>
<p><code>school_choice_match</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = school_choice_match $x
# or in a pipeline:
@list |> map school_choice_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schottky-barrier-height">
<h3><a class="doc-anchor" href="#doc-schottky-barrier-height">#</a> <code>schottky_barrier_height</code></h3>
<p><code>schottky_barrier_height</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = schottky_barrier_height $x
# or in a pipeline:
@list |> map schottky_barrier_height |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schouten-tensor-step">
<h3><a class="doc-anchor" href="#doc-schouten-tensor-step">#</a> <code>schouten_tensor_step</code></h3>
<p><code>schouten_tensor_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = schouten_tensor_step $x
# or in a pipeline:
@list |> map schouten_tensor_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schreier-index">
<h3><a class="doc-anchor" href="#doc-schreier-index">#</a> <code>schreier_index</code></h3>
<p><code>schreier_index</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = schreier_index $x
# or in a pipeline:
@list |> map schreier_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schrodinger-step-real">
<h3><a class="doc-anchor" href="#doc-schrodinger-step-real">#</a> <code>schrodinger_step_real</code></h3>
<p><code>schrodinger_step_real</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = schrodinger_step_real $x
# or in a pipeline:
@list |> map schrodinger_step_real |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schulze-method-step">
<h3><a class="doc-anchor" href="#doc-schulze-method-step">#</a> <code>schulze_method_step</code></h3>
<p><code>schulze_method_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = schulze_method_step $x
# or in a pipeline:
@list |> map schulze_method_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schur-polynomial-eval">
<h3><a class="doc-anchor" href="#doc-schur-polynomial-eval">#</a> <code>schur_polynomial_eval</code></h3>
<p><code>schur_polynomial_eval</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = schur_polynomial_eval $x
# or in a pipeline:
@list |> map schur_polynomial_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarz">
<h3><a class="doc-anchor" href="#doc-schwarz">#</a> <code>schwarz</code></h3>
<p><code>schwarzschild_radius($mass)</code> (alias <code>schwarz</code>) — event horizon radius rs = 2GM/c² of a black hole.</p>
<pre><code class="lang-perl">p schwarz(1.989e30) # ~2954 m (Sun as black hole)
p schwarz(5.972e24) # ~0.009 m (Earth as black hole)
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarzschild-freefall-time">
<h3><a class="doc-anchor" href="#doc-schwarzschild-freefall-time">#</a> <code>schwarzschild_freefall_time</code></h3>
<p><code>schwarzschild_freefall_time</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = schwarzschild_freefall_time $x
# or in a pipeline:
@list |> map schwarzschild_freefall_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarzschild-g-rr">
<h3><a class="doc-anchor" href="#doc-schwarzschild-g-rr">#</a> <code>schwarzschild_g_rr</code></h3>
<p><code>schwarzschild_g_rr</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = schwarzschild_g_rr $x
# or in a pipeline:
@list |> map schwarzschild_g_rr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarzschild-g-tt">
<h3><a class="doc-anchor" href="#doc-schwarzschild-g-tt">#</a> <code>schwarzschild_g_tt</code></h3>
<p><code>schwarzschild_g_tt</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = schwarzschild_g_tt $x
# or in a pipeline:
@list |> map schwarzschild_g_tt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarzschild-isco">
<h3><a class="doc-anchor" href="#doc-schwarzschild-isco">#</a> <code>schwarzschild_isco</code></h3>
<p><code>schwarzschild_isco</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = schwarzschild_isco $x
# or in a pipeline:
@list |> map schwarzschild_isco |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarzschild-kruskal-step">
<h3><a class="doc-anchor" href="#doc-schwarzschild-kruskal-step">#</a> <code>schwarzschild_kruskal_step</code></h3>
<p><code>schwarzschild_kruskal_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = schwarzschild_kruskal_step $x
# or in a pipeline:
@list |> map schwarzschild_kruskal_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarzschild-radius-kg">
<h3><a class="doc-anchor" href="#doc-schwarzschild-radius-kg">#</a> <code>schwarzschild_radius_kg</code></h3>
<p><code>schwarzschild_radius_kg</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = schwarzschild_radius_kg $x
# or in a pipeline:
@list |> map schwarzschild_radius_kg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarzschild-radius-m">
<h3><a class="doc-anchor" href="#doc-schwarzschild-radius-m">#</a> <code>schwarzschild_radius_m</code></h3>
<p><code>schwarzschild_radius_m</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = schwarzschild_radius_m $x
# or in a pipeline:
@list |> map schwarzschild_radius_m |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-score-test-stat">
<h3><a class="doc-anchor" href="#doc-score-test-stat">#</a> <code>score_test_stat</code></h3>
<p><code>score_test_stat</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = score_test_stat $x
# or in a pipeline:
@list |> map score_test_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-script-name">
<h3><a class="doc-anchor" href="#doc-script-name">#</a> <code>script_name</code></h3>
<p><code>script_name</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = script_name $x
# or in a pipeline:
@list |> map script_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scrypt-round">
<h3><a class="doc-anchor" href="#doc-scrypt-round">#</a> <code>scrypt_round</code></h3>
<p><code>scrypt_round</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = scrypt_round $x
# or in a pipeline:
@list |> map scrypt_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sdbm-hash">
<h3><a class="doc-anchor" href="#doc-sdbm-hash">#</a> <code>sdbm_hash</code></h3>
<p><code>sdbm_hash</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = sdbm_hash $x
# or in a pipeline:
@list |> map sdbm_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sdiff">
<h3><a class="doc-anchor" href="#doc-sdiff">#</a> <code>sdiff</code></h3>
<p><code>sdiff</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = sdiff $x
# or in a pipeline:
@list |> map sdiff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sdivs">
<h3><a class="doc-anchor" href="#doc-sdivs">#</a> <code>sdivs</code></h3>
<p><code>sdivs</code> — math / numeric (uncategorized batch) builtin. Alias for <code>sum_divisors</code>.</p>
<pre><code class="lang-perl">my $result = sdivs $x
# or in a pipeline:
@list |> map sdivs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sdns">
<h3><a class="doc-anchor" href="#doc-sdns">#</a> <code>sdns</code></h3>
<p><code>sdns</code> — stress / telemetry extensions builtin. Alias for <code>stress_dns</code>.</p>
<pre><code class="lang-perl">my $result = sdns $x
# or in a pipeline:
@list |> map sdns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sdx">
<h3><a class="doc-anchor" href="#doc-sdx">#</a> <code>sdx</code></h3>
<p><code>sdx</code> — extended stdlib builtin. Alias for <code>soundex</code>.</p>
<pre><code class="lang-perl">my $result = sdx $x
# or in a pipeline:
@list |> map sdx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sealed-bid-first-price">
<h3><a class="doc-anchor" href="#doc-sealed-bid-first-price">#</a> <code>sealed_bid_first_price</code></h3>
<p><code>sealed_bid_first_price</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = sealed_bid_first_price $x
# or in a pipeline:
@list |> map sealed_bid_first_price |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sealed-bid-second-price">
<h3><a class="doc-anchor" href="#doc-sealed-bid-second-price">#</a> <code>sealed_bid_second_price</code></h3>
<p><code>sealed_bid_second_price</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = sealed_bid_second_price $x
# or in a pipeline:
@list |> map sealed_bid_second_price |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-searchsorted">
<h3><a class="doc-anchor" href="#doc-searchsorted">#</a> <code>searchsorted</code></h3>
<p><code>searchsorted</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = searchsorted $x
# or in a pipeline:
@list |> map searchsorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seasonal-decompose">
<h3><a class="doc-anchor" href="#doc-seasonal-decompose">#</a> <code>seasonal_decompose</code></h3>
<p><code>seasonal_decompose</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = seasonal_decompose $x
# or in a pipeline:
@list |> map seasonal_decompose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seasonal-diff">
<h3><a class="doc-anchor" href="#doc-seasonal-diff">#</a> <code>seasonal_diff</code></h3>
<p><code>seasonal_diff</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = seasonal_diff $x
# or in a pipeline:
@list |> map seasonal_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec">
<h3><a class="doc-anchor" href="#doc-sec">#</a> <code>sec</code></h3>
<p><code>sec</code> returns the secant (1/cos) of an angle in radians.</p>
<pre><code class="lang-perl">p sec(0) # 1.0
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-2fa-totp-window">
<h3><a class="doc-anchor" href="#doc-sec-2fa-totp-window">#</a> <code>sec_2fa_totp_window</code></h3>
<p><code>sec_2fa_totp_window</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_2fa_totp_window $x
# or in a pipeline:
@list |> map sec_2fa_totp_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-account-lockout-step">
<h3><a class="doc-anchor" href="#doc-sec-account-lockout-step">#</a> <code>sec_account_lockout_step</code></h3>
<p><code>sec_account_lockout_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_account_lockout_step $x
# or in a pipeline:
@list |> map sec_account_lockout_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-acme-dns-challenge">
<h3><a class="doc-anchor" href="#doc-sec-acme-dns-challenge">#</a> <code>sec_acme_dns_challenge</code></h3>
<p><code>sec_acme_dns_challenge</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_acme_dns_challenge $x
# or in a pipeline:
@list |> map sec_acme_dns_challenge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-aes-keyschedule-step">
<h3><a class="doc-anchor" href="#doc-sec-aes-keyschedule-step">#</a> <code>sec_aes_keyschedule_step</code></h3>
<p><code>sec_aes_keyschedule_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_aes_keyschedule_step $x
# or in a pipeline:
@list |> map sec_aes_keyschedule_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-aes-round-step">
<h3><a class="doc-anchor" href="#doc-sec-aes-round-step">#</a> <code>sec_aes_round_step</code></h3>
<p><code>sec_aes_round_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_aes_round_step $x
# or in a pipeline:
@list |> map sec_aes_round_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-arc-chain-step">
<h3><a class="doc-anchor" href="#doc-sec-arc-chain-step">#</a> <code>sec_arc_chain_step</code></h3>
<p><code>sec_arc_chain_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_arc_chain_step $x
# or in a pipeline:
@list |> map sec_arc_chain_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-argon2-block-step">
<h3><a class="doc-anchor" href="#doc-sec-argon2-block-step">#</a> <code>sec_argon2_block_step</code></h3>
<p><code>sec_argon2_block_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_argon2_block_step $x
# or in a pipeline:
@list |> map sec_argon2_block_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-argon2-memcost">
<h3><a class="doc-anchor" href="#doc-sec-argon2-memcost">#</a> <code>sec_argon2_memcost</code></h3>
<p><code>sec_argon2_memcost</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_argon2_memcost $x
# or in a pipeline:
@list |> map sec_argon2_memcost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-argon2-parallelism">
<h3><a class="doc-anchor" href="#doc-sec-argon2-parallelism">#</a> <code>sec_argon2_parallelism</code></h3>
<p><code>sec_argon2_parallelism</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_argon2_parallelism $x
# or in a pipeline:
@list |> map sec_argon2_parallelism |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-argon2-state-advance">
<h3><a class="doc-anchor" href="#doc-sec-argon2-state-advance">#</a> <code>sec_argon2_state_advance</code></h3>
<p><code>sec_argon2_state_advance</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_argon2_state_advance $x
# or in a pipeline:
@list |> map sec_argon2_state_advance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-argon2-timecost">
<h3><a class="doc-anchor" href="#doc-sec-argon2-timecost">#</a> <code>sec_argon2_timecost</code></h3>
<p><code>sec_argon2_timecost</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_argon2_timecost $x
# or in a pipeline:
@list |> map sec_argon2_timecost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-balloon-hash-step">
<h3><a class="doc-anchor" href="#doc-sec-balloon-hash-step">#</a> <code>sec_balloon_hash_step</code></h3>
<p><code>sec_balloon_hash_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_balloon_hash_step $x
# or in a pipeline:
@list |> map sec_balloon_hash_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-basic-constraints-ca">
<h3><a class="doc-anchor" href="#doc-sec-basic-constraints-ca">#</a> <code>sec_basic_constraints_ca</code></h3>
<p><code>sec_basic_constraints_ca</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_basic_constraints_ca $x
# or in a pipeline:
@list |> map sec_basic_constraints_ca |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-bcrypt-cost-factor">
<h3><a class="doc-anchor" href="#doc-sec-bcrypt-cost-factor">#</a> <code>sec_bcrypt_cost_factor</code></h3>
<p><code>sec_bcrypt_cost_factor</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_bcrypt_cost_factor $x
# or in a pipeline:
@list |> map sec_bcrypt_cost_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-bcrypt-round-step">
<h3><a class="doc-anchor" href="#doc-sec-bcrypt-round-step">#</a> <code>sec_bcrypt_round_step</code></h3>
<p><code>sec_bcrypt_round_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_bcrypt_round_step $x
# or in a pipeline:
@list |> map sec_bcrypt_round_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-blake3-chunk-step">
<h3><a class="doc-anchor" href="#doc-sec-blake3-chunk-step">#</a> <code>sec_blake3_chunk_step</code></h3>
<p><code>sec_blake3_chunk_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_blake3_chunk_step $x
# or in a pipeline:
@list |> map sec_blake3_chunk_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-blowfish-round-step">
<h3><a class="doc-anchor" href="#doc-sec-blowfish-round-step">#</a> <code>sec_blowfish_round_step</code></h3>
<p><code>sec_blowfish_round_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_blowfish_round_step $x
# or in a pipeline:
@list |> map sec_blowfish_round_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-brute-force-attempts">
<h3><a class="doc-anchor" href="#doc-sec-brute-force-attempts">#</a> <code>sec_brute_force_attempts</code></h3>
<p><code>sec_brute_force_attempts</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_brute_force_attempts $x
# or in a pipeline:
@list |> map sec_brute_force_attempts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-cbc-mac-block-count">
<h3><a class="doc-anchor" href="#doc-sec-cbc-mac-block-count">#</a> <code>sec_cbc_mac_block_count</code></h3>
<p><code>sec_cbc_mac_block_count</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_cbc_mac_block_count $x
# or in a pipeline:
@list |> map sec_cbc_mac_block_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-certificate-chain-depth">
<h3><a class="doc-anchor" href="#doc-sec-certificate-chain-depth">#</a> <code>sec_certificate_chain_depth</code></h3>
<p><code>sec_certificate_chain_depth</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_certificate_chain_depth $x
# or in a pipeline:
@list |> map sec_certificate_chain_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-certificate-transparency">
<h3><a class="doc-anchor" href="#doc-sec-certificate-transparency">#</a> <code>sec_certificate_transparency</code></h3>
<p><code>sec_certificate_transparency</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_certificate_transparency $x
# or in a pipeline:
@list |> map sec_certificate_transparency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-chacha20-quarterround">
<h3><a class="doc-anchor" href="#doc-sec-chacha20-quarterround">#</a> <code>sec_chacha20_quarterround</code></h3>
<p><code>sec_chacha20_quarterround</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_chacha20_quarterround $x
# or in a pipeline:
@list |> map sec_chacha20_quarterround |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-chachapoly-nonce-check">
<h3><a class="doc-anchor" href="#doc-sec-chachapoly-nonce-check">#</a> <code>sec_chachapoly_nonce_check</code></h3>
<p><code>sec_chachapoly_nonce_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_chachapoly_nonce_check $x
# or in a pipeline:
@list |> map sec_chachapoly_nonce_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-chosen-charset-strength">
<h3><a class="doc-anchor" href="#doc-sec-chosen-charset-strength">#</a> <code>sec_chosen_charset_strength</code></h3>
<p><code>sec_chosen_charset_strength</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_chosen_charset_strength $x
# or in a pipeline:
@list |> map sec_chosen_charset_strength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-cipher-suite-strength">
<h3><a class="doc-anchor" href="#doc-sec-cipher-suite-strength">#</a> <code>sec_cipher_suite_strength</code></h3>
<p><code>sec_cipher_suite_strength</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_cipher_suite_strength $x
# or in a pipeline:
@list |> map sec_cipher_suite_strength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-command-injection-score">
<h3><a class="doc-anchor" href="#doc-sec-command-injection-score">#</a> <code>sec_command_injection_score</code></h3>
<p><code>sec_command_injection_score</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_command_injection_score $x
# or in a pipeline:
@list |> map sec_command_injection_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-complexity-policy-score">
<h3><a class="doc-anchor" href="#doc-sec-complexity-policy-score">#</a> <code>sec_complexity_policy_score</code></h3>
<p><code>sec_complexity_policy_score</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_complexity_policy_score $x
# or in a pipeline:
@list |> map sec_complexity_policy_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-cors-origin-match">
<h3><a class="doc-anchor" href="#doc-sec-cors-origin-match">#</a> <code>sec_cors_origin_match</code></h3>
<p><code>sec_cors_origin_match</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_cors_origin_match $x
# or in a pipeline:
@list |> map sec_cors_origin_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-credential-stuffing-score">
<h3><a class="doc-anchor" href="#doc-sec-credential-stuffing-score">#</a> <code>sec_credential_stuffing_score</code></h3>
<p><code>sec_credential_stuffing_score</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_credential_stuffing_score $x
# or in a pipeline:
@list |> map sec_credential_stuffing_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-crl-age-seconds">
<h3><a class="doc-anchor" href="#doc-sec-crl-age-seconds">#</a> <code>sec_crl_age_seconds</code></h3>
<p><code>sec_crl_age_seconds</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_crl_age_seconds $x
# or in a pipeline:
@list |> map sec_crl_age_seconds |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-csp-directive-match">
<h3><a class="doc-anchor" href="#doc-sec-csp-directive-match">#</a> <code>sec_csp_directive_match</code></h3>
<p><code>sec_csp_directive_match</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_csp_directive_match $x
# or in a pipeline:
@list |> map sec_csp_directive_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-csrf-token-match">
<h3><a class="doc-anchor" href="#doc-sec-csrf-token-match">#</a> <code>sec_csrf_token_match</code></h3>
<p><code>sec_csrf_token_match</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_csrf_token_match $x
# or in a pipeline:
@list |> map sec_csrf_token_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-dane-tlsa-match">
<h3><a class="doc-anchor" href="#doc-sec-dane-tlsa-match">#</a> <code>sec_dane_tlsa_match</code></h3>
<p><code>sec_dane_tlsa_match</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_dane_tlsa_match $x
# or in a pipeline:
@list |> map sec_dane_tlsa_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-des-round-step">
<h3><a class="doc-anchor" href="#doc-sec-des-round-step">#</a> <code>sec_des_round_step</code></h3>
<p><code>sec_des_round_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_des_round_step $x
# or in a pipeline:
@list |> map sec_des_round_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-diameter-avp-step">
<h3><a class="doc-anchor" href="#doc-sec-diameter-avp-step">#</a> <code>sec_diameter_avp_step</code></h3>
<p><code>sec_diameter_avp_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_diameter_avp_step $x
# or in a pipeline:
@list |> map sec_diameter_avp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-diceware-word-index">
<h3><a class="doc-anchor" href="#doc-sec-diceware-word-index">#</a> <code>sec_diceware_word_index</code></h3>
<p><code>sec_diceware_word_index</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_diceware_word_index $x
# or in a pipeline:
@list |> map sec_diceware_word_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-dictionary-attack-check">
<h3><a class="doc-anchor" href="#doc-sec-dictionary-attack-check">#</a> <code>sec_dictionary_attack_check</code></h3>
<p><code>sec_dictionary_attack_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_dictionary_attack_check $x
# or in a pipeline:
@list |> map sec_dictionary_attack_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-dkim-signature-check">
<h3><a class="doc-anchor" href="#doc-sec-dkim-signature-check">#</a> <code>sec_dkim_signature_check</code></h3>
<p><code>sec_dkim_signature_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_dkim_signature_check $x
# or in a pipeline:
@list |> map sec_dkim_signature_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-dmarc-policy-check">
<h3><a class="doc-anchor" href="#doc-sec-dmarc-policy-check">#</a> <code>sec_dmarc_policy_check</code></h3>
<p><code>sec_dmarc_policy_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_dmarc_policy_check $x
# or in a pipeline:
@list |> map sec_dmarc_policy_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-dnssec-signature-check">
<h3><a class="doc-anchor" href="#doc-sec-dnssec-signature-check">#</a> <code>sec_dnssec_signature_check</code></h3>
<p><code>sec_dnssec_signature_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_dnssec_signature_check $x
# or in a pipeline:
@list |> map sec_dnssec_signature_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-ed25519-signature-step">
<h3><a class="doc-anchor" href="#doc-sec-ed25519-signature-step">#</a> <code>sec_ed25519_signature_step</code></h3>
<p><code>sec_ed25519_signature_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_ed25519_signature_step $x
# or in a pipeline:
@list |> map sec_ed25519_signature_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-ed448-signature-step">
<h3><a class="doc-anchor" href="#doc-sec-ed448-signature-step">#</a> <code>sec_ed448_signature_step</code></h3>
<p><code>sec_ed448_signature_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_ed448_signature_step $x
# or in a pipeline:
@list |> map sec_ed448_signature_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-fido2-assertion-check">
<h3><a class="doc-anchor" href="#doc-sec-fido2-assertion-check">#</a> <code>sec_fido2_assertion_check</code></h3>
<p><code>sec_fido2_assertion_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_fido2_assertion_check $x
# or in a pipeline:
@list |> map sec_fido2_assertion_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-gcm-iv-unique-check">
<h3><a class="doc-anchor" href="#doc-sec-gcm-iv-unique-check">#</a> <code>sec_gcm_iv_unique_check</code></h3>
<p><code>sec_gcm_iv_unique_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_gcm_iv_unique_check $x
# or in a pipeline:
@list |> map sec_gcm_iv_unique_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-haveibeenpwned-check">
<h3><a class="doc-anchor" href="#doc-sec-haveibeenpwned-check">#</a> <code>sec_haveibeenpwned_check</code></h3>
<p><code>sec_haveibeenpwned_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_haveibeenpwned_check $x
# or in a pipeline:
@list |> map sec_haveibeenpwned_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-hotp-counter-step">
<h3><a class="doc-anchor" href="#doc-sec-hotp-counter-step">#</a> <code>sec_hotp_counter_step</code></h3>
<p><code>sec_hotp_counter_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_hotp_counter_step $x
# or in a pipeline:
@list |> map sec_hotp_counter_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-hpkp-pin-match">
<h3><a class="doc-anchor" href="#doc-sec-hpkp-pin-match">#</a> <code>sec_hpkp_pin_match</code></h3>
<p><code>sec_hpkp_pin_match</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_hpkp_pin_match $x
# or in a pipeline:
@list |> map sec_hpkp_pin_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-html-escape-check">
<h3><a class="doc-anchor" href="#doc-sec-html-escape-check">#</a> <code>sec_html_escape_check</code></h3>
<p><code>sec_html_escape_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_html_escape_check $x
# or in a pipeline:
@list |> map sec_html_escape_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-idle-timeout-step">
<h3><a class="doc-anchor" href="#doc-sec-idle-timeout-step">#</a> <code>sec_idle_timeout_step</code></h3>
<p><code>sec_idle_timeout_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_idle_timeout_step $x
# or in a pipeline:
@list |> map sec_idle_timeout_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-idor-check">
<h3><a class="doc-anchor" href="#doc-sec-idor-check">#</a> <code>sec_idor_check</code></h3>
<p><code>sec_idor_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_idor_check $x
# or in a pipeline:
@list |> map sec_idor_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-imap-starttls-check">
<h3><a class="doc-anchor" href="#doc-sec-imap-starttls-check">#</a> <code>sec_imap_starttls_check</code></h3>
<p><code>sec_imap_starttls_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_imap_starttls_check $x
# or in a pipeline:
@list |> map sec_imap_starttls_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-jwt-alg-safe">
<h3><a class="doc-anchor" href="#doc-sec-jwt-alg-safe">#</a> <code>sec_jwt_alg_safe</code></h3>
<p><code>sec_jwt_alg_safe</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_jwt_alg_safe $x
# or in a pipeline:
@list |> map sec_jwt_alg_safe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-jwt-kid-match">
<h3><a class="doc-anchor" href="#doc-sec-jwt-kid-match">#</a> <code>sec_jwt_kid_match</code></h3>
<p><code>sec_jwt_kid_match</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_jwt_kid_match $x
# or in a pipeline:
@list |> map sec_jwt_kid_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-jwt-signature-verify">
<h3><a class="doc-anchor" href="#doc-sec-jwt-signature-verify">#</a> <code>sec_jwt_signature_verify</code></h3>
<p><code>sec_jwt_signature_verify</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_jwt_signature_verify $x
# or in a pipeline:
@list |> map sec_jwt_signature_verify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-keccak-round-step">
<h3><a class="doc-anchor" href="#doc-sec-keccak-round-step">#</a> <code>sec_keccak_round_step</code></h3>
<p><code>sec_keccak_round_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_keccak_round_step $x
# or in a pipeline:
@list |> map sec_keccak_round_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-kerberos-pac-check">
<h3><a class="doc-anchor" href="#doc-sec-kerberos-pac-check">#</a> <code>sec_kerberos_pac_check</code></h3>
<p><code>sec_kerberos_pac_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_kerberos_pac_check $x
# or in a pipeline:
@list |> map sec_kerberos_pac_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-kerberos-pre-auth">
<h3><a class="doc-anchor" href="#doc-sec-kerberos-pre-auth">#</a> <code>sec_kerberos_pre_auth</code></h3>
<p><code>sec_kerberos_pre_auth</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_kerberos_pre_auth $x
# or in a pipeline:
@list |> map sec_kerberos_pre_auth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-kerberos-ticket-age">
<h3><a class="doc-anchor" href="#doc-sec-kerberos-ticket-age">#</a> <code>sec_kerberos_ticket_age</code></h3>
<p><code>sec_kerberos_ticket_age</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_kerberos_ticket_age $x
# or in a pipeline:
@list |> map sec_kerberos_ticket_age |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-keystroke-timing-var">
<h3><a class="doc-anchor" href="#doc-sec-keystroke-timing-var">#</a> <code>sec_keystroke_timing_var</code></h3>
<p><code>sec_keystroke_timing_var</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_keystroke_timing_var $x
# or in a pipeline:
@list |> map sec_keystroke_timing_var |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-ldap-bind-step">
<h3><a class="doc-anchor" href="#doc-sec-ldap-bind-step">#</a> <code>sec_ldap_bind_step</code></h3>
<p><code>sec_ldap_bind_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_ldap_bind_step $x
# or in a pipeline:
@list |> map sec_ldap_bind_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-login-throttle-step">
<h3><a class="doc-anchor" href="#doc-sec-login-throttle-step">#</a> <code>sec_login_throttle_step</code></h3>
<p><code>sec_login_throttle_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_login_throttle_step $x
# or in a pipeline:
@list |> map sec_login_throttle_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-oauth2-pkce-step">
<h3><a class="doc-anchor" href="#doc-sec-oauth2-pkce-step">#</a> <code>sec_oauth2_pkce_step</code></h3>
<p><code>sec_oauth2_pkce_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_oauth2_pkce_step $x
# or in a pipeline:
@list |> map sec_oauth2_pkce_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-oauth2-state-validate">
<h3><a class="doc-anchor" href="#doc-sec-oauth2-state-validate">#</a> <code>sec_oauth2_state_validate</code></h3>
<p><code>sec_oauth2_state_validate</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_oauth2_state_validate $x
# or in a pipeline:
@list |> map sec_oauth2_state_validate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-oauth-nonce-check">
<h3><a class="doc-anchor" href="#doc-sec-oauth-nonce-check">#</a> <code>sec_oauth_nonce_check</code></h3>
<p><code>sec_oauth_nonce_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_oauth_nonce_check $x
# or in a pipeline:
@list |> map sec_oauth_nonce_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-oidc-id-token-age">
<h3><a class="doc-anchor" href="#doc-sec-oidc-id-token-age">#</a> <code>sec_oidc_id_token_age</code></h3>
<p><code>sec_oidc_id_token_age</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_oidc_id_token_age $x
# or in a pipeline:
@list |> map sec_oidc_id_token_age |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-p384-curve-step">
<h3><a class="doc-anchor" href="#doc-sec-p384-curve-step">#</a> <code>sec_p384_curve_step</code></h3>
<p><code>sec_p384_curve_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_p384_curve_step $x
# or in a pipeline:
@list |> map sec_p384_curve_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-passphrase-entropy">
<h3><a class="doc-anchor" href="#doc-sec-passphrase-entropy">#</a> <code>sec_passphrase_entropy</code></h3>
<p><code>sec_passphrase_entropy</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_passphrase_entropy $x
# or in a pipeline:
@list |> map sec_passphrase_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-password-history-check">
<h3><a class="doc-anchor" href="#doc-sec-password-history-check">#</a> <code>sec_password_history_check</code></h3>
<p><code>sec_password_history_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_password_history_check $x
# or in a pipeline:
@list |> map sec_password_history_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-password-strength-zxcvbn">
<h3><a class="doc-anchor" href="#doc-sec-password-strength-zxcvbn">#</a> <code>sec_password_strength_zxcvbn</code></h3>
<p><code>sec_password_strength_zxcvbn</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_password_strength_zxcvbn $x
# or in a pipeline:
@list |> map sec_password_strength_zxcvbn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-path-traversal-detect">
<h3><a class="doc-anchor" href="#doc-sec-path-traversal-detect">#</a> <code>sec_path_traversal_detect</code></h3>
<p><code>sec_path_traversal_detect</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_path_traversal_detect $x
# or in a pipeline:
@list |> map sec_path_traversal_detect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-pbkdf2-iter">
<h3><a class="doc-anchor" href="#doc-sec-pbkdf2-iter">#</a> <code>sec_pbkdf2_iter</code></h3>
<p><code>sec_pbkdf2_iter</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_pbkdf2_iter $x
# or in a pipeline:
@list |> map sec_pbkdf2_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-pinning-compare">
<h3><a class="doc-anchor" href="#doc-sec-pinning-compare">#</a> <code>sec_pinning_compare</code></h3>
<p><code>sec_pinning_compare</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_pinning_compare $x
# or in a pipeline:
@list |> map sec_pinning_compare |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-pki-path-validate">
<h3><a class="doc-anchor" href="#doc-sec-pki-path-validate">#</a> <code>sec_pki_path_validate</code></h3>
<p><code>sec_pki_path_validate</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_pki_path_validate $x
# or in a pipeline:
@list |> map sec_pki_path_validate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-pop3-security-step">
<h3><a class="doc-anchor" href="#doc-sec-pop3-security-step">#</a> <code>sec_pop3_security_step</code></h3>
<p><code>sec_pop3_security_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_pop3_security_step $x
# or in a pipeline:
@list |> map sec_pop3_security_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-radius-auth-step">
<h3><a class="doc-anchor" href="#doc-sec-radius-auth-step">#</a> <code>sec_radius_auth_step</code></h3>
<p><code>sec_radius_auth_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_radius_auth_step $x
# or in a pipeline:
@list |> map sec_radius_auth_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-revocation-ocsp-check">
<h3><a class="doc-anchor" href="#doc-sec-revocation-ocsp-check">#</a> <code>sec_revocation_ocsp_check</code></h3>
<p><code>sec_revocation_ocsp_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_revocation_ocsp_check $x
# or in a pipeline:
@list |> map sec_revocation_ocsp_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-saml-assertion-age">
<h3><a class="doc-anchor" href="#doc-sec-saml-assertion-age">#</a> <code>sec_saml_assertion_age</code></h3>
<p><code>sec_saml_assertion_age</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_saml_assertion_age $x
# or in a pipeline:
@list |> map sec_saml_assertion_age |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-san-match-count">
<h3><a class="doc-anchor" href="#doc-sec-san-match-count">#</a> <code>sec_san_match_count</code></h3>
<p><code>sec_san_match_count</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_san_match_count $x
# or in a pipeline:
@list |> map sec_san_match_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-scrypt-n-param">
<h3><a class="doc-anchor" href="#doc-sec-scrypt-n-param">#</a> <code>sec_scrypt_n_param</code></h3>
<p><code>sec_scrypt_n_param</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_scrypt_n_param $x
# or in a pipeline:
@list |> map sec_scrypt_n_param |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-scrypt-p-param">
<h3><a class="doc-anchor" href="#doc-sec-scrypt-p-param">#</a> <code>sec_scrypt_p_param</code></h3>
<p><code>sec_scrypt_p_param</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_scrypt_p_param $x
# or in a pipeline:
@list |> map sec_scrypt_p_param |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-scrypt-r-param">
<h3><a class="doc-anchor" href="#doc-sec-scrypt-r-param">#</a> <code>sec_scrypt_r_param</code></h3>
<p><code>sec_scrypt_r_param</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_scrypt_r_param $x
# or in a pipeline:
@list |> map sec_scrypt_r_param |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-secp256k1-step">
<h3><a class="doc-anchor" href="#doc-sec-secp256k1-step">#</a> <code>sec_secp256k1_step</code></h3>
<p><code>sec_secp256k1_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_secp256k1_step $x
# or in a pipeline:
@list |> map sec_secp256k1_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-serpent-round-step">
<h3><a class="doc-anchor" href="#doc-sec-serpent-round-step">#</a> <code>sec_serpent_round_step</code></h3>
<p><code>sec_serpent_round_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_serpent_round_step $x
# or in a pipeline:
@list |> map sec_serpent_round_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-session-lifetime">
<h3><a class="doc-anchor" href="#doc-sec-session-lifetime">#</a> <code>sec_session_lifetime</code></h3>
<p><code>sec_session_lifetime</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_session_lifetime $x
# or in a pipeline:
@list |> map sec_session_lifetime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-sha3-padding-step">
<h3><a class="doc-anchor" href="#doc-sec-sha3-padding-step">#</a> <code>sec_sha3_padding_step</code></h3>
<p><code>sec_sha3_padding_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_sha3_padding_step $x
# or in a pipeline:
@list |> map sec_sha3_padding_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-smtp-ssl-check">
<h3><a class="doc-anchor" href="#doc-sec-smtp-ssl-check">#</a> <code>sec_smtp_ssl_check</code></h3>
<p><code>sec_smtp_ssl_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_smtp_ssl_check $x
# or in a pipeline:
@list |> map sec_smtp_ssl_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-spf-pass-check">
<h3><a class="doc-anchor" href="#doc-sec-spf-pass-check">#</a> <code>sec_spf_pass_check</code></h3>
<p><code>sec_spf_pass_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_spf_pass_check $x
# or in a pipeline:
@list |> map sec_spf_pass_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-sqli-pattern-score">
<h3><a class="doc-anchor" href="#doc-sec-sqli-pattern-score">#</a> <code>sec_sqli_pattern_score</code></h3>
<p><code>sec_sqli_pattern_score</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_sqli_pattern_score $x
# or in a pipeline:
@list |> map sec_sqli_pattern_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-ssl3-disabled-check">
<h3><a class="doc-anchor" href="#doc-sec-ssl3-disabled-check">#</a> <code>sec_ssl3_disabled_check</code></h3>
<p><code>sec_ssl3_disabled_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_ssl3_disabled_check $x
# or in a pipeline:
@list |> map sec_ssl3_disabled_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-tls11-deprecation-check">
<h3><a class="doc-anchor" href="#doc-sec-tls11-deprecation-check">#</a> <code>sec_tls11_deprecation_check</code></h3>
<p><code>sec_tls11_deprecation_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_tls11_deprecation_check $x
# or in a pipeline:
@list |> map sec_tls11_deprecation_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-tls12-handshake-step">
<h3><a class="doc-anchor" href="#doc-sec-tls12-handshake-step">#</a> <code>sec_tls12_handshake_step</code></h3>
<p><code>sec_tls12_handshake_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_tls12_handshake_step $x
# or in a pipeline:
@list |> map sec_tls12_handshake_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-tls13-handshake-step">
<h3><a class="doc-anchor" href="#doc-sec-tls13-handshake-step">#</a> <code>sec_tls13_handshake_step</code></h3>
<p><code>sec_tls13_handshake_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_tls13_handshake_step $x
# or in a pipeline:
@list |> map sec_tls13_handshake_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-tls-alert-severity">
<h3><a class="doc-anchor" href="#doc-sec-tls-alert-severity">#</a> <code>sec_tls_alert_severity</code></h3>
<p><code>sec_tls_alert_severity</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_tls_alert_severity $x
# or in a pipeline:
@list |> map sec_tls_alert_severity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-totp-drift-check">
<h3><a class="doc-anchor" href="#doc-sec-totp-drift-check">#</a> <code>sec_totp_drift_check</code></h3>
<p><code>sec_totp_drift_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_totp_drift_check $x
# or in a pipeline:
@list |> map sec_totp_drift_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-twofish-round-step">
<h3><a class="doc-anchor" href="#doc-sec-twofish-round-step">#</a> <code>sec_twofish_round_step</code></h3>
<p><code>sec_twofish_round_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_twofish_round_step $x
# or in a pipeline:
@list |> map sec_twofish_round_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-url-safe-encode-check">
<h3><a class="doc-anchor" href="#doc-sec-url-safe-encode-check">#</a> <code>sec_url_safe_encode_check</code></h3>
<p><code>sec_url_safe_encode_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_url_safe_encode_check $x
# or in a pipeline:
@list |> map sec_url_safe_encode_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-webauthn-attestation-check">
<h3><a class="doc-anchor" href="#doc-sec-webauthn-attestation-check">#</a> <code>sec_webauthn_attestation_check</code></h3>
<p><code>sec_webauthn_attestation_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_webauthn_attestation_check $x
# or in a pipeline:
@list |> map sec_webauthn_attestation_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-x25519-clamping-step">
<h3><a class="doc-anchor" href="#doc-sec-x25519-clamping-step">#</a> <code>sec_x25519_clamping_step</code></h3>
<p><code>sec_x25519_clamping_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_x25519_clamping_step $x
# or in a pipeline:
@list |> map sec_x25519_clamping_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-x509-subject-match">
<h3><a class="doc-anchor" href="#doc-sec-x509-subject-match">#</a> <code>sec_x509_subject_match</code></h3>
<p><code>sec_x509_subject_match</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_x509_subject_match $x
# or in a pipeline:
@list |> map sec_x509_subject_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-xkcd-passphrase-score">
<h3><a class="doc-anchor" href="#doc-sec-xkcd-passphrase-score">#</a> <code>sec_xkcd_passphrase_score</code></h3>
<p><code>sec_xkcd_passphrase_score</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_xkcd_passphrase_score $x
# or in a pipeline:
@list |> map sec_xkcd_passphrase_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-xss-filter-score">
<h3><a class="doc-anchor" href="#doc-sec-xss-filter-score">#</a> <code>sec_xss_filter_score</code></h3>
<p><code>sec_xss_filter_score</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_xss_filter_score $x
# or in a pipeline:
@list |> map sec_xss_filter_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-xxe-dtd-check">
<h3><a class="doc-anchor" href="#doc-sec-xxe-dtd-check">#</a> <code>sec_xxe_dtd_check</code></h3>
<p><code>sec_xxe_dtd_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_xxe_dtd_check $x
# or in a pipeline:
@list |> map sec_xxe_dtd_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-xxe-pattern-score">
<h3><a class="doc-anchor" href="#doc-sec-xxe-pattern-score">#</a> <code>sec_xxe_pattern_score</code></h3>
<p><code>sec_xxe_pattern_score</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_xxe_pattern_score $x
# or in a pipeline:
@list |> map sec_xxe_pattern_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-yescrypt-step">
<h3><a class="doc-anchor" href="#doc-sec-yescrypt-step">#</a> <code>sec_yescrypt_step</code></h3>
<p><code>sec_yescrypt_step</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_yescrypt_step $x
# or in a pipeline:
@list |> map sec_yescrypt_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec-yubikey-otp-check">
<h3><a class="doc-anchor" href="#doc-sec-yubikey-otp-check">#</a> <code>sec_yubikey_otp_check</code></h3>
<p><code>sec_yubikey_otp_check</code> — batch 51 builtin.</p>
<pre><code class="lang-perl">my $result = sec_yubikey_otp_check $x
# or in a pipeline:
@list |> map sec_yubikey_otp_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-secant">
<h3><a class="doc-anchor" href="#doc-secant">#</a> <code>secant</code></h3>
<p><code>secant</code> — batch 19 builtin. Alias for <code>secant_root</code>.</p>
<pre><code class="lang-perl">my $result = secant $x
# or in a pipeline:
@list |> map secant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-secant-root">
<h3><a class="doc-anchor" href="#doc-secant-root">#</a> <code>secant_root</code></h3>
<p><code>secant_root</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = secant_root $x
# or in a pipeline:
@list |> map secant_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-second">
<h3><a class="doc-anchor" href="#doc-second">#</a> <code>second</code></h3>
<p><code>second</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = second $x
# or in a pipeline:
@list |> map second |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-second-arg">
<h3><a class="doc-anchor" href="#doc-second-arg">#</a> <code>second_arg</code></h3>
<p><code>second_arg</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = second_arg $x
# or in a pipeline:
@list |> map second_arg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-second-elem">
<h3><a class="doc-anchor" href="#doc-second-elem">#</a> <code>second_elem</code></h3>
<p><code>second_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = second_elem $x
# or in a pipeline:
@list |> map second_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-second-order-concentration">
<h3><a class="doc-anchor" href="#doc-second-order-concentration">#</a> <code>second_order_concentration</code></h3>
<p><code>second_order_concentration</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = second_order_concentration $x
# or in a pipeline:
@list |> map second_order_concentration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-second-order-half-life">
<h3><a class="doc-anchor" href="#doc-second-order-half-life">#</a> <code>second_order_half_life</code></h3>
<p><code>second_order_half_life</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = second_order_half_life $x
# or in a pipeline:
@list |> map second_order_half_life |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seconds-to-days">
<h3><a class="doc-anchor" href="#doc-seconds-to-days">#</a> <code>seconds_to_days</code></h3>
<p><code>seconds_to_days</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = seconds_to_days $input
</code></pre>
</article>
<article class="doc-entry" id="doc-seconds-to-hours">
<h3><a class="doc-anchor" href="#doc-seconds-to-hours">#</a> <code>seconds_to_hours</code></h3>
<p><code>seconds_to_hours</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = seconds_to_hours $input
</code></pre>
</article>
<article class="doc-entry" id="doc-seconds-to-minutes">
<h3><a class="doc-anchor" href="#doc-seconds-to-minutes">#</a> <code>seconds_to_minutes</code></h3>
<p><code>seconds_to_minutes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = seconds_to_minutes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-secp256k1-y-recover">
<h3><a class="doc-anchor" href="#doc-secp256k1-y-recover">#</a> <code>secp256k1_y_recover</code></h3>
<p><code>secp256k1_y_recover</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = secp256k1_y_recover $x
# or in a pipeline:
@list |> map secp256k1_y_recover |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sectarea">
<h3><a class="doc-anchor" href="#doc-sectarea">#</a> <code>sectarea</code></h3>
<p><code>sectarea</code> — geometry (extended) builtin. Alias for <code>sector_area</code>.</p>
<pre><code class="lang-perl">my $result = sectarea $x
# or in a pipeline:
@list |> map sectarea |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sectional-curvature-two-plane">
<h3><a class="doc-anchor" href="#doc-sectional-curvature-two-plane">#</a> <code>sectional_curvature_two_plane</code></h3>
<p><code>sectional_curvature_two_plane</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = sectional_curvature_two_plane $x
# or in a pipeline:
@list |> map sectional_curvature_two_plane |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sector-area">
<h3><a class="doc-anchor" href="#doc-sector-area">#</a> <code>sector_area</code></h3>
<p><code>sector_area($radius, $theta)</code> — computes the area of a circular sector. Theta is the central angle in radians. Returns <code>0.5 * r² * theta</code>.</p>
<pre><code class="lang-perl">p sector_area(10, 3.14159) # ~157 (half circle)
p sector_area(5, 1.57) # ~19.6
</code></pre>
</article>
<article class="doc-entry" id="doc-seg-sum">
<h3><a class="doc-anchor" href="#doc-seg-sum">#</a> <code>seg_sum</code></h3>
<p><code>seg_sum</code> — batch 10 builtin. Alias for <code>segment_tree_sum</code>.</p>
<pre><code class="lang-perl">my $result = seg_sum $x
# or in a pipeline:
@list |> map seg_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-segment-distance-point">
<h3><a class="doc-anchor" href="#doc-segment-distance-point">#</a> <code>segment_distance_point</code></h3>
<p><code>segment_distance_point</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = segment_distance_point $x
# or in a pipeline:
@list |> map segment_distance_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-segment-intersection">
<h3><a class="doc-anchor" href="#doc-segment-intersection">#</a> <code>segment_intersection</code></h3>
<p><code>segment_intersection</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = segment_intersection $x
# or in a pipeline:
@list |> map segment_intersection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-segment-length">
<h3><a class="doc-anchor" href="#doc-segment-length">#</a> <code>segment_length</code></h3>
<p><code>segment_length</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = segment_length $x
# or in a pipeline:
@list |> map segment_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-segment-tree-sum">
<h3><a class="doc-anchor" href="#doc-segment-tree-sum">#</a> <code>segment_tree_sum</code></h3>
<p><code>segment_tree_sum</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = segment_tree_sum $x
# or in a pipeline:
@list |> map segment_tree_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-segments-parallel-q">
<h3><a class="doc-anchor" href="#doc-segments-parallel-q">#</a> <code>segments_parallel_q</code></h3>
<p><code>segments_parallel_q</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = segments_parallel_q $x
# or in a pipeline:
@list |> map segments_parallel_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-segments-perpendicular-q">
<h3><a class="doc-anchor" href="#doc-segments-perpendicular-q">#</a> <code>segments_perpendicular_q</code></h3>
<p><code>segments_perpendicular_q</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = segments_perpendicular_q $x
# or in a pipeline:
@list |> map segments_perpendicular_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sei-resistance-growth">
<h3><a class="doc-anchor" href="#doc-sei-resistance-growth">#</a> <code>sei_resistance_growth</code></h3>
<p><code>sei_resistance_growth</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = sei_resistance_growth $x
# or in a pipeline:
@list |> map sei_resistance_growth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seiberg-witten-value">
<h3><a class="doc-anchor" href="#doc-seiberg-witten-value">#</a> <code>seiberg_witten_value</code></h3>
<p><code>seiberg_witten_value</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = seiberg_witten_value $x
# or in a pipeline:
@list |> map seiberg_witten_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seifert-form-2x2">
<h3><a class="doc-anchor" href="#doc-seifert-form-2x2">#</a> <code>seifert_form_2x2</code></h3>
<p><code>seifert_form_2x2</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = seifert_form_2x2 $x
# or in a pipeline:
@list |> map seifert_form_2x2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seifert-genus-lower">
<h3><a class="doc-anchor" href="#doc-seifert-genus-lower">#</a> <code>seifert_genus_lower</code></h3>
<p><code>seifert_genus_lower</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = seifert_genus_lower $x
# or in a pipeline:
@list |> map seifert_genus_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seir-step">
<h3><a class="doc-anchor" href="#doc-seir-step">#</a> <code>seir_step</code></h3>
<p><code>seir_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = seir_step $x
# or in a pipeline:
@list |> map seir_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seird-step">
<h3><a class="doc-anchor" href="#doc-seird-step">#</a> <code>seird_step</code></h3>
<p><code>seird_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = seird_step $x
# or in a pipeline:
@list |> map seird_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seirs-step">
<h3><a class="doc-anchor" href="#doc-seirs-step">#</a> <code>seirs_step</code></h3>
<p><code>seirs_step</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = seirs_step $x
# or in a pipeline:
@list |> map seirs_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-select-period-step">
<h3><a class="doc-anchor" href="#doc-select-period-step">#</a> <code>select_period_step</code></h3>
<p><code>select_period_step</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = select_period_step $x
# or in a pipeline:
@list |> map select_period_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-select-ultimate">
<h3><a class="doc-anchor" href="#doc-select-ultimate">#</a> <code>select_ultimate</code></h3>
<p><code>select_ultimate</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = select_ultimate $x
# or in a pipeline:
@list |> map select_ultimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-selection-step">
<h3><a class="doc-anchor" href="#doc-selection-step">#</a> <code>selection_step</code></h3>
<p><code>selection_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = selection_step $x
# or in a pipeline:
@list |> map selection_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-selu">
<h3><a class="doc-anchor" href="#doc-selu">#</a> <code>selu</code></h3>
<p><code>selu</code> applies the Scaled ELU with fixed lambda=1.0507, alpha=1.6733 for self-normalizing networks.</p>
<pre><code class="lang-perl">p selu(1) # 1.0507
p selu(-1) # -1.1113
</code></pre>
</article>
<article class="doc-entry" id="doc-semctl">
<h3><a class="doc-anchor" href="#doc-semctl">#</a> <code>semctl</code></h3>
<p><code>semctl</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = semctl $x
# or in a pipeline:
@list |> map semctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-semget">
<h3><a class="doc-anchor" href="#doc-semget">#</a> <code>semget</code></h3>
<p><code>semget</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = semget $x
# or in a pipeline:
@list |> map semget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-semi-major-axis">
<h3><a class="doc-anchor" href="#doc-semi-major-axis">#</a> <code>semi_major_axis</code></h3>
<p><code>semi_major_axis</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = semi_major_axis $x
# or in a pipeline:
@list |> map semi_major_axis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-semop">
<h3><a class="doc-anchor" href="#doc-semop">#</a> <code>semop</code></h3>
<p><code>semop</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = semop $x
# or in a pipeline:
@list |> map semop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sentence-case">
<h3><a class="doc-anchor" href="#doc-sentence-case">#</a> <code>sentence_case</code></h3>
<p><code>sentence_case</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = sentence_case $x
# or in a pipeline:
@list |> map sentence_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seq">
<h3><a class="doc-anchor" href="#doc-seq">#</a> <code>seq</code></h3>
<p><code>seq</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = seq $x
# or in a pipeline:
@list |> map seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seq-fn">
<h3><a class="doc-anchor" href="#doc-seq-fn">#</a> <code>seq_fn</code></h3>
<p><code>seq_fn</code> — generate a numeric sequence from, to, by. Like R's seq().</p>
<pre><code class="lang-perl">my @s = @{seq_fn(1, 10, 2)} # [1,3,5,7,9]
my @r = @{seq_fn(5, 1, -1)} # [5,4,3,2,1]
</code></pre>
</article>
<article class="doc-entry" id="doc-seq-logo-information">
<h3><a class="doc-anchor" href="#doc-seq-logo-information">#</a> <code>seq_logo_information</code></h3>
<p><code>seq_logo_information</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = seq_logo_information $x
# or in a pipeline:
@list |> map seq_logo_information |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sequence-shannon-info">
<h3><a class="doc-anchor" href="#doc-sequence-shannon-info">#</a> <code>sequence_shannon_info</code></h3>
<p><code>sequence_shannon_info</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = sequence_shannon_info $x
# or in a pipeline:
@list |> map sequence_shannon_info |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sequent-left-intro">
<h3><a class="doc-anchor" href="#doc-sequent-left-intro">#</a> <code>sequent_left_intro</code></h3>
<p><code>sequent_left_intro</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = sequent_left_intro $x
# or in a pipeline:
@list |> map sequent_left_intro |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sequent-right-intro">
<h3><a class="doc-anchor" href="#doc-sequent-right-intro">#</a> <code>sequent_right_intro</code></h3>
<p><code>sequent_right_intro</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = sequent_right_intro $x
# or in a pipeline:
@list |> map sequent_right_intro |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sequential-eq-check">
<h3><a class="doc-anchor" href="#doc-sequential-eq-check">#</a> <code>sequential_eq_check</code></h3>
<p><code>sequential_eq_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = sequential_eq_check $x
# or in a pipeline:
@list |> map sequential_eq_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-servo-position-velocity">
<h3><a class="doc-anchor" href="#doc-servo-position-velocity">#</a> <code>servo_position_velocity</code></h3>
<p><code>servo_position_velocity</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = servo_position_velocity $x
# or in a pipeline:
@list |> map servo_position_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-servo-torque-step">
<h3><a class="doc-anchor" href="#doc-servo-torque-step">#</a> <code>servo_torque_step</code></h3>
<p><code>servo_torque_step</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = servo_torque_step $x
# or in a pipeline:
@list |> map servo_torque_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-set-at">
<h3><a class="doc-anchor" href="#doc-set-at">#</a> <code>set_at</code></h3>
<p><code>set_at</code> — batch 9 builtin. Alias for <code>replace_at_index</code>.</p>
<pre><code class="lang-perl">my $result = set_at $x
# or in a pipeline:
@list |> map set_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-set-cover-greedy-step">
<h3><a class="doc-anchor" href="#doc-set-cover-greedy-step">#</a> <code>set_cover_greedy_step</code></h3>
<p><code>set_cover_greedy_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = set_cover_greedy_step $x
# or in a pipeline:
@list |> map set_cover_greedy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-set-cover-lp-round">
<h3><a class="doc-anchor" href="#doc-set-cover-lp-round">#</a> <code>set_cover_lp_round</code></h3>
<p><code>set_cover_lp_round</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = set_cover_lp_round $x
# or in a pipeline:
@list |> map set_cover_lp_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-set-subname">
<h3><a class="doc-anchor" href="#doc-set-subname">#</a> <code>set_subname</code></h3>
<p><code>set_subname</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = set_subname $x
# or in a pipeline:
@list |> map set_subname |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setex">
<h3><a class="doc-anchor" href="#doc-setex">#</a> <code>setex</code></h3>
<p><code>setex</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = setex $x
# or in a pipeline:
@list |> map setex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setgrent">
<h3><a class="doc-anchor" href="#doc-setgrent">#</a> <code>setgrent</code></h3>
<p><code>setgrent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setgrent $x
# or in a pipeline:
@list |> map setgrent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sethostent">
<h3><a class="doc-anchor" href="#doc-sethostent">#</a> <code>sethostent</code></h3>
<p><code>sethostent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = sethostent $x
# or in a pipeline:
@list |> map sethostent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setnetent">
<h3><a class="doc-anchor" href="#doc-setnetent">#</a> <code>setnetent</code></h3>
<p><code>setnetent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setnetent $x
# or in a pipeline:
@list |> map setnetent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setnx">
<h3><a class="doc-anchor" href="#doc-setnx">#</a> <code>setnx</code></h3>
<p><code>setnx</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = setnx $x
# or in a pipeline:
@list |> map setnx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setprotoent">
<h3><a class="doc-anchor" href="#doc-setprotoent">#</a> <code>setprotoent</code></h3>
<p><code>setprotoent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setprotoent $x
# or in a pipeline:
@list |> map setprotoent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setpwent">
<h3><a class="doc-anchor" href="#doc-setpwent">#</a> <code>setpwent</code></h3>
<p><code>setpwent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setpwent $x
# or in a pipeline:
@list |> map setpwent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setrange">
<h3><a class="doc-anchor" href="#doc-setrange">#</a> <code>setrange</code></h3>
<p><code>setrange</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = setrange $x
# or in a pipeline:
@list |> map setrange |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setservent">
<h3><a class="doc-anchor" href="#doc-setservent">#</a> <code>setservent</code></h3>
<p><code>setservent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setservent $x
# or in a pipeline:
@list |> map setservent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seven-smooth-q">
<h3><a class="doc-anchor" href="#doc-seven-smooth-q">#</a> <code>seven_smooth_q</code></h3>
<p><code>seven_smooth_q</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = seven_smooth_q $x
# or in a pipeline:
@list |> map seven_smooth_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sfork">
<h3><a class="doc-anchor" href="#doc-sfork">#</a> <code>sfork</code></h3>
<p><code>sfork</code> — stress / telemetry extensions builtin. Alias for <code>stress_fork</code>.</p>
<pre><code class="lang-perl">my $result = sfork $x
# or in a pipeline:
@list |> map sfork |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sgemm">
<h3><a class="doc-anchor" href="#doc-sgemm">#</a> <code>sgemm</code></h3>
<p><code>sgemm</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = sgemm $x
# or in a pipeline:
@list |> map sgemm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sgemv">
<h3><a class="doc-anchor" href="#doc-sgemv">#</a> <code>sgemv</code></h3>
<p><code>sgemv</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = sgemv $x
# or in a pipeline:
@list |> map sgemv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sgnum">
<h3><a class="doc-anchor" href="#doc-sgnum">#</a> <code>sgnum</code></h3>
<p><code>sgnum</code> — extended stdlib builtin. Alias for <code>signum_of</code>.</p>
<pre><code class="lang-perl">my $result = sgnum $x
# or in a pipeline:
@list |> map sgnum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sgp4-propagate-step">
<h3><a class="doc-anchor" href="#doc-sgp4-propagate-step">#</a> <code>sgp4_propagate_step</code></h3>
<p><code>sgp4_propagate_step</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = sgp4_propagate_step $x
# or in a pipeline:
@list |> map sgp4_propagate_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shake-map-pga">
<h3><a class="doc-anchor" href="#doc-shake-map-pga">#</a> <code>shake_map_pga</code></h3>
<p><code>shake_map_pga</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = shake_map_pga $x
# or in a pipeline:
@list |> map shake_map_pga |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shanks-transform">
<h3><a class="doc-anchor" href="#doc-shanks-transform">#</a> <code>shanks_transform</code></h3>
<p><code>shanks_transform</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = shanks_transform $x
# or in a pipeline:
@list |> map shanks_transform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shannon-fano-elias-code">
<h3><a class="doc-anchor" href="#doc-shannon-fano-elias-code">#</a> <code>shannon_fano_elias_code</code></h3>
<p><code>shannon_fano_elias_code</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = shannon_fano_elias_code $x
# or in a pipeline:
@list |> map shannon_fano_elias_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shape-operator-eig">
<h3><a class="doc-anchor" href="#doc-shape-operator-eig">#</a> <code>shape_operator_eig</code></h3>
<p><code>shape_operator_eig</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = shape_operator_eig $x
# or in a pipeline:
@list |> map shape_operator_eig |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shapiro">
<h3><a class="doc-anchor" href="#doc-shapiro">#</a> <code>shapiro</code></h3>
<p><code>shapiro_test</code> (alias <code>shapiro</code>) — Shapiro-Wilk normality test. Returns W statistic (close to 1 = normal). Like R's shapiro.test().</p>
<pre><code class="lang-perl">p shapiro([rnorm(100)]) # W ≈ 0.99 for normal data
p shapiro([1,1,1,2,10]) # W < 0.9 for non-normal
</code></pre>
</article>
<article class="doc-entry" id="doc-shapiro-delay">
<h3><a class="doc-anchor" href="#doc-shapiro-delay">#</a> <code>shapiro_delay</code></h3>
<p><code>shapiro_delay</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = shapiro_delay $x
# or in a pipeline:
@list |> map shapiro_delay |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shapiro-delay-step">
<h3><a class="doc-anchor" href="#doc-shapiro-delay-step">#</a> <code>shapiro_delay_step</code></h3>
<p><code>shapiro_delay_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = shapiro_delay_step $x
# or in a pipeline:
@list |> map shapiro_delay_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shapiro-wilk">
<h3><a class="doc-anchor" href="#doc-shapiro-wilk">#</a> <code>shapiro_wilk</code></h3>
<p><code>shapiro_wilk</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = shapiro_wilk $x
# or in a pipeline:
@list |> map shapiro_wilk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shapley-value-two-step">
<h3><a class="doc-anchor" href="#doc-shapley-value-two-step">#</a> <code>shapley_value_two_step</code></h3>
<p><code>shapley_value_two_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = shapley_value_two_step $x
# or in a pipeline:
@list |> map shapley_value_two_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sharpe">
<h3><a class="doc-anchor" href="#doc-sharpe">#</a> <code>sharpe</code></h3>
<p><code>sharpe_ratio(\@returns, $risk_free_rate)</code> (alias <code>sharpe</code>) — computes the Sharpe ratio measuring risk-adjusted returns. Higher is better. Returns (mean_return - rf) / stddev.</p>
<pre><code class="lang-perl">my @returns = (0.05, -0.02, 0.08, 0.03)
p sharpe(\@returns, 0.02) # risk-adjusted performance
</code></pre>
</article>
<article class="doc-entry" id="doc-sharpe-annualized">
<h3><a class="doc-anchor" href="#doc-sharpe-annualized">#</a> <code>sharpe_annualized</code></h3>
<p><code>sharpe_annualized</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = sharpe_annualized $x
# or in a pipeline:
@list |> map sharpe_annualized |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sharpen-kernel">
<h3><a class="doc-anchor" href="#doc-sharpen-kernel">#</a> <code>sharpen_kernel</code></h3>
<p><code>sharpen_kernel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = sharpen_kernel $x
# or in a pipeline:
@list |> map sharpen_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shear-tensor-step">
<h3><a class="doc-anchor" href="#doc-shear-tensor-step">#</a> <code>shear_tensor_step</code></h3>
<p><code>shear_tensor_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = shear_tensor_step $x
# or in a pipeline:
@list |> map shear_tensor_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shepherd-voltage-step">
<h3><a class="doc-anchor" href="#doc-shepherd-voltage-step">#</a> <code>shepherd_voltage_step</code></h3>
<p><code>shepherd_voltage_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = shepherd_voltage_step $x
# or in a pipeline:
@list |> map shepherd_voltage_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sherwood-number-step">
<h3><a class="doc-anchor" href="#doc-sherwood-number-step">#</a> <code>sherwood_number_step</code></h3>
<p><code>sherwood_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = sherwood_number_step $x
# or in a pipeline:
@list |> map sherwood_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shi-tomasi-corners">
<h3><a class="doc-anchor" href="#doc-shi-tomasi-corners">#</a> <code>shi_tomasi_corners</code></h3>
<p><code>shi_tomasi_corners</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = shi_tomasi_corners $x
# or in a pipeline:
@list |> map shi_tomasi_corners |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shift-left">
<h3><a class="doc-anchor" href="#doc-shift-left">#</a> <code>shift_left</code></h3>
<p><code>shift_left</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = shift_left $x
# or in a pipeline:
@list |> map shift_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shift-right">
<h3><a class="doc-anchor" href="#doc-shift-right">#</a> <code>shift_right</code></h3>
<p><code>shift_right</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = shift_right $x
# or in a pipeline:
@list |> map shift_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shl">
<h3><a class="doc-anchor" href="#doc-shl">#</a> <code>shl</code></h3>
<p><code>shl</code> — bit ops builtin. Alias for <code>shift_left</code>.</p>
<pre><code class="lang-perl">my $result = shl $x
# or in a pipeline:
@list |> map shl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shmctl">
<h3><a class="doc-anchor" href="#doc-shmctl">#</a> <code>shmctl</code></h3>
<p><code>shmctl</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = shmctl $x
# or in a pipeline:
@list |> map shmctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shmget">
<h3><a class="doc-anchor" href="#doc-shmget">#</a> <code>shmget</code></h3>
<p><code>shmget</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = shmget $x
# or in a pipeline:
@list |> map shmget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shmread">
<h3><a class="doc-anchor" href="#doc-shmread">#</a> <code>shmread</code></h3>
<p><code>shmread</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = shmread $x
# or in a pipeline:
@list |> map shmread |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shmwrite">
<h3><a class="doc-anchor" href="#doc-shmwrite">#</a> <code>shmwrite</code></h3>
<p><code>shmwrite</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = shmwrite $x
# or in a pipeline:
@list |> map shmwrite |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shoelace-area">
<h3><a class="doc-anchor" href="#doc-shoelace-area">#</a> <code>shoelace_area</code></h3>
<p><code>shoelace_area</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = shoelace_area $x
# or in a pipeline:
@list |> map shoelace_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shooting-pct">
<h3><a class="doc-anchor" href="#doc-shooting-pct">#</a> <code>shooting_pct</code></h3>
<p><code>shooting_pct</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = shooting_pct $x
# or in a pipeline:
@list |> map shooting_pct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shor-period">
<h3><a class="doc-anchor" href="#doc-shor-period">#</a> <code>shor_period</code></h3>
<p><code>shor_period</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = shor_period $x
# or in a pipeline:
@list |> map shor_period |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shor-period-prob">
<h3><a class="doc-anchor" href="#doc-shor-period-prob">#</a> <code>shor_period_prob</code></h3>
<p><code>shor_period_prob</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = shor_period_prob $x
# or in a pipeline:
@list |> map shor_period_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-short-id">
<h3><a class="doc-anchor" href="#doc-short-id">#</a> <code>short_id</code></h3>
<p><code>short_id</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = short_id $x
# or in a pipeline:
@list |> map short_id |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shorten">
<h3><a class="doc-anchor" href="#doc-shorten">#</a> <code>shorten</code></h3>
<p><code>shorten</code> — trivial string ops builtin. Alias for <code>truncate_at</code>.</p>
<pre><code class="lang-perl">my $result = shorten $x
# or in a pipeline:
@list |> map shorten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shortest">
<h3><a class="doc-anchor" href="#doc-shortest">#</a> <code>shortest</code></h3>
<p><code>shortest</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = shortest $x
# or in a pipeline:
@list |> map shortest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shortest-path-bfs">
<h3><a class="doc-anchor" href="#doc-shortest-path-bfs">#</a> <code>shortest_path_bfs</code></h3>
<p><code>shortest_path_bfs</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = shortest_path_bfs $x
# or in a pipeline:
@list |> map shortest_path_bfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shr">
<h3><a class="doc-anchor" href="#doc-shr">#</a> <code>shr</code></h3>
<p><code>shr</code> — bit ops builtin. Alias for <code>shift_right</code>.</p>
<pre><code class="lang-perl">my $result = shr $x
# or in a pipeline:
@list |> map shr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shuf">
<h3><a class="doc-anchor" href="#doc-shuf">#</a> <code>shuf</code></h3>
<p><code>shuf</code> — extended stdlib builtin. Alias for <code>shuffle_arr</code>.</p>
<pre><code class="lang-perl">my $result = shuf $x
# or in a pipeline:
@list |> map shuf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shuffle-arr">
<h3><a class="doc-anchor" href="#doc-shuffle-arr">#</a> <code>shuffle_arr</code></h3>
<p><code>shuffle_arr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = shuffle_arr $x
# or in a pipeline:
@list |> map shuffle_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shuffle-chars">
<h3><a class="doc-anchor" href="#doc-shuffle-chars">#</a> <code>shuffle_chars</code></h3>
<p><code>shuffle_chars</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = shuffle_chars $x
# or in a pipeline:
@list |> map shuffle_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shuffled">
<h3><a class="doc-anchor" href="#doc-shuffled">#</a> <code>shuffled</code></h3>
<p><code>shuffled</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = shuffled $x
# or in a pipeline:
@list |> map shuffled |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shunting-yard-step">
<h3><a class="doc-anchor" href="#doc-shunting-yard-step">#</a> <code>shunting_yard_step</code></h3>
<p><code>shunting_yard_step</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = shunting_yard_step $x
# or in a pipeline:
@list |> map shunting_yard_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sidereal-day-period">
<h3><a class="doc-anchor" href="#doc-sidereal-day-period">#</a> <code>sidereal_day_period</code></h3>
<p><code>sidereal_day_period</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = sidereal_day_period $x
# or in a pipeline:
@list |> map sidereal_day_period |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-siera">
<h3><a class="doc-anchor" href="#doc-siera">#</a> <code>siera</code></h3>
<p><code>siera</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = siera $x
# or in a pipeline:
@list |> map siera |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sierp">
<h3><a class="doc-anchor" href="#doc-sierp">#</a> <code>sierp</code></h3>
<p><code>sierp</code> — algorithms / puzzles builtin. Alias for <code>sierpinski</code>.</p>
<pre><code class="lang-perl">my $result = sierp $x
# or in a pipeline:
@list |> map sierp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sierpinski">
<h3><a class="doc-anchor" href="#doc-sierpinski">#</a> <code>sierpinski</code></h3>
<p><code>sierpinski</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = sierpinski $x
# or in a pipeline:
@list |> map sierpinski |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sieve">
<h3><a class="doc-anchor" href="#doc-sieve">#</a> <code>sieve</code></h3>
<p><code>sieve</code> — number theory / primes builtin. Alias for <code>primes_up_to</code>.</p>
<pre><code class="lang-perl">my $result = sieve $x
# or in a pipeline:
@list |> map sieve |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sift-keypoints">
<h3><a class="doc-anchor" href="#doc-sift-keypoints">#</a> <code>sift_keypoints</code></h3>
<p><code>sift_keypoints</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = sift_keypoints $x
# or in a pipeline:
@list |> map sift_keypoints |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sigma8-default">
<h3><a class="doc-anchor" href="#doc-sigma8-default">#</a> <code>sigma8_default</code></h3>
<p><code>sigma8_default</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = sigma8_default $x
# or in a pipeline:
@list |> map sigma8_default |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sigma-crit">
<h3><a class="doc-anchor" href="#doc-sigma-crit">#</a> <code>sigma_crit</code></h3>
<p><code>sigma_crit</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = sigma_crit $x
# or in a pipeline:
@list |> map sigma_crit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sigma-sb">
<h3><a class="doc-anchor" href="#doc-sigma-sb">#</a> <code>sigma_sb</code></h3>
<p><code>sigma_sb</code> — physics constants builtin. Alias for <code>stefan_boltzmann_constant</code>.</p>
<pre><code class="lang-perl">my $result = sigma_sb $x
# or in a pipeline:
@list |> map sigma_sb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sigmoid">
<h3><a class="doc-anchor" href="#doc-sigmoid">#</a> <code>sigmoid</code></h3>
<p><code>sigmoid</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = sigmoid $x
# or in a pipeline:
@list |> map sigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sigmoid-grad">
<h3><a class="doc-anchor" href="#doc-sigmoid-grad">#</a> <code>sigmoid_grad</code></h3>
<p><code>sigmoid_grad</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = sigmoid_grad $x
# or in a pipeline:
@list |> map sigmoid_grad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sign">
<h3><a class="doc-anchor" href="#doc-sign">#</a> <code>sign</code></h3>
<p><code>sign</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = sign $x
# or in a pipeline:
@list |> map sign |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-signal-name">
<h3><a class="doc-anchor" href="#doc-signal-name">#</a> <code>signal_name</code></h3>
<p><code>signal_name</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = signal_name $x
# or in a pipeline:
@list |> map signal_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-signum">
<h3><a class="doc-anchor" href="#doc-signum">#</a> <code>signum</code></h3>
<p><code>signum</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = signum $x
# or in a pipeline:
@list |> map signum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-signum-of">
<h3><a class="doc-anchor" href="#doc-signum-of">#</a> <code>signum_of</code></h3>
<p><code>signum_of</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = signum_of $x
# or in a pipeline:
@list |> map signum_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-silicate-classify">
<h3><a class="doc-anchor" href="#doc-silicate-classify">#</a> <code>silicate_classify</code></h3>
<p><code>silicate_classify</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = silicate_classify $x
# or in a pipeline:
@list |> map silicate_classify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-silu">
<h3><a class="doc-anchor" href="#doc-silu">#</a> <code>silu</code></h3>
<p><code>silu</code> (alias <code>swish</code>) applies SiLU/Swish: x·sigmoid(x). Smooth approximation to ReLU.</p>
<pre><code class="lang-perl">p silu(1) # 0.7311
p swish(-2) # -0.2384
</code></pre>
</article>
<article class="doc-entry" id="doc-silver">
<h3><a class="doc-anchor" href="#doc-silver">#</a> <code>silver</code></h3>
<p><code>silver_ratio</code> (alias <code>silver</code>) — δS = 1 + √2 ≈ 2.414. Related to Pell numbers.</p>
<pre><code class="lang-perl">p silver # 2.414213562373095
</code></pre>
</article>
<article class="doc-entry" id="doc-sim">
<h3><a class="doc-anchor" href="#doc-sim">#</a> <code>sim</code></h3>
<p><code>sim</code> — extended stdlib builtin. Alias for <code>similarity</code>.</p>
<pre><code class="lang-perl">my $result = sim $x
# or in a pipeline:
@list |> map sim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-similarity">
<h3><a class="doc-anchor" href="#doc-similarity">#</a> <code>similarity</code></h3>
<p><code>similarity</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = similarity $x
# or in a pipeline:
@list |> map similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-similarity-function-phi">
<h3><a class="doc-anchor" href="#doc-similarity-function-phi">#</a> <code>similarity_function_phi</code></h3>
<p><code>similarity_function_phi</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = similarity_function_phi $x
# or in a pipeline:
@list |> map similarity_function_phi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simon-round">
<h3><a class="doc-anchor" href="#doc-simon-round">#</a> <code>simon_round</code></h3>
<p><code>simon_round</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = simon_round $x
# or in a pipeline:
@list |> map simon_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simple-interest">
<h3><a class="doc-anchor" href="#doc-simple-interest">#</a> <code>simple_interest</code></h3>
<p><code>simple_interest</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = simple_interest $x
# or in a pipeline:
@list |> map simple_interest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simple-interest-compute">
<h3><a class="doc-anchor" href="#doc-simple-interest-compute">#</a> <code>simple_interest_compute</code></h3>
<p><code>simple_interest_compute</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = simple_interest_compute $x
# or in a pipeline:
@list |> map simple_interest_compute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simplex-volume-3d">
<h3><a class="doc-anchor" href="#doc-simplex-volume-3d">#</a> <code>simplex_volume_3d</code></h3>
<p><code>simplex_volume_3d</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = simplex_volume_3d $x
# or in a pipeline:
@list |> map simplex_volume_3d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simplex-volume-n">
<h3><a class="doc-anchor" href="#doc-simplex-volume-n">#</a> <code>simplex_volume_n</code></h3>
<p><code>simplex_volume_n</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = simplex_volume_n $x
# or in a pipeline:
@list |> map simplex_volume_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simplicial-volume">
<h3><a class="doc-anchor" href="#doc-simplicial-volume">#</a> <code>simplicial_volume</code></h3>
<p><code>simplicial_volume</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = simplicial_volume $x
# or in a pipeline:
@list |> map simplicial_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simply-typed-check">
<h3><a class="doc-anchor" href="#doc-simply-typed-check">#</a> <code>simply_typed_check</code></h3>
<p><code>simply_typed_check</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = simply_typed_check $x
# or in a pipeline:
@list |> map simply_typed_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simps">
<h3><a class="doc-anchor" href="#doc-simps">#</a> <code>simps</code></h3>
<p><code>simpson</code> (alias <code>simps</code>) integrates evenly-spaced samples using Simpson's rule. More accurate than trapz for smooth functions.</p>
<pre><code class="lang-perl">my @y = map { sin(_ * 0.01) } 0:314
p simps(\@y, 0.01) # ≈ 2.0
</code></pre>
</article>
<article class="doc-entry" id="doc-simpson-rule">
<h3><a class="doc-anchor" href="#doc-simpson-rule">#</a> <code>simpson_rule</code></h3>
<p><code>simpson_rule</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = simpson_rule $x
# or in a pipeline:
@list |> map simpson_rule |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simrank">
<h3><a class="doc-anchor" href="#doc-simrank">#</a> <code>simrank</code></h3>
<p><code>simrank</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = simrank $x
# or in a pipeline:
@list |> map simrank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simulated-annealing-step">
<h3><a class="doc-anchor" href="#doc-simulated-annealing-step">#</a> <code>simulated_annealing_step</code></h3>
<p><code>simulated_annealing_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = simulated_annealing_step $x
# or in a pipeline:
@list |> map simulated_annealing_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sinc">
<h3><a class="doc-anchor" href="#doc-sinc">#</a> <code>sinc</code></h3>
<p><code>sinc</code> returns the unnormalized sinc function: sin(x)/x, with sinc(0)=1.</p>
<pre><code class="lang-perl">p sinc(0) # 1.0
p sinc(3.14159) # ≈ 0
</code></pre>
</article>
<article class="doc-entry" id="doc-sine-integral-si">
<h3><a class="doc-anchor" href="#doc-sine-integral-si">#</a> <code>sine_integral_si</code></h3>
<p><code>sine_integral_si</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = sine_integral_si $x
# or in a pipeline:
@list |> map sine_integral_si |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-single-quote">
<h3><a class="doc-anchor" href="#doc-single-quote">#</a> <code>single_quote</code></h3>
<p><code>single_quote</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = single_quote $x
# or in a pipeline:
@list |> map single_quote |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-single-slit-min">
<h3><a class="doc-anchor" href="#doc-single-slit-min">#</a> <code>single_slit_min</code></h3>
<p><code>single_slit_min</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = single_slit_min $x
# or in a pipeline:
@list |> map single_slit_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-single-transferable-vote">
<h3><a class="doc-anchor" href="#doc-single-transferable-vote">#</a> <code>single_transferable_vote</code></h3>
<p><code>single_transferable_vote</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = single_transferable_vote $x
# or in a pipeline:
@list |> map single_transferable_vote |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-singularity-check-2link">
<h3><a class="doc-anchor" href="#doc-singularity-check-2link">#</a> <code>singularity_check_2link</code></h3>
<p><code>singularity_check_2link</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = singularity_check_2link $x
# or in a pipeline:
@list |> map singularity_check_2link |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-singularize">
<h3><a class="doc-anchor" href="#doc-singularize">#</a> <code>singularize</code></h3>
<p><code>singularize</code> — batch 9 builtin. Alias for <code>singularize_simple</code>.</p>
<pre><code class="lang-perl">my $result = singularize $x
# or in a pipeline:
@list |> map singularize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-singularize-simple">
<h3><a class="doc-anchor" href="#doc-singularize-simple">#</a> <code>singularize_simple</code></h3>
<p><code>singularize_simple</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = singularize_simple $x
# or in a pipeline:
@list |> map singularize_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sinh">
<h3><a class="doc-anchor" href="#doc-sinh">#</a> <code>sinh</code></h3>
<p><code>sinh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = sinh $x
# or in a pipeline:
@list |> map sinh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sinhc">
<h3><a class="doc-anchor" href="#doc-sinhc">#</a> <code>sinhc</code></h3>
<p><code>sinhc</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = sinhc $x
# or in a pipeline:
@list |> map sinhc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sinkhorn-iteration-step">
<h3><a class="doc-anchor" href="#doc-sinkhorn-iteration-step">#</a> <code>sinkhorn_iteration_step</code></h3>
<p><code>sinkhorn_iteration_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = sinkhorn_iteration_step $x
# or in a pipeline:
@list |> map sinkhorn_iteration_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sinter">
<h3><a class="doc-anchor" href="#doc-sinter">#</a> <code>sinter</code></h3>
<p><code>sinter</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = sinter $x
# or in a pipeline:
@list |> map sinter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sinusoidal-project">
<h3><a class="doc-anchor" href="#doc-sinusoidal-project">#</a> <code>sinusoidal_project</code></h3>
<p><code>sinusoidal_project</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = sinusoidal_project $x
# or in a pipeline:
@list |> map sinusoidal_project |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-siphash24">
<h3><a class="doc-anchor" href="#doc-siphash24">#</a> <code>siphash24</code></h3>
<p><code>siphash24</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = siphash24 $x
# or in a pipeline:
@list |> map siphash24 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-siphash-keyed">
<h3><a class="doc-anchor" href="#doc-siphash-keyed">#</a> <code>siphash_keyed</code></h3>
<p><code>siphash_keyed</code> computes SipHash-2-4 with a custom 128-bit key (two 64-bit integers). The key should be random per application to prevent collision attacks.</p>
<pre><code class="lang-perl">p siphash_keyed("data", 0x123456789, 0xabcdef012) # keyed hash
</code></pre>
</article>
<article class="doc-entry" id="doc-sirs-step">
<h3><a class="doc-anchor" href="#doc-sirs-step">#</a> <code>sirs_step</code></h3>
<p><code>sirs_step</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = sirs_step $x
# or in a pipeline:
@list |> map sirs_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sis-step">
<h3><a class="doc-anchor" href="#doc-sis-step">#</a> <code>sis_step</code></h3>
<p><code>sis_step</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = sis_step $x
# or in a pipeline:
@list |> map sis_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sismember">
<h3><a class="doc-anchor" href="#doc-sismember">#</a> <code>sismember</code></h3>
<p><code>sismember</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = sismember $x
# or in a pipeline:
@list |> map sismember |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-size">
<h3><a class="doc-anchor" href="#doc-size">#</a> <code>size</code></h3>
<p><code>size</code> returns the byte size of a file on disk — equivalent to Perl's <code>-s FILE</code> file test. With no arguments, it operates on <code>_</code>; with one argument, it stats the given path; with multiple arguments (or a flattened list), it returns an array of sizes. Paths that can't be stat'd return <code>undef</code>. This is a stryke extension that makes pipelines over filenames concise.</p>
<pre><code class="lang-perl">p size "Cargo.toml" # 2013
f |> map +{ _ => size } |> tj |> p # [{name => bytes}, ...]
f |> filter { size > 1024 } |> e p # files larger than 1 KiB
</code></pre>
</article>
<article class="doc-entry" id="doc-sjson">
<h3><a class="doc-anchor" href="#doc-sjson">#</a> <code>sjson</code></h3>
<p><code>sjson</code> — stress / telemetry extensions builtin. Alias for <code>stress_json</code>.</p>
<pre><code class="lang-perl">my $result = sjson $x
# or in a pipeline:
@list |> map sjson |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-adjusted-rand">
<h3><a class="doc-anchor" href="#doc-sk-adjusted-rand">#</a> <code>sk_adjusted_rand</code></h3>
<p><code>sk_adjusted_rand</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_adjusted_rand $x
# or in a pipeline:
@list |> map sk_adjusted_rand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-agglomerative-fit">
<h3><a class="doc-anchor" href="#doc-sk-agglomerative-fit">#</a> <code>sk_agglomerative_fit</code></h3>
<p><code>sk_agglomerative_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_agglomerative_fit $x
# or in a pipeline:
@list |> map sk_agglomerative_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-bayes-search">
<h3><a class="doc-anchor" href="#doc-sk-bayes-search">#</a> <code>sk_bayes_search</code></h3>
<p><code>sk_bayes_search</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_bayes_search $x
# or in a pipeline:
@list |> map sk_bayes_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-calinski-harabasz">
<h3><a class="doc-anchor" href="#doc-sk-calinski-harabasz">#</a> <code>sk_calinski_harabasz</code></h3>
<p><code>sk_calinski_harabasz</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_calinski_harabasz $x
# or in a pipeline:
@list |> map sk_calinski_harabasz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-count-vectorize">
<h3><a class="doc-anchor" href="#doc-sk-count-vectorize">#</a> <code>sk_count_vectorize</code></h3>
<p><code>sk_count_vectorize</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_count_vectorize $x
# or in a pipeline:
@list |> map sk_count_vectorize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-cross-val-score">
<h3><a class="doc-anchor" href="#doc-sk-cross-val-score">#</a> <code>sk_cross_val_score</code></h3>
<p><code>sk_cross_val_score</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_cross_val_score $x
# or in a pipeline:
@list |> map sk_cross_val_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-davies-bouldin">
<h3><a class="doc-anchor" href="#doc-sk-davies-bouldin">#</a> <code>sk_davies_bouldin</code></h3>
<p><code>sk_davies_bouldin</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_davies_bouldin $x
# or in a pipeline:
@list |> map sk_davies_bouldin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-dbscan-fit">
<h3><a class="doc-anchor" href="#doc-sk-dbscan-fit">#</a> <code>sk_dbscan_fit</code></h3>
<p><code>sk_dbscan_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_dbscan_fit $x
# or in a pipeline:
@list |> map sk_dbscan_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-decision-tree-split">
<h3><a class="doc-anchor" href="#doc-sk-decision-tree-split">#</a> <code>sk_decision_tree_split</code></h3>
<p><code>sk_decision_tree_split</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_decision_tree_split $x
# or in a pipeline:
@list |> map sk_decision_tree_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-doc2vec-train">
<h3><a class="doc-anchor" href="#doc-sk-doc2vec-train">#</a> <code>sk_doc2vec_train</code></h3>
<p><code>sk_doc2vec_train</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_doc2vec_train $x
# or in a pipeline:
@list |> map sk_doc2vec_train |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-gbt-fit">
<h3><a class="doc-anchor" href="#doc-sk-gbt-fit">#</a> <code>sk_gbt_fit</code></h3>
<p><code>sk_gbt_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_gbt_fit $x
# or in a pipeline:
@list |> map sk_gbt_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-grid-search">
<h3><a class="doc-anchor" href="#doc-sk-grid-search">#</a> <code>sk_grid_search</code></h3>
<p><code>sk_grid_search</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_grid_search $x
# or in a pipeline:
@list |> map sk_grid_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-isolation-forest-fit">
<h3><a class="doc-anchor" href="#doc-sk-isolation-forest-fit">#</a> <code>sk_isolation_forest_fit</code></h3>
<p><code>sk_isolation_forest_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_isolation_forest_fit $x
# or in a pipeline:
@list |> map sk_isolation_forest_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-kfold-split">
<h3><a class="doc-anchor" href="#doc-sk-kfold-split">#</a> <code>sk_kfold_split</code></h3>
<p><code>sk_kfold_split</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_kfold_split $x
# or in a pipeline:
@list |> map sk_kfold_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-kmeans-fit">
<h3><a class="doc-anchor" href="#doc-sk-kmeans-fit">#</a> <code>sk_kmeans_fit</code></h3>
<p><code>sk_kmeans_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_kmeans_fit $x
# or in a pipeline:
@list |> map sk_kmeans_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-knn-predict">
<h3><a class="doc-anchor" href="#doc-sk-knn-predict">#</a> <code>sk_knn_predict</code></h3>
<p><code>sk_knn_predict</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_knn_predict $x
# or in a pipeline:
@list |> map sk_knn_predict |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-label-encode">
<h3><a class="doc-anchor" href="#doc-sk-label-encode">#</a> <code>sk_label_encode</code></h3>
<p><code>sk_label_encode</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_label_encode $x
# or in a pipeline:
@list |> map sk_label_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-lda-topic">
<h3><a class="doc-anchor" href="#doc-sk-lda-topic">#</a> <code>sk_lda_topic</code></h3>
<p><code>sk_lda_topic</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_lda_topic $x
# or in a pipeline:
@list |> map sk_lda_topic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-lightgbm-fit">
<h3><a class="doc-anchor" href="#doc-sk-lightgbm-fit">#</a> <code>sk_lightgbm_fit</code></h3>
<p><code>sk_lightgbm_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_lightgbm_fit $x
# or in a pipeline:
@list |> map sk_lightgbm_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-lof-fit">
<h3><a class="doc-anchor" href="#doc-sk-lof-fit">#</a> <code>sk_lof_fit</code></h3>
<p><code>sk_lof_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_lof_fit $x
# or in a pipeline:
@list |> map sk_lof_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-logistic-fit">
<h3><a class="doc-anchor" href="#doc-sk-logistic-fit">#</a> <code>sk_logistic_fit</code></h3>
<p><code>sk_logistic_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_logistic_fit $x
# or in a pipeline:
@list |> map sk_logistic_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-logistic-predict">
<h3><a class="doc-anchor" href="#doc-sk-logistic-predict">#</a> <code>sk_logistic_predict</code></h3>
<p><code>sk_logistic_predict</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_logistic_predict $x
# or in a pipeline:
@list |> map sk_logistic_predict |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-min-max-scaler">
<h3><a class="doc-anchor" href="#doc-sk-min-max-scaler">#</a> <code>sk_min_max_scaler</code></h3>
<p><code>sk_min_max_scaler</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_min_max_scaler $x
# or in a pipeline:
@list |> map sk_min_max_scaler |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-mutual-info">
<h3><a class="doc-anchor" href="#doc-sk-mutual-info">#</a> <code>sk_mutual_info</code></h3>
<p><code>sk_mutual_info</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_mutual_info $x
# or in a pipeline:
@list |> map sk_mutual_info |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-naive-bayes-predict">
<h3><a class="doc-anchor" href="#doc-sk-naive-bayes-predict">#</a> <code>sk_naive_bayes_predict</code></h3>
<p><code>sk_naive_bayes_predict</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_naive_bayes_predict $x
# or in a pipeline:
@list |> map sk_naive_bayes_predict |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-nmf-topic">
<h3><a class="doc-anchor" href="#doc-sk-nmf-topic">#</a> <code>sk_nmf_topic</code></h3>
<p><code>sk_nmf_topic</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_nmf_topic $x
# or in a pipeline:
@list |> map sk_nmf_topic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-one-hot">
<h3><a class="doc-anchor" href="#doc-sk-one-hot">#</a> <code>sk_one_hot</code></h3>
<p><code>sk_one_hot</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_one_hot $x
# or in a pipeline:
@list |> map sk_one_hot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-ordinal-encode">
<h3><a class="doc-anchor" href="#doc-sk-ordinal-encode">#</a> <code>sk_ordinal_encode</code></h3>
<p><code>sk_ordinal_encode</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_ordinal_encode $x
# or in a pipeline:
@list |> map sk_ordinal_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-pca-fit">
<h3><a class="doc-anchor" href="#doc-sk-pca-fit">#</a> <code>sk_pca_fit</code></h3>
<p><code>sk_pca_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_pca_fit $x
# or in a pipeline:
@list |> map sk_pca_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-pipeline-fit">
<h3><a class="doc-anchor" href="#doc-sk-pipeline-fit">#</a> <code>sk_pipeline_fit</code></h3>
<p><code>sk_pipeline_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_pipeline_fit $x
# or in a pipeline:
@list |> map sk_pipeline_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-power-transform">
<h3><a class="doc-anchor" href="#doc-sk-power-transform">#</a> <code>sk_power_transform</code></h3>
<p><code>sk_power_transform</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_power_transform $x
# or in a pipeline:
@list |> map sk_power_transform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-quantile-transform">
<h3><a class="doc-anchor" href="#doc-sk-quantile-transform">#</a> <code>sk_quantile_transform</code></h3>
<p><code>sk_quantile_transform</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_quantile_transform $x
# or in a pipeline:
@list |> map sk_quantile_transform |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-random-forest-fit">
<h3><a class="doc-anchor" href="#doc-sk-random-forest-fit">#</a> <code>sk_random_forest_fit</code></h3>
<p><code>sk_random_forest_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_random_forest_fit $x
# or in a pipeline:
@list |> map sk_random_forest_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-random-search">
<h3><a class="doc-anchor" href="#doc-sk-random-search">#</a> <code>sk_random_search</code></h3>
<p><code>sk_random_search</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_random_search $x
# or in a pipeline:
@list |> map sk_random_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-robust-scaler">
<h3><a class="doc-anchor" href="#doc-sk-robust-scaler">#</a> <code>sk_robust_scaler</code></h3>
<p><code>sk_robust_scaler</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_robust_scaler $x
# or in a pipeline:
@list |> map sk_robust_scaler |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-silhouette">
<h3><a class="doc-anchor" href="#doc-sk-silhouette">#</a> <code>sk_silhouette</code></h3>
<p><code>sk_silhouette</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_silhouette $x
# or in a pipeline:
@list |> map sk_silhouette |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-standard-scaler">
<h3><a class="doc-anchor" href="#doc-sk-standard-scaler">#</a> <code>sk_standard_scaler</code></h3>
<p><code>sk_standard_scaler</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_standard_scaler $x
# or in a pipeline:
@list |> map sk_standard_scaler |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-stratified-kfold">
<h3><a class="doc-anchor" href="#doc-sk-stratified-kfold">#</a> <code>sk_stratified_kfold</code></h3>
<p><code>sk_stratified_kfold</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_stratified_kfold $x
# or in a pipeline:
@list |> map sk_stratified_kfold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-svm-fit">
<h3><a class="doc-anchor" href="#doc-sk-svm-fit">#</a> <code>sk_svm_fit</code></h3>
<p><code>sk_svm_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_svm_fit $x
# or in a pipeline:
@list |> map sk_svm_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-tfidf">
<h3><a class="doc-anchor" href="#doc-sk-tfidf">#</a> <code>sk_tfidf</code></h3>
<p><code>sk_tfidf</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_tfidf $x
# or in a pipeline:
@list |> map sk_tfidf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-tsne-fit">
<h3><a class="doc-anchor" href="#doc-sk-tsne-fit">#</a> <code>sk_tsne_fit</code></h3>
<p><code>sk_tsne_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_tsne_fit $x
# or in a pipeline:
@list |> map sk_tsne_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-umap-fit">
<h3><a class="doc-anchor" href="#doc-sk-umap-fit">#</a> <code>sk_umap_fit</code></h3>
<p><code>sk_umap_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_umap_fit $x
# or in a pipeline:
@list |> map sk_umap_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-word2vec-train">
<h3><a class="doc-anchor" href="#doc-sk-word2vec-train">#</a> <code>sk_word2vec_train</code></h3>
<p><code>sk_word2vec_train</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_word2vec_train $x
# or in a pipeline:
@list |> map sk_word2vec_train |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sk-xgb-fit">
<h3><a class="doc-anchor" href="#doc-sk-xgb-fit">#</a> <code>sk_xgb_fit</code></h3>
<p><code>sk_xgb_fit</code> — batch 79 builtin.</p>
<pre><code class="lang-perl">my $result = sk_xgb_fit $x
# or in a pipeline:
@list |> map sk_xgb_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skew">
<h3><a class="doc-anchor" href="#doc-skew">#</a> <code>skew</code></h3>
<p><code>skew</code> — math / numeric (uncategorized batch) builtin. Alias for <code>skewness</code>.</p>
<pre><code class="lang-perl">my $result = skew $x
# or in a pipeline:
@list |> map skew |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skewness">
<h3><a class="doc-anchor" href="#doc-skewness">#</a> <code>skewness</code></h3>
<p><code>skewness</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = skewness $x
# or in a pipeline:
@list |> map skewness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skill-score">
<h3><a class="doc-anchor" href="#doc-skill-score">#</a> <code>skill_score</code></h3>
<p><code>skill_score</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = skill_score $x
# or in a pipeline:
@list |> map skill_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skin-depth">
<h3><a class="doc-anchor" href="#doc-skin-depth">#</a> <code>skin_depth</code></h3>
<p><code>skin_depth</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = skin_depth $x
# or in a pipeline:
@list |> map skin_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skip-assert">
<h3><a class="doc-anchor" href="#doc-skip-assert">#</a> <code>skip_assert</code></h3>
<p><code>skip_assert</code> — testing framework builtin. Alias for <code>test_skip</code>.</p>
<pre><code class="lang-perl">my $result = skip_assert $x
# or in a pipeline:
@list |> map skip_assert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skip-test">
<h3><a class="doc-anchor" href="#doc-skip-test">#</a> <code>skip_test</code></h3>
<p><code>skip_test</code> — testing framework builtin. Alias for <code>test_skip</code>.</p>
<pre><code class="lang-perl">my $result = skip_test $x
# or in a pipeline:
@list |> map skip_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skip-while">
<h3><a class="doc-anchor" href="#doc-skip-while">#</a> <code>skip_while</code></h3>
<p><code>skip_while { COND } LIST</code> — skip leading elements while the predicate is true (alias for <code>drop_while</code>).</p>
<p>Behavior is identical to <code>drop_while</code>: once the predicate returns false, that element and all subsequent elements are emitted. The <code>skip_while</code> name is provided for users coming from Rust or Kotlin where this is the conventional name. Both compile to the same streaming operation internally.</p>
<pre><code class="lang-perl">1:10 |> skip_while { _ < 5 } |> e p # 5 6 7 8 9 10
@sorted |> skip_while { _ le "m" } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-sla">
<h3><a class="doc-anchor" href="#doc-sla">#</a> <code>sla</code></h3>
<p><code>sla</code> — python/ruby stdlib builtin. Alias for <code>slice_arr</code>.</p>
<pre><code class="lang-perl">my $result = sla $x
# or in a pipeline:
@list |> map sla |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slca">
<h3><a class="doc-anchor" href="#doc-slca">#</a> <code>slca</code></h3>
<p><code>slca</code> — additional missing stdlib functions builtin. Alias for <code>slice_after</code>.</p>
<pre><code class="lang-perl">my $result = slca $x
# or in a pipeline:
@list |> map slca |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slcb">
<h3><a class="doc-anchor" href="#doc-slcb">#</a> <code>slcb</code></h3>
<p><code>slcb</code> — additional missing stdlib functions builtin. Alias for <code>slice_before</code>.</p>
<pre><code class="lang-perl">my $result = slcb $x
# or in a pipeline:
@list |> map slcb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slcw">
<h3><a class="doc-anchor" href="#doc-slcw">#</a> <code>slcw</code></h3>
<p><code>slcw</code> — additional missing stdlib functions builtin. Alias for <code>slice_when</code>.</p>
<pre><code class="lang-perl">my $result = slcw $x
# or in a pipeline:
@list |> map slcw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slic-superpixels">
<h3><a class="doc-anchor" href="#doc-slic-superpixels">#</a> <code>slic_superpixels</code></h3>
<p><code>slic_superpixels</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = slic_superpixels $x
# or in a pipeline:
@list |> map slic_superpixels |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slice-after">
<h3><a class="doc-anchor" href="#doc-slice-after">#</a> <code>slice_after</code></h3>
<p><code>slice_after</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = slice_after $x
# or in a pipeline:
@list |> map slice_after |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slice-arr">
<h3><a class="doc-anchor" href="#doc-slice-arr">#</a> <code>slice_arr</code></h3>
<p><code>slice_arr</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = slice_arr $x
# or in a pipeline:
@list |> map slice_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slice-before">
<h3><a class="doc-anchor" href="#doc-slice-before">#</a> <code>slice_before</code></h3>
<p><code>slice_before</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = slice_before $x
# or in a pipeline:
@list |> map slice_before |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slice-when">
<h3><a class="doc-anchor" href="#doc-slice-when">#</a> <code>slice_when</code></h3>
<p><code>slice_when</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = slice_when $x
# or in a pipeline:
@list |> map slice_when |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sliced-wasserstein">
<h3><a class="doc-anchor" href="#doc-sliced-wasserstein">#</a> <code>sliced_wasserstein</code></h3>
<p><code>sliced_wasserstein</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = sliced_wasserstein $x
# or in a pipeline:
@list |> map sliced_wasserstein |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sliding-pairs">
<h3><a class="doc-anchor" href="#doc-sliding-pairs">#</a> <code>sliding_pairs</code></h3>
<p><code>sliding_pairs</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = sliding_pairs $x
# or in a pipeline:
@list |> map sliding_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sliding-window">
<h3><a class="doc-anchor" href="#doc-sliding-window">#</a> <code>sliding_window</code></h3>
<p><code>sliding_window</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = sliding_window $x
# or in a pipeline:
@list |> map sliding_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slope">
<h3><a class="doc-anchor" href="#doc-slope">#</a> <code>slope</code></h3>
<p><code>slope</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = slope $x
# or in a pipeline:
@list |> map slope |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slug">
<h3><a class="doc-anchor" href="#doc-slug">#</a> <code>slug</code></h3>
<p><code>slug</code> — extended stdlib builtin. Alias for <code>slugify</code>.</p>
<pre><code class="lang-perl">my $result = slug $x
# or in a pipeline:
@list |> map slug |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slugify">
<h3><a class="doc-anchor" href="#doc-slugify">#</a> <code>slugify</code></h3>
<p><code>slugify</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = slugify $x
# or in a pipeline:
@list |> map slugify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slutsky-decompose">
<h3><a class="doc-anchor" href="#doc-slutsky-decompose">#</a> <code>slutsky_decompose</code></h3>
<p><code>slutsky_decompose</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = slutsky_decompose $x
# or in a pipeline:
@list |> map slutsky_decompose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smap">
<h3><a class="doc-anchor" href="#doc-smap">#</a> <code>smap</code></h3>
<p><code>smap</code> — python/ruby stdlib builtin. Alias for <code>starmap</code>.</p>
<pre><code class="lang-perl">my $result = smap $x
# or in a pipeline:
@list |> map smap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smembers">
<h3><a class="doc-anchor" href="#doc-smembers">#</a> <code>smembers</code></h3>
<p><code>smembers</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = smembers $x
# or in a pipeline:
@list |> map smembers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smith-normal-2x2-step">
<h3><a class="doc-anchor" href="#doc-smith-normal-2x2-step">#</a> <code>smith_normal_2x2_step</code></h3>
<p><code>smith_normal_2x2_step</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = smith_normal_2x2_step $x
# or in a pipeline:
@list |> map smith_normal_2x2_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smith-predictor-step">
<h3><a class="doc-anchor" href="#doc-smith-predictor-step">#</a> <code>smith_predictor_step</code></h3>
<p><code>smith_predictor_step</code> — batch 59 builtin.</p>
<pre><code class="lang-perl">my $result = smith_predictor_step $x
# or in a pipeline:
@list |> map smith_predictor_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smith-q">
<h3><a class="doc-anchor" href="#doc-smith-q">#</a> <code>smith_q</code></h3>
<p><code>smith_q</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = smith_q $x
# or in a pipeline:
@list |> map smith_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smith-waterman-score">
<h3><a class="doc-anchor" href="#doc-smith-waterman-score">#</a> <code>smith_waterman_score</code></h3>
<p><code>smith_waterman_score</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = smith_waterman_score $x
# or in a pipeline:
@list |> map smith_waterman_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smmap">
<h3><a class="doc-anchor" href="#doc-smmap">#</a> <code>smmap</code></h3>
<p><code>smmap</code> — stress / telemetry extensions builtin. Alias for <code>stress_mmap</code>.</p>
<pre><code class="lang-perl">my $result = smmap $x
# or in a pipeline:
@list |> map smmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smoothstep">
<h3><a class="doc-anchor" href="#doc-smoothstep">#</a> <code>smoothstep</code></h3>
<p><code>smoothstep($edge0, $edge1, $x)</code> — smooth Hermite interpolation. Returns 0 if x ≤ edge0, 1 if x ≥ edge1, otherwise smooth S-curve. Great for animations.</p>
<pre><code class="lang-perl">p smoothstep(0, 1, 0.5) # 0.5 (but with smooth acceleration/deceleration)
p smoothstep(10, 20, 15) # 0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-smst">
<h3><a class="doc-anchor" href="#doc-smst">#</a> <code>smst</code></h3>
<p><code>smst</code> — extended stdlib builtin. Alias for <code>smoothstep</code>.</p>
<pre><code class="lang-perl">my $result = smst $x
# or in a pipeline:
@list |> map smst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smt-qf-lia-solve-step">
<h3><a class="doc-anchor" href="#doc-smt-qf-lia-solve-step">#</a> <code>smt_qf_lia_solve_step</code></h3>
<p><code>smt_qf_lia_solve_step</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = smt_qf_lia_solve_step $x
# or in a pipeline:
@list |> map smt_qf_lia_solve_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smt-qf-uf-combine">
<h3><a class="doc-anchor" href="#doc-smt-qf-uf-combine">#</a> <code>smt_qf_uf_combine</code></h3>
<p><code>smt_qf_uf_combine</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = smt_qf_uf_combine $x
# or in a pipeline:
@list |> map smt_qf_uf_combine |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-snake-to-camel">
<h3><a class="doc-anchor" href="#doc-snake-to-camel">#</a> <code>snake_to_camel</code></h3>
<p><code>snake_to_camel</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = snake_to_camel $input
</code></pre>
</article>
<article class="doc-entry" id="doc-snappy-encode">
<h3><a class="doc-anchor" href="#doc-snappy-encode">#</a> <code>snappy_encode</code></h3>
<p><code>snappy_encode</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = snappy_encode $x
# or in a pipeline:
@list |> map snappy_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-snd">
<h3><a class="doc-anchor" href="#doc-snd">#</a> <code>snd</code></h3>
<p><code>snd</code> — algebraic match builtin. Alias for <code>second</code>.</p>
<pre><code class="lang-perl">my $result = snd $x
# or in a pipeline:
@list |> map snd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-snell">
<h3><a class="doc-anchor" href="#doc-snell">#</a> <code>snell</code></h3>
<p><code>snells_law($n1, $n2, $theta1)</code> (alias <code>snell</code>) — refraction angle using Snell's law. Angles in degrees. Returns undef for total internal reflection.</p>
<pre><code class="lang-perl">p snell(1, 1.5, 30) # ~19.5° (air to glass)
p snell(1.5, 1, 45) # undef (total internal reflection)
</code></pre>
</article>
<article class="doc-entry" id="doc-snell-theta2">
<h3><a class="doc-anchor" href="#doc-snell-theta2">#</a> <code>snell_theta2</code></h3>
<p><code>snell_theta2</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = snell_theta2 $x
# or in a pipeline:
@list |> map snell_theta2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-snowball-stem-english">
<h3><a class="doc-anchor" href="#doc-snowball-stem-english">#</a> <code>snowball_stem_english</code></h3>
<p><code>snowball_stem_english</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = snowball_stem_english $x
# or in a pipeline:
@list |> map snowball_stem_english |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-snowball-stem-french">
<h3><a class="doc-anchor" href="#doc-snowball-stem-french">#</a> <code>snowball_stem_french</code></h3>
<p><code>snowball_stem_french</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = snowball_stem_french $x
# or in a pipeline:
@list |> map snowball_stem_french |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sobel-diagonal-kernel">
<h3><a class="doc-anchor" href="#doc-sobel-diagonal-kernel">#</a> <code>sobel_diagonal_kernel</code></h3>
<p><code>sobel_diagonal_kernel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = sobel_diagonal_kernel $x
# or in a pipeline:
@list |> map sobel_diagonal_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sobel-kernel-value">
<h3><a class="doc-anchor" href="#doc-sobel-kernel-value">#</a> <code>sobel_kernel_value</code></h3>
<p><code>sobel_kernel_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = sobel_kernel_value $x
# or in a pipeline:
@list |> map sobel_kernel_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-soc-estimate-coulomb">
<h3><a class="doc-anchor" href="#doc-soc-estimate-coulomb">#</a> <code>soc_estimate_coulomb</code></h3>
<p><code>soc_estimate_coulomb</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = soc_estimate_coulomb $x
# or in a pipeline:
@list |> map soc_estimate_coulomb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-social-welfare-nash">
<h3><a class="doc-anchor" href="#doc-social-welfare-nash">#</a> <code>social_welfare_nash</code></h3>
<p><code>social_welfare_nash</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = social_welfare_nash $x
# or in a pipeline:
@list |> map social_welfare_nash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-social-welfare-rawls">
<h3><a class="doc-anchor" href="#doc-social-welfare-rawls">#</a> <code>social_welfare_rawls</code></h3>
<p><code>social_welfare_rawls</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = social_welfare_rawls $x
# or in a pipeline:
@list |> map social_welfare_rawls |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-social-welfare-sum">
<h3><a class="doc-anchor" href="#doc-social-welfare-sum">#</a> <code>social_welfare_sum</code></h3>
<p><code>social_welfare_sum</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = social_welfare_sum $x
# or in a pipeline:
@list |> map social_welfare_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-social-welfare-utilitarian">
<h3><a class="doc-anchor" href="#doc-social-welfare-utilitarian">#</a> <code>social_welfare_utilitarian</code></h3>
<p><code>social_welfare_utilitarian</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = social_welfare_utilitarian $x
# or in a pipeline:
@list |> map social_welfare_utilitarian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-socketpair">
<h3><a class="doc-anchor" href="#doc-socketpair">#</a> <code>socketpair</code></h3>
<p><code>socketpair</code> — socket builtin.</p>
<pre><code class="lang-perl">my $result = socketpair $x
# or in a pipeline:
@list |> map socketpair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sockets">
<h3><a class="doc-anchor" href="#doc-sockets">#</a> <code>sockets</code></h3>
<p><code>sockets</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = sockets $x
# or in a pipeline:
@list |> map sockets |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sod">
<h3><a class="doc-anchor" href="#doc-sod">#</a> <code>sod</code></h3>
<p><code>sod</code> — extended stdlib builtin. Alias for <code>start_of_day</code>.</p>
<pre><code class="lang-perl">my $result = sod $x
# or in a pipeline:
@list |> map sod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-softmax">
<h3><a class="doc-anchor" href="#doc-softmax">#</a> <code>softmax</code></h3>
<p><code>softmax</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = softmax $x
# or in a pipeline:
@list |> map softmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-softplus">
<h3><a class="doc-anchor" href="#doc-softplus">#</a> <code>softplus</code></h3>
<p><code>softplus</code> applies the Softplus activation: ln(1 + e^x). Smooth approximation to ReLU.</p>
<pre><code class="lang-perl">p softplus(0) # 0.6931 (ln 2)
p softplus(10) # ≈ 10
</code></pre>
</article>
<article class="doc-entry" id="doc-softsign">
<h3><a class="doc-anchor" href="#doc-softsign">#</a> <code>softsign</code></h3>
<p><code>softsign</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = softsign $x
# or in a pipeline:
@list |> map softsign |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-soh">
<h3><a class="doc-anchor" href="#doc-soh">#</a> <code>soh</code></h3>
<p><code>soh</code> — extended stdlib builtin. Alias for <code>start_of_hour</code>.</p>
<pre><code class="lang-perl">my $result = soh $x
# or in a pipeline:
@list |> map soh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-soh-capacity-fade">
<h3><a class="doc-anchor" href="#doc-soh-capacity-fade">#</a> <code>soh_capacity_fade</code></h3>
<p><code>soh_capacity_fade</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = soh_capacity_fade $x
# or in a pipeline:
@list |> map soh_capacity_fade |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-soi-oscillation-index">
<h3><a class="doc-anchor" href="#doc-soi-oscillation-index">#</a> <code>soi_oscillation_index</code></h3>
<p><code>soi_oscillation_index</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = soi_oscillation_index $x
# or in a pipeline:
@list |> map soi_oscillation_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sol">
<h3><a class="doc-anchor" href="#doc-sol">#</a> <code>sol</code></h3>
<p><code>sol</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = sol $x
# or in a pipeline:
@list |> map sol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solar-constant">
<h3><a class="doc-anchor" href="#doc-solar-constant">#</a> <code>solar_constant</code></h3>
<p><code>solar_constant</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = solar_constant $x
# or in a pipeline:
@list |> map solar_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solar-constant-at-distance">
<h3><a class="doc-anchor" href="#doc-solar-constant-at-distance">#</a> <code>solar_constant_at_distance</code></h3>
<p><code>solar_constant_at_distance</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = solar_constant_at_distance $x
# or in a pipeline:
@list |> map solar_constant_at_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solar-cycle-phase">
<h3><a class="doc-anchor" href="#doc-solar-cycle-phase">#</a> <code>solar_cycle_phase</code></h3>
<p><code>solar_cycle_phase</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = solar_cycle_phase $x
# or in a pipeline:
@list |> map solar_cycle_phase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solar-declination">
<h3><a class="doc-anchor" href="#doc-solar-declination">#</a> <code>solar_declination</code></h3>
<p><code>solar_declination</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = solar_declination $x
# or in a pipeline:
@list |> map solar_declination |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solar-luminosity-to-w">
<h3><a class="doc-anchor" href="#doc-solar-luminosity-to-w">#</a> <code>solar_luminosity_to_w</code></h3>
<p><code>solar_luminosity_to_w</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = solar_luminosity_to_w $input
</code></pre>
</article>
<article class="doc-entry" id="doc-solar-mass-to-kg">
<h3><a class="doc-anchor" href="#doc-solar-mass-to-kg">#</a> <code>solar_mass_to_kg</code></h3>
<p><code>solar_mass_to_kg</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = solar_mass_to_kg $input
</code></pre>
</article>
<article class="doc-entry" id="doc-solar-zenith-angle">
<h3><a class="doc-anchor" href="#doc-solar-zenith-angle">#</a> <code>solar_zenith_angle</code></h3>
<p><code>solar_zenith_angle</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = solar_zenith_angle $x
# or in a pipeline:
@list |> map solar_zenith_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sole">
<h3><a class="doc-anchor" href="#doc-sole">#</a> <code>sole</code></h3>
<p><code>sole</code> — ruby enumerable extras builtin.</p>
<pre><code class="lang-perl">my $result = sole $x
# or in a pipeline:
@list |> map sole |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solid-electrolyte-capacity">
<h3><a class="doc-anchor" href="#doc-solid-electrolyte-capacity">#</a> <code>solid_electrolyte_capacity</code></h3>
<p><code>solid_electrolyte_capacity</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = solid_electrolyte_capacity $x
# or in a pipeline:
@list |> map solid_electrolyte_capacity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solstice-winter">
<h3><a class="doc-anchor" href="#doc-solstice-winter">#</a> <code>solstice_winter</code></h3>
<p><code>solstice_winter</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = solstice_winter $x
# or in a pipeline:
@list |> map solstice_winter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solution-resistance-estimate">
<h3><a class="doc-anchor" href="#doc-solution-resistance-estimate">#</a> <code>solution_resistance_estimate</code></h3>
<p><code>solution_resistance_estimate</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = solution_resistance_estimate $x
# or in a pipeline:
@list |> map solution_resistance_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solvable-length-upper">
<h3><a class="doc-anchor" href="#doc-solvable-length-upper">#</a> <code>solvable_length_upper</code></h3>
<p><code>solvable_length_upper</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = solvable_length_upper $x
# or in a pipeline:
@list |> map solvable_length_upper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-solve-ivp-step">
<h3><a class="doc-anchor" href="#doc-solve-ivp-step">#</a> <code>solve_ivp_step</code></h3>
<p><code>solve_ivp_step</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = solve_ivp_step $x
# or in a pipeline:
@list |> map solve_ivp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-som">
<h3><a class="doc-anchor" href="#doc-som">#</a> <code>som</code></h3>
<p><code>som</code> — extended stdlib builtin. Alias for <code>start_of_minute</code>.</p>
<pre><code class="lang-perl">my $result = som $x
# or in a pipeline:
@list |> map som |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-some">
<h3><a class="doc-anchor" href="#doc-some">#</a> <code>some</code></h3>
<p><code>some</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = some $x
# or in a pipeline:
@list |> map some |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorensen-dice">
<h3><a class="doc-anchor" href="#doc-sorensen-dice">#</a> <code>sorensen_dice</code></h3>
<p><code>sorensen_dice</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = sorensen_dice $x
# or in a pipeline:
@list |> map sorensen_dice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sort-by">
<h3><a class="doc-anchor" href="#doc-sort-by">#</a> <code>sort_by</code></h3>
<p><code>sort_by</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = sort_by $x
# or in a pipeline:
@list |> map sort_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sort-on">
<h3><a class="doc-anchor" href="#doc-sort-on">#</a> <code>sort_on</code></h3>
<p><code>sort_on</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = sort_on $x
# or in a pipeline:
@list |> map sort_on |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sort-words">
<h3><a class="doc-anchor" href="#doc-sort-words">#</a> <code>sort_words</code></h3>
<p><code>sort_words</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = sort_words $x
# or in a pipeline:
@list |> map sort_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorted">
<h3><a class="doc-anchor" href="#doc-sorted">#</a> <code>sorted</code></h3>
<p><code>sorted</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = sorted $x
# or in a pipeline:
@list |> map sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorted-by-length">
<h3><a class="doc-anchor" href="#doc-sorted-by-length">#</a> <code>sorted_by_length</code></h3>
<p><code>sorted_by_length</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = sorted_by_length $x
# or in a pipeline:
@list |> map sorted_by_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorted-desc">
<h3><a class="doc-anchor" href="#doc-sorted-desc">#</a> <code>sorted_desc</code></h3>
<p><code>sorted_desc</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = sorted_desc $x
# or in a pipeline:
@list |> map sorted_desc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorted-nums">
<h3><a class="doc-anchor" href="#doc-sorted-nums">#</a> <code>sorted_nums</code></h3>
<p><code>sorted_nums</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = sorted_nums $x
# or in a pipeline:
@list |> map sorted_nums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sortino">
<h3><a class="doc-anchor" href="#doc-sortino">#</a> <code>sortino</code></h3>
<p><code>sortino_ratio(\@returns, $target)</code> (alias <code>sortino</code>) — computes the Sortino ratio, similar to Sharpe but only penalizes downside volatility. Better for asymmetric return distributions.</p>
<pre><code class="lang-perl">my @returns = (0.05, -0.02, 0.08, -0.01)
p sortino(\@returns, 0.0) # penalizes only negative returns
</code></pre>
</article>
<article class="doc-entry" id="doc-sortw">
<h3><a class="doc-anchor" href="#doc-sortw">#</a> <code>sortw</code></h3>
<p><code>sortw</code> — string processing (uncategorized batch) builtin. Alias for <code>sort_words</code>.</p>
<pre><code class="lang-perl">my $result = sortw $x
# or in a pipeline:
@list |> map sortw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sos2tf-step">
<h3><a class="doc-anchor" href="#doc-sos2tf-step">#</a> <code>sos2tf_step</code></h3>
<p><code>sos2tf_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = sos2tf_step $x
# or in a pipeline:
@list |> map sos2tf_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sos-constraint-check">
<h3><a class="doc-anchor" href="#doc-sos-constraint-check">#</a> <code>sos_constraint_check</code></h3>
<p><code>sos_constraint_check</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = sos_constraint_check $x
# or in a pipeline:
@list |> map sos_constraint_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sosfilt-step">
<h3><a class="doc-anchor" href="#doc-sosfilt-step">#</a> <code>sosfilt_step</code></h3>
<p><code>sosfilt_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = sosfilt_step $x
# or in a pipeline:
@list |> map sosfilt_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sound-db">
<h3><a class="doc-anchor" href="#doc-sound-db">#</a> <code>sound_db</code></h3>
<p><code>sound_db</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = sound_db $x
# or in a pipeline:
@list |> map sound_db |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sound-gas">
<h3><a class="doc-anchor" href="#doc-sound-gas">#</a> <code>sound_gas</code></h3>
<p><code>sound_gas</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = sound_gas $x
# or in a pipeline:
@list |> map sound_gas |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sound-horizon-recomb">
<h3><a class="doc-anchor" href="#doc-sound-horizon-recomb">#</a> <code>sound_horizon_recomb</code></h3>
<p><code>sound_horizon_recomb</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = sound_horizon_recomb $x
# or in a pipeline:
@list |> map sound_horizon_recomb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sound-solid">
<h3><a class="doc-anchor" href="#doc-sound-solid">#</a> <code>sound_solid</code></h3>
<p><code>sound_solid</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = sound_solid $x
# or in a pipeline:
@list |> map sound_solid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-soundex">
<h3><a class="doc-anchor" href="#doc-soundex">#</a> <code>soundex</code></h3>
<p><code>soundex</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = soundex $x
# or in a pipeline:
@list |> map soundex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-soundex-phonetic">
<h3><a class="doc-anchor" href="#doc-soundex-phonetic">#</a> <code>soundex_phonetic</code></h3>
<p><code>soundex_phonetic</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = soundex_phonetic $x
# or in a pipeline:
@list |> map soundex_phonetic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spaceship">
<h3><a class="doc-anchor" href="#doc-spaceship">#</a> <code>spaceship</code></h3>
<p><code>spaceship</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = spaceship $x
# or in a pipeline:
@list |> map spaceship |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-span">
<h3><a class="doc-anchor" href="#doc-span">#</a> <code>span</code></h3>
<p><code>span</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = span $x
# or in a pipeline:
@list |> map span |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-span-fn">
<h3><a class="doc-anchor" href="#doc-span-fn">#</a> <code>span_fn</code></h3>
<p><code>span_fn</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = span_fn $x
# or in a pipeline:
@list |> map span_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spanf">
<h3><a class="doc-anchor" href="#doc-spanf">#</a> <code>spanf</code></h3>
<p><code>spanf</code> — haskell list functions builtin. Alias for <code>span_fn</code>.</p>
<pre><code class="lang-perl">my $result = spanf $x
# or in a pipeline:
@list |> map spanf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sparse-csr-build">
<h3><a class="doc-anchor" href="#doc-sparse-csr-build">#</a> <code>sparse_csr_build</code></h3>
<p><code>sparse_csr_build</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = sparse_csr_build $x
# or in a pipeline:
@list |> map sparse_csr_build |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sparse-csr-mul-vec">
<h3><a class="doc-anchor" href="#doc-sparse-csr-mul-vec">#</a> <code>sparse_csr_mul_vec</code></h3>
<p><code>sparse_csr_mul_vec</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = sparse_csr_mul_vec $x
# or in a pipeline:
@list |> map sparse_csr_mul_vec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sparse-density">
<h3><a class="doc-anchor" href="#doc-sparse-density">#</a> <code>sparse_density</code></h3>
<p><code>sparse_density</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = sparse_density $x
# or in a pipeline:
@list |> map sparse_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spat">
<h3><a class="doc-anchor" href="#doc-spat">#</a> <code>spat</code></h3>
<p><code>spat</code> — algebraic match builtin. Alias for <code>split_at</code>.</p>
<pre><code class="lang-perl">my $result = spat $x
# or in a pipeline:
@list |> map spat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spbfs">
<h3><a class="doc-anchor" href="#doc-spbfs">#</a> <code>spbfs</code></h3>
<p><code>spbfs</code> — extended stdlib builtin. Alias for <code>shortest_path_bfs</code>.</p>
<pre><code class="lang-perl">my $result = spbfs $x
# or in a pipeline:
@list |> map spbfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spearman">
<h3><a class="doc-anchor" href="#doc-spearman">#</a> <code>spearman</code></h3>
<p><code>spearman_correlation(\@x, \@y)</code> (alias <code>spearman</code>) — computes Spearman's rank correlation coefficient between two datasets. Measures monotonic relationships, robust to outliers. Returns a value from -1 to 1.</p>
<pre><code class="lang-perl">my @x = (1, 2, 3, 4, 5)
my @y = (5, 6, 7, 8, 7)
p spearman(\@x, \@y) # high positive correlation
</code></pre>
</article>
<article class="doc-entry" id="doc-spearmanr">
<h3><a class="doc-anchor" href="#doc-spearmanr">#</a> <code>spearmanr</code></h3>
<p><code>spearmanr</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = spearmanr $x
# or in a pipeline:
@list |> map spearmanr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-species-area">
<h3><a class="doc-anchor" href="#doc-species-area">#</a> <code>species_area</code></h3>
<p><code>species_area</code> — batch 22 builtin.</p>
<pre><code class="lang-perl">my $result = species_area $x
# or in a pipeline:
@list |> map species_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-specific-angular-momentum">
<h3><a class="doc-anchor" href="#doc-specific-angular-momentum">#</a> <code>specific_angular_momentum</code></h3>
<p><code>specific_angular_momentum</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = specific_angular_momentum $x
# or in a pipeline:
@list |> map specific_angular_momentum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-specific-capacity-active">
<h3><a class="doc-anchor" href="#doc-specific-capacity-active">#</a> <code>specific_capacity_active</code></h3>
<p><code>specific_capacity_active</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = specific_capacity_active $x
# or in a pipeline:
@list |> map specific_capacity_active |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-specific-gravity-water">
<h3><a class="doc-anchor" href="#doc-specific-gravity-water">#</a> <code>specific_gravity_water</code></h3>
<p><code>specific_gravity_water</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = specific_gravity_water $x
# or in a pipeline:
@list |> map specific_gravity_water |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-specific-heat-const-v">
<h3><a class="doc-anchor" href="#doc-specific-heat-const-v">#</a> <code>specific_heat_const_v</code></h3>
<p><code>specific_heat_const_v</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = specific_heat_const_v $x
# or in a pipeline:
@list |> map specific_heat_const_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-specific-orbital-energy">
<h3><a class="doc-anchor" href="#doc-specific-orbital-energy">#</a> <code>specific_orbital_energy</code></h3>
<p><code>specific_orbital_energy</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = specific_orbital_energy $x
# or in a pipeline:
@list |> map specific_orbital_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-specificity">
<h3><a class="doc-anchor" href="#doc-specificity">#</a> <code>specificity</code></h3>
<p><code>specificity</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = specificity $x
# or in a pipeline:
@list |> map specificity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-speck-round">
<h3><a class="doc-anchor" href="#doc-speck-round">#</a> <code>speck_round</code></h3>
<p><code>speck_round</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = speck_round $x
# or in a pipeline:
@list |> map speck_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectral-density-estimate">
<h3><a class="doc-anchor" href="#doc-spectral-density-estimate">#</a> <code>spectral_density_estimate</code></h3>
<p><code>spectral_density_estimate</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = spectral_density_estimate $x
# or in a pipeline:
@list |> map spectral_density_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectral-kappa-minus53">
<h3><a class="doc-anchor" href="#doc-spectral-kappa-minus53">#</a> <code>spectral_kappa_minus53</code></h3>
<p><code>spectral_kappa_minus53</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = spectral_kappa_minus53 $x
# or in a pipeline:
@list |> map spectral_kappa_minus53 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectral-radius">
<h3><a class="doc-anchor" href="#doc-spectral-radius">#</a> <code>spectral_radius</code></h3>
<p><code>spectral_radius</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = spectral_radius $x
# or in a pipeline:
@list |> map spectral_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectral-signature-match">
<h3><a class="doc-anchor" href="#doc-spectral-signature-match">#</a> <code>spectral_signature_match</code></h3>
<p><code>spectral_signature_match</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = spectral_signature_match $x
# or in a pipeline:
@list |> map spectral_signature_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectro">
<h3><a class="doc-anchor" href="#doc-spectro">#</a> <code>spectro</code></h3>
<p><code>spectro</code> — dsp / signal (extended) builtin. Alias for <code>spectrogram</code>.</p>
<pre><code class="lang-perl">my $result = spectro $x
# or in a pipeline:
@list |> map spectro |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectrogram">
<h3><a class="doc-anchor" href="#doc-spectrogram">#</a> <code>spectrogram</code></h3>
<p><code>spectrogram(\@signal, $window_size, $hop_size)</code> (alias <code>stft</code>) — computes Short-Time Fourier Transform. Returns a 2D arrayref where each row is the spectrum of a windowed segment. Useful for time-frequency analysis.</p>
<pre><code class="lang-perl">my $spec = stft(\@audio, 1024, 512)
# $spec->[t][f] is magnitude at time t, frequency f
</code></pre>
</article>
<article class="doc-entry" id="doc-spectrogram-simple">
<h3><a class="doc-anchor" href="#doc-spectrogram-simple">#</a> <code>spectrogram_simple</code></h3>
<p><code>spectrogram_simple</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = spectrogram_simple $x
# or in a pipeline:
@list |> map spectrogram_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectrophotometer-beer-lambert">
<h3><a class="doc-anchor" href="#doc-spectrophotometer-beer-lambert">#</a> <code>spectrophotometer_beer_lambert</code></h3>
<p><code>spectrophotometer_beer_lambert</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = spectrophotometer_beer_lambert $x
# or in a pipeline:
@list |> map spectrophotometer_beer_lambert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectroscopic-factor">
<h3><a class="doc-anchor" href="#doc-spectroscopic-factor">#</a> <code>spectroscopic_factor</code></h3>
<p><code>spectroscopic_factor</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = spectroscopic_factor $x
# or in a pipeline:
@list |> map spectroscopic_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-speed-distance-time">
<h3><a class="doc-anchor" href="#doc-speed-distance-time">#</a> <code>speed_distance_time</code></h3>
<p><code>speed_distance_time</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = speed_distance_time $x
# or in a pipeline:
@list |> map speed_distance_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-speed-of-light">
<h3><a class="doc-anchor" href="#doc-speed-of-light">#</a> <code>speed_of_light</code></h3>
<p><code>speed_of_light</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = speed_of_light $x
# or in a pipeline:
@list |> map speed_of_light |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-speed-of-sound-ideal">
<h3><a class="doc-anchor" href="#doc-speed-of-sound-ideal">#</a> <code>speed_of_sound_ideal</code></h3>
<p><code>speed_of_sound_ideal</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = speed_of_sound_ideal $x
# or in a pipeline:
@list |> map speed_of_sound_ideal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spew">
<h3><a class="doc-anchor" href="#doc-spew">#</a> <code>spew</code></h3>
<p><code>spew</code> — filesystem extensions builtin. Alias for <code>spurt</code>.</p>
<pre><code class="lang-perl">my $result = spew $x
# or in a pipeline:
@list |> map spew |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sph-harm">
<h3><a class="doc-anchor" href="#doc-sph-harm">#</a> <code>sph_harm</code></h3>
<p><code>sph_harm</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = sph_harm $x
# or in a pipeline:
@list |> map sph_harm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphenic-q">
<h3><a class="doc-anchor" href="#doc-sphenic-q">#</a> <code>sphenic_q</code></h3>
<p><code>sphenic_q</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = sphenic_q $x
# or in a pipeline:
@list |> map sphenic_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphere-of-influence">
<h3><a class="doc-anchor" href="#doc-sphere-of-influence">#</a> <code>sphere_of_influence</code></h3>
<p><code>sphere_of_influence</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = sphere_of_influence $x
# or in a pipeline:
@list |> map sphere_of_influence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphere-surface">
<h3><a class="doc-anchor" href="#doc-sphere-surface">#</a> <code>sphere_surface</code></h3>
<p><code>sphere_surface</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = sphere_surface $x
# or in a pipeline:
@list |> map sphere_surface |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphere-volume">
<h3><a class="doc-anchor" href="#doc-sphere-volume">#</a> <code>sphere_volume</code></h3>
<p><code>sphere_volume</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = sphere_volume $x
# or in a pipeline:
@list |> map sphere_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spherical-bessel-j0">
<h3><a class="doc-anchor" href="#doc-spherical-bessel-j0">#</a> <code>spherical_bessel_j0</code></h3>
<p><code>spherical_bessel_j0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = spherical_bessel_j0 $x
# or in a pipeline:
@list |> map spherical_bessel_j0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spherical-bessel-j1">
<h3><a class="doc-anchor" href="#doc-spherical-bessel-j1">#</a> <code>spherical_bessel_j1</code></h3>
<p><code>spherical_bessel_j1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = spherical_bessel_j1 $x
# or in a pipeline:
@list |> map spherical_bessel_j1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spherical-bessel-y0">
<h3><a class="doc-anchor" href="#doc-spherical-bessel-y0">#</a> <code>spherical_bessel_y0</code></h3>
<p><code>spherical_bessel_y0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = spherical_bessel_y0 $x
# or in a pipeline:
@list |> map spherical_bessel_y0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spherical-bessel-y1">
<h3><a class="doc-anchor" href="#doc-spherical-bessel-y1">#</a> <code>spherical_bessel_y1</code></h3>
<p><code>spherical_bessel_y1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = spherical_bessel_y1 $x
# or in a pipeline:
@list |> map spherical_bessel_y1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spherical-jn">
<h3><a class="doc-anchor" href="#doc-spherical-jn">#</a> <code>spherical_jn</code></h3>
<p><code>spherical_jn</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = spherical_jn $x
# or in a pipeline:
@list |> map spherical_jn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spherical-triangle-area">
<h3><a class="doc-anchor" href="#doc-spherical-triangle-area">#</a> <code>spherical_triangle_area</code></h3>
<p><code>spherical_triangle_area</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = spherical_triangle_area $x
# or in a pipeline:
@list |> map spherical_triangle_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spherical-yn">
<h3><a class="doc-anchor" href="#doc-spherical-yn">#</a> <code>spherical_yn</code></h3>
<p><code>spherical_yn</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = spherical_yn $x
# or in a pipeline:
@list |> map spherical_yn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphsurf">
<h3><a class="doc-anchor" href="#doc-sphsurf">#</a> <code>sphsurf</code></h3>
<p><code>sphsurf</code> — geometry / physics builtin. Alias for <code>sphere_surface</code>.</p>
<pre><code class="lang-perl">my $result = sphsurf $x
# or in a pipeline:
@list |> map sphsurf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphvol">
<h3><a class="doc-anchor" href="#doc-sphvol">#</a> <code>sphvol</code></h3>
<p><code>sphvol</code> — geometry / physics builtin. Alias for <code>sphere_volume</code>.</p>
<pre><code class="lang-perl">my $result = sphvol $x
# or in a pipeline:
@list |> map sphvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spin-casimir">
<h3><a class="doc-anchor" href="#doc-spin-casimir">#</a> <code>spin_casimir</code></h3>
<p><code>spin_casimir</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = spin_casimir $x
# or in a pipeline:
@list |> map spin_casimir |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spin-orbit-coupling-term">
<h3><a class="doc-anchor" href="#doc-spin-orbit-coupling-term">#</a> <code>spin_orbit_coupling_term</code></h3>
<p><code>spin_orbit_coupling_term</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = spin_orbit_coupling_term $x
# or in a pipeline:
@list |> map spin_orbit_coupling_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spin-spin-coupling-term">
<h3><a class="doc-anchor" href="#doc-spin-spin-coupling-term">#</a> <code>spin_spin_coupling_term</code></h3>
<p><code>spin_spin_coupling_term</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = spin_spin_coupling_term $x
# or in a pipeline:
@list |> map spin_spin_coupling_term |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spinner-start">
<h3><a class="doc-anchor" href="#doc-spinner-start">#</a> <code>spinner_start</code></h3>
<p><code>spinner_start</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = spinner_start $x
# or in a pipeline:
@list |> map spinner_start |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spinner-stop">
<h3><a class="doc-anchor" href="#doc-spinner-stop">#</a> <code>spinner_stop</code></h3>
<p><code>spinner_stop</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = spinner_stop $x
# or in a pipeline:
@list |> map spinner_stop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-split-at">
<h3><a class="doc-anchor" href="#doc-split-at">#</a> <code>split_at</code></h3>
<p><code>split_at</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = split_at $x
# or in a pipeline:
@list |> map split_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-split-on">
<h3><a class="doc-anchor" href="#doc-split-on">#</a> <code>split_on</code></h3>
<p><code>split_on</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = split_on $x
# or in a pipeline:
@list |> map split_on |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-split-regex">
<h3><a class="doc-anchor" href="#doc-split-regex">#</a> <code>split_regex</code></h3>
<p><code>split_regex</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = split_regex $x
# or in a pipeline:
@list |> map split_regex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-split-with">
<h3><a class="doc-anchor" href="#doc-split-with">#</a> <code>split_with</code></h3>
<p><code>split_with</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = split_with $x
# or in a pipeline:
@list |> map split_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-splitmix64-step">
<h3><a class="doc-anchor" href="#doc-splitmix64-step">#</a> <code>splitmix64_step</code></h3>
<p><code>splitmix64_step</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = splitmix64_step $x
# or in a pipeline:
@list |> map splitmix64_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-splre">
<h3><a class="doc-anchor" href="#doc-splre">#</a> <code>splre</code></h3>
<p><code>splre</code> — extended stdlib builtin. Alias for <code>split_regex</code>.</p>
<pre><code class="lang-perl">my $result = splre $x
# or in a pipeline:
@list |> map splre |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spon">
<h3><a class="doc-anchor" href="#doc-spon">#</a> <code>spon</code></h3>
<p><code>spon</code> — go/general functional utilities builtin. Alias for <code>split_on</code>.</p>
<pre><code class="lang-perl">my $result = spon $x
# or in a pipeline:
@list |> map spon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spookyhash-128">
<h3><a class="doc-anchor" href="#doc-spookyhash-128">#</a> <code>spookyhash_128</code></h3>
<p><code>spookyhash_128</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = spookyhash_128 $x
# or in a pipeline:
@list |> map spookyhash_128 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spop">
<h3><a class="doc-anchor" href="#doc-spop">#</a> <code>spop</code></h3>
<p><code>spop</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = spop $x
# or in a pipeline:
@list |> map spop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spring-energy">
<h3><a class="doc-anchor" href="#doc-spring-energy">#</a> <code>spring_energy</code></h3>
<p><code>spring_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = spring_energy $x
# or in a pipeline:
@list |> map spring_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spring-force">
<h3><a class="doc-anchor" href="#doc-spring-force">#</a> <code>spring_force</code></h3>
<p><code>spring_force</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = spring_force $x
# or in a pipeline:
@list |> map spring_force |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spring-period">
<h3><a class="doc-anchor" href="#doc-spring-period">#</a> <code>spring_period</code></h3>
<p><code>spring_period</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = spring_period $x
# or in a pipeline:
@list |> map spring_period |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-springpe">
<h3><a class="doc-anchor" href="#doc-springpe">#</a> <code>springpe</code></h3>
<p><code>springpe</code> — physics formulas builtin. Alias for <code>spring_energy</code>.</p>
<pre><code class="lang-perl">my $result = springpe $x
# or in a pipeline:
@list |> map springpe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spt-n-correction">
<h3><a class="doc-anchor" href="#doc-spt-n-correction">#</a> <code>spt_n_correction</code></h3>
<p><code>spt_n_correction</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = spt_n_correction $x
# or in a pipeline:
@list |> map spt_n_correction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spw">
<h3><a class="doc-anchor" href="#doc-spw">#</a> <code>spw</code></h3>
<p><code>spw</code> — algebraic match builtin. Alias for <code>split_with</code>.</p>
<pre><code class="lang-perl">my $result = spw $x
# or in a pipeline:
@list |> map spw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sql">
<h3><a class="doc-anchor" href="#doc-sql">#</a> <code>sql</code></h3>
<p><code>sql</code> — data / network builtin. Alias for <code>sqlite</code>.</p>
<pre><code class="lang-perl">my $result = sql $x
# or in a pipeline:
@list |> map sql |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sqr">
<h3><a class="doc-anchor" href="#doc-sqr">#</a> <code>sqr</code></h3>
<p><code>sqr</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = sqr $x
# or in a pipeline:
@list |> map sqr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sqrt2">
<h3><a class="doc-anchor" href="#doc-sqrt2">#</a> <code>sqrt2</code></h3>
<p><code>sqrt2</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = sqrt2 $x
# or in a pipeline:
@list |> map sqrt2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sqrt-each">
<h3><a class="doc-anchor" href="#doc-sqrt-each">#</a> <code>sqrt_each</code></h3>
<p><code>sqrt_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = sqrt_each $x
# or in a pipeline:
@list |> map sqrt_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sqrt-swap-gate">
<h3><a class="doc-anchor" href="#doc-sqrt-swap-gate">#</a> <code>sqrt_swap_gate</code></h3>
<p><code>sqrt_swap_gate</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = sqrt_swap_gate $x
# or in a pipeline:
@list |> map sqrt_swap_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-square-each">
<h3><a class="doc-anchor" href="#doc-square-each">#</a> <code>square_each</code></h3>
<p><code>square_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = square_each $x
# or in a pipeline:
@list |> map square_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-square-pyramidal-number">
<h3><a class="doc-anchor" href="#doc-square-pyramidal-number">#</a> <code>square_pyramidal_number</code></h3>
<p><code>square_pyramidal_number</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = square_pyramidal_number $x
# or in a pipeline:
@list |> map square_pyramidal_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-square-root">
<h3><a class="doc-anchor" href="#doc-square-root">#</a> <code>square_root</code></h3>
<p><code>square_root</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = square_root $x
# or in a pipeline:
@list |> map square_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-squared-hinge">
<h3><a class="doc-anchor" href="#doc-squared-hinge">#</a> <code>squared_hinge</code></h3>
<p><code>squared_hinge</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = squared_hinge $x
# or in a pipeline:
@list |> map squared_hinge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-squared-triangular">
<h3><a class="doc-anchor" href="#doc-squared-triangular">#</a> <code>squared_triangular</code></h3>
<p><code>squared_triangular</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = squared_triangular $x
# or in a pipeline:
@list |> map squared_triangular |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-squares-seq">
<h3><a class="doc-anchor" href="#doc-squares-seq">#</a> <code>squares_seq</code></h3>
<p><code>squares_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = squares_seq $x
# or in a pipeline:
@list |> map squares_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-squeezing-db">
<h3><a class="doc-anchor" href="#doc-squeezing-db">#</a> <code>squeezing_db</code></h3>
<p><code>squeezing_db</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = squeezing_db $x
# or in a pipeline:
@list |> map squeezing_db |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-squish">
<h3><a class="doc-anchor" href="#doc-squish">#</a> <code>squish</code></h3>
<p><code>squish</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = squish $x
# or in a pipeline:
@list |> map squish |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sregex">
<h3><a class="doc-anchor" href="#doc-sregex">#</a> <code>sregex</code></h3>
<p><code>sregex</code> — stress / telemetry extensions builtin. Alias for <code>stress_regex</code>.</p>
<pre><code class="lang-perl">my $result = sregex $x
# or in a pipeline:
@list |> map sregex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-srem">
<h3><a class="doc-anchor" href="#doc-srem">#</a> <code>srem</code></h3>
<p><code>srem</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = srem $x
# or in a pipeline:
@list |> map srem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-srgb-to-xyz">
<h3><a class="doc-anchor" href="#doc-srgb-to-xyz">#</a> <code>srgb_to_xyz</code></h3>
<p><code>srgb_to_xyz</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = srgb_to_xyz $input
</code></pre>
</article>
<article class="doc-entry" id="doc-srton">
<h3><a class="doc-anchor" href="#doc-srton">#</a> <code>srton</code></h3>
<p><code>srton</code> — haskell list functions builtin. Alias for <code>sort_on</code>.</p>
<pre><code class="lang-perl">my $result = srton $x
# or in a pipeline:
@list |> map srton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ssa-phi-insert">
<h3><a class="doc-anchor" href="#doc-ssa-phi-insert">#</a> <code>ssa_phi_insert</code></h3>
<p><code>ssa_phi_insert</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = ssa_phi_insert $x
# or in a pipeline:
@list |> map ssa_phi_insert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ssn-check">
<h3><a class="doc-anchor" href="#doc-ssn-check">#</a> <code>ssn_check</code></h3>
<p><code>ssn_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = ssn_check $x
# or in a pipeline:
@list |> map ssn_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ssort">
<h3><a class="doc-anchor" href="#doc-ssort">#</a> <code>ssort</code></h3>
<p><code>ssort</code> — stress / telemetry extensions builtin. Alias for <code>stress_sort</code>.</p>
<pre><code class="lang-perl">my $result = ssort $x
# or in a pipeline:
@list |> map ssort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sst-anomaly-step">
<h3><a class="doc-anchor" href="#doc-sst-anomaly-step">#</a> <code>sst_anomaly_step</code></h3>
<p><code>sst_anomaly_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = sst_anomaly_step $x
# or in a pipeline:
@list |> map sst_anomaly_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stable-matching-count">
<h3><a class="doc-anchor" href="#doc-stable-matching-count">#</a> <code>stable_matching_count</code></h3>
<p><code>stable_matching_count</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = stable_matching_count $x
# or in a pipeline:
@list |> map stable_matching_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stack-new">
<h3><a class="doc-anchor" href="#doc-stack-new">#</a> <code>stack_new</code></h3>
<p><code>stack_new</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = stack_new $x
# or in a pipeline:
@list |> map stack_new |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stackelberg-eq">
<h3><a class="doc-anchor" href="#doc-stackelberg-eq">#</a> <code>stackelberg_eq</code></h3>
<p><code>stackelberg_eq</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = stackelberg_eq $x
# or in a pipeline:
@list |> map stackelberg_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stackelberg-step">
<h3><a class="doc-anchor" href="#doc-stackelberg-step">#</a> <code>stackelberg_step</code></h3>
<p><code>stackelberg_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = stackelberg_step $x
# or in a pipeline:
@list |> map stackelberg_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stag-hunt-payoff">
<h3><a class="doc-anchor" href="#doc-stag-hunt-payoff">#</a> <code>stag_hunt_payoff</code></h3>
<p><code>stag_hunt_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = stag_hunt_payoff $x
# or in a pipeline:
@list |> map stag_hunt_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-standard-error">
<h3><a class="doc-anchor" href="#doc-standard-error">#</a> <code>standard_error</code></h3>
<p><code>standard_error</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = standard_error $x
# or in a pipeline:
@list |> map standard_error |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-standardized-mortality-smr">
<h3><a class="doc-anchor" href="#doc-standardized-mortality-smr">#</a> <code>standardized_mortality_smr</code></h3>
<p><code>standardized_mortality_smr</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = standardized_mortality_smr $x
# or in a pipeline:
@list |> map standardized_mortality_smr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-standing-wave-fundamental">
<h3><a class="doc-anchor" href="#doc-standing-wave-fundamental">#</a> <code>standing_wave_fundamental</code></h3>
<p><code>standing_wave_fundamental</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = standing_wave_fundamental $x
# or in a pipeline:
@list |> map standing_wave_fundamental |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-star-number">
<h3><a class="doc-anchor" href="#doc-star-number">#</a> <code>star_number</code></h3>
<p><code>star_number</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = star_number $x
# or in a pipeline:
@list |> map star_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stark-shift-linear">
<h3><a class="doc-anchor" href="#doc-stark-shift-linear">#</a> <code>stark_shift_linear</code></h3>
<p><code>stark_shift_linear</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = stark_shift_linear $x
# or in a pipeline:
@list |> map stark_shift_linear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-starmap">
<h3><a class="doc-anchor" href="#doc-starmap">#</a> <code>starmap</code></h3>
<p><code>starmap</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = starmap $x
# or in a pipeline:
@list |> map starmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-start-of-day">
<h3><a class="doc-anchor" href="#doc-start-of-day">#</a> <code>start_of_day</code></h3>
<p><code>start_of_day</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = start_of_day $x
# or in a pipeline:
@list |> map start_of_day |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-start-of-hour">
<h3><a class="doc-anchor" href="#doc-start-of-hour">#</a> <code>start_of_hour</code></h3>
<p><code>start_of_hour</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = start_of_hour $x
# or in a pipeline:
@list |> map start_of_hour |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-start-of-minute">
<h3><a class="doc-anchor" href="#doc-start-of-minute">#</a> <code>start_of_minute</code></h3>
<p><code>start_of_minute</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = start_of_minute $x
# or in a pipeline:
@list |> map start_of_minute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-starts-with">
<h3><a class="doc-anchor" href="#doc-starts-with">#</a> <code>starts_with</code></h3>
<p><code>starts_with</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = starts_with $x
# or in a pipeline:
@list |> map starts_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-starts-with-any">
<h3><a class="doc-anchor" href="#doc-starts-with-any">#</a> <code>starts_with_any</code></h3>
<p><code>starts_with_any</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = starts_with_any $x
# or in a pipeline:
@list |> map starts_with_any |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-state-norm">
<h3><a class="doc-anchor" href="#doc-state-norm">#</a> <code>state_norm</code></h3>
<p><code>state_norm</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = state_norm $x
# or in a pipeline:
@list |> map state_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-state-normalize">
<h3><a class="doc-anchor" href="#doc-state-normalize">#</a> <code>state_normalize</code></h3>
<p><code>state_normalize</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = state_normalize $x
# or in a pipeline:
@list |> map state_normalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-state-of-charge-kalman">
<h3><a class="doc-anchor" href="#doc-state-of-charge-kalman">#</a> <code>state_of_charge_kalman</code></h3>
<p><code>state_of_charge_kalman</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = state_of_charge_kalman $x
# or in a pipeline:
@list |> map state_of_charge_kalman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-state-space-kalman">
<h3><a class="doc-anchor" href="#doc-state-space-kalman">#</a> <code>state_space_kalman</code></h3>
<p><code>state_space_kalman</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = state_space_kalman $x
# or in a pipeline:
@list |> map state_space_kalman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stats-describe">
<h3><a class="doc-anchor" href="#doc-stats-describe">#</a> <code>stats_describe</code></h3>
<p><code>stats_describe</code> — statistics (extended) builtin. Alias for <code>describe</code>.</p>
<pre><code class="lang-perl">my $result = stats_describe $x
# or in a pipeline:
@list |> map stats_describe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stderr-stat">
<h3><a class="doc-anchor" href="#doc-stderr-stat">#</a> <code>stderr_stat</code></h3>
<p><code>stderr_stat</code> — math / numeric (uncategorized batch) builtin. Alias for <code>standard_error</code>.</p>
<pre><code class="lang-perl">my $result = stderr_stat $x
# or in a pipeline:
@list |> map stderr_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stefan-boltzmann">
<h3><a class="doc-anchor" href="#doc-stefan-boltzmann">#</a> <code>stefan_boltzmann</code></h3>
<p><code>stefan_boltzmann</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = stefan_boltzmann $x
# or in a pipeline:
@list |> map stefan_boltzmann |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stefan-boltzmann-constant">
<h3><a class="doc-anchor" href="#doc-stefan-boltzmann-constant">#</a> <code>stefan_boltzmann_constant</code></h3>
<p><code>stefan_boltzmann_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = stefan_boltzmann_constant $x
# or in a pipeline:
@list |> map stefan_boltzmann_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stefan-boltzmann-radiation">
<h3><a class="doc-anchor" href="#doc-stefan-boltzmann-radiation">#</a> <code>stefan_boltzmann_radiation</code></h3>
<p><code>stefan_boltzmann_radiation</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = stefan_boltzmann_radiation $x
# or in a pipeline:
@list |> map stefan_boltzmann_radiation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stefan-boltzmann-si">
<h3><a class="doc-anchor" href="#doc-stefan-boltzmann-si">#</a> <code>stefan_boltzmann_si</code></h3>
<p><code>stefan_boltzmann_si</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = stefan_boltzmann_si $x
# or in a pipeline:
@list |> map stefan_boltzmann_si |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stefboltz">
<h3><a class="doc-anchor" href="#doc-stefboltz">#</a> <code>stefboltz</code></h3>
<p><code>stefboltz</code> — physics formulas builtin. Alias for <code>stefan_boltzmann</code>.</p>
<pre><code class="lang-perl">my $result = stefboltz $x
# or in a pipeline:
@list |> map stefboltz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-steffensen">
<h3><a class="doc-anchor" href="#doc-steffensen">#</a> <code>steffensen</code></h3>
<p><code>steffensen</code> — batch 19 builtin. Alias for <code>steffensen_root</code>.</p>
<pre><code class="lang-perl">my $result = steffensen $x
# or in a pipeline:
@list |> map steffensen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-steffensen-root">
<h3><a class="doc-anchor" href="#doc-steffensen-root">#</a> <code>steffensen_root</code></h3>
<p><code>steffensen_root</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = steffensen_root $x
# or in a pipeline:
@list |> map steffensen_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stem-lancaster">
<h3><a class="doc-anchor" href="#doc-stem-lancaster">#</a> <code>stem_lancaster</code></h3>
<p><code>stem_lancaster</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = stem_lancaster $x
# or in a pipeline:
@list |> map stem_lancaster |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-step">
<h3><a class="doc-anchor" href="#doc-step">#</a> <code>step</code></h3>
<p><code>step</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = step $x
# or in a pipeline:
@list |> map step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stern-layer-capacitance">
<h3><a class="doc-anchor" href="#doc-stern-layer-capacitance">#</a> <code>stern_layer_capacitance</code></h3>
<p><code>stern_layer_capacitance</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = stern_layer_capacitance $x
# or in a pipeline:
@list |> map stern_layer_capacitance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stft-step">
<h3><a class="doc-anchor" href="#doc-stft-step">#</a> <code>stft_step</code></h3>
<p><code>stft_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = stft_step $x
# or in a pipeline:
@list |> map stft_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sthread">
<h3><a class="doc-anchor" href="#doc-sthread">#</a> <code>sthread</code></h3>
<p><code>sthread</code> — stress / telemetry extensions builtin. Alias for <code>stress_thread</code>.</p>
<pre><code class="lang-perl">my $result = sthread $x
# or in a pipeline:
@list |> map sthread |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stiffness-ratio">
<h3><a class="doc-anchor" href="#doc-stiffness-ratio">#</a> <code>stiffness_ratio</code></h3>
<p><code>stiffness_ratio</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = stiffness_ratio $x
# or in a pipeline:
@list |> map stiffness_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stirling">
<h3><a class="doc-anchor" href="#doc-stirling">#</a> <code>stirling</code></h3>
<p><code>stirling</code> — math formulas builtin. Alias for <code>stirling_approx</code>.</p>
<pre><code class="lang-perl">my $result = stirling $x
# or in a pipeline:
@list |> map stirling |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stirling2">
<h3><a class="doc-anchor" href="#doc-stirling2">#</a> <code>stirling2</code></h3>
<p><code>stirling2</code> (alias <code>stirling_second</code>) computes the Stirling number of the second kind S(n,k) — the number of ways to partition n elements into k non-empty subsets.</p>
<pre><code class="lang-perl">p stirling2(4, 2) # 7
p stirling2(5, 3) # 25
</code></pre>
</article>
<article class="doc-entry" id="doc-stirling-approx">
<h3><a class="doc-anchor" href="#doc-stirling-approx">#</a> <code>stirling_approx</code></h3>
<p><code>stirling_approx</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = stirling_approx $x
# or in a pipeline:
@list |> map stirling_approx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stl-decompose">
<h3><a class="doc-anchor" href="#doc-stl-decompose">#</a> <code>stl_decompose</code></h3>
<p><code>stl_decompose</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = stl_decompose $x
# or in a pipeline:
@list |> map stl_decompose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stoer-wagner-step">
<h3><a class="doc-anchor" href="#doc-stoer-wagner-step">#</a> <code>stoer_wagner_step</code></h3>
<p><code>stoer_wagner_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = stoer_wagner_step $x
# or in a pipeline:
@list |> map stoer_wagner_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stone-to-kg">
<h3><a class="doc-anchor" href="#doc-stone-to-kg">#</a> <code>stone_to_kg</code></h3>
<p><code>stone_to_kg</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = stone_to_kg $input
</code></pre>
</article>
<article class="doc-entry" id="doc-stormer-verlet-step">
<h3><a class="doc-anchor" href="#doc-stormer-verlet-step">#</a> <code>stormer_verlet_step</code></h3>
<p><code>stormer_verlet_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = stormer_verlet_step $x
# or in a pipeline:
@list |> map stormer_verlet_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strang-split">
<h3><a class="doc-anchor" href="#doc-strang-split">#</a> <code>strang_split</code></h3>
<p><code>strang_split</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = strang_split $x
# or in a pipeline:
@list |> map strang_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stratonovich-correction">
<h3><a class="doc-anchor" href="#doc-stratonovich-correction">#</a> <code>stratonovich_correction</code></h3>
<p><code>stratonovich_correction</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = stratonovich_correction $x
# or in a pipeline:
@list |> map stratonovich_correction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strdist">
<h3><a class="doc-anchor" href="#doc-strdist">#</a> <code>strdist</code></h3>
<p><code>strdist</code> — string processing (uncategorized batch) builtin. Alias for <code>string_distance</code>.</p>
<pre><code class="lang-perl">my $result = strdist $x
# or in a pipeline:
@list |> map strdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-streak-color-index">
<h3><a class="doc-anchor" href="#doc-streak-color-index">#</a> <code>streak_color_index</code></h3>
<p><code>streak_color_index</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = streak_color_index $x
# or in a pipeline:
@list |> map streak_color_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stream-prompt-cb">
<h3><a class="doc-anchor" href="#doc-stream-prompt-cb">#</a> <code>stream_prompt_cb</code></h3>
<p><code>stream_prompt_cb</code> — ai primitives (docs/ai_primitives.md) builtin.</p>
<pre><code class="lang-perl">my $result = stream_prompt_cb $x
# or in a pipeline:
@list |> map stream_prompt_cb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-streamfunction-step">
<h3><a class="doc-anchor" href="#doc-streamfunction-step">#</a> <code>streamfunction_step</code></h3>
<p><code>streamfunction_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = streamfunction_step $x
# or in a pipeline:
@list |> map streamfunction_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strehl-ratio">
<h3><a class="doc-anchor" href="#doc-strehl-ratio">#</a> <code>strehl_ratio</code></h3>
<p><code>strehl_ratio</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = strehl_ratio $x
# or in a pipeline:
@list |> map strehl_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strict-word-similarity">
<h3><a class="doc-anchor" href="#doc-strict-word-similarity">#</a> <code>strict_word_similarity</code></h3>
<p><code>strict_word_similarity</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = strict_word_similarity $x
# or in a pipeline:
@list |> map strict_word_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strikethrough">
<h3><a class="doc-anchor" href="#doc-strikethrough">#</a> <code>strikethrough</code></h3>
<p><code>strikethrough</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = strikethrough $x
# or in a pipeline:
@list |> map strikethrough |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-agg">
<h3><a class="doc-anchor" href="#doc-string-agg">#</a> <code>string_agg</code></h3>
<p><code>string_agg</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = string_agg $x
# or in a pipeline:
@list |> map string_agg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-camel-to-snake">
<h3><a class="doc-anchor" href="#doc-string-camel-to-snake">#</a> <code>string_camel_to_snake</code></h3>
<p><code>string_camel_to_snake</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_camel_to_snake $input
</code></pre>
</article>
<article class="doc-entry" id="doc-string-chars">
<h3><a class="doc-anchor" href="#doc-string-chars">#</a> <code>string_chars</code></h3>
<p><code>string_chars</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_chars $x
# or in a pipeline:
@list |> map string_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-count">
<h3><a class="doc-anchor" href="#doc-string-count">#</a> <code>string_count</code></h3>
<p><code>string_count</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = string_count $x
# or in a pipeline:
@list |> map string_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-distance">
<h3><a class="doc-anchor" href="#doc-string-distance">#</a> <code>string_distance</code></h3>
<p><code>string_distance</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = string_distance $x
# or in a pipeline:
@list |> map string_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-drop-first">
<h3><a class="doc-anchor" href="#doc-string-drop-first">#</a> <code>string_drop_first</code></h3>
<p><code>string_drop_first</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = string_drop_first $x
# or in a pipeline:
@list |> map string_drop_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-drop-last">
<h3><a class="doc-anchor" href="#doc-string-drop-last">#</a> <code>string_drop_last</code></h3>
<p><code>string_drop_last</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = string_drop_last $x
# or in a pipeline:
@list |> map string_drop_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-drop-while">
<h3><a class="doc-anchor" href="#doc-string-drop-while">#</a> <code>string_drop_while</code></h3>
<p><code>string_drop_while</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_drop_while $x
# or in a pipeline:
@list |> map string_drop_while |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-expand-tabs">
<h3><a class="doc-anchor" href="#doc-string-expand-tabs">#</a> <code>string_expand_tabs</code></h3>
<p><code>string_expand_tabs</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_expand_tabs $x
# or in a pipeline:
@list |> map string_expand_tabs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-intersperse">
<h3><a class="doc-anchor" href="#doc-string-intersperse">#</a> <code>string_intersperse</code></h3>
<p><code>string_intersperse</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_intersperse $x
# or in a pipeline:
@list |> map string_intersperse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-kebab-to-snake">
<h3><a class="doc-anchor" href="#doc-string-kebab-to-snake">#</a> <code>string_kebab_to_snake</code></h3>
<p><code>string_kebab_to_snake</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_kebab_to_snake $input
</code></pre>
</article>
<article class="doc-entry" id="doc-string-letter-frequency">
<h3><a class="doc-anchor" href="#doc-string-letter-frequency">#</a> <code>string_letter_frequency</code></h3>
<p><code>string_letter_frequency</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_letter_frequency $x
# or in a pipeline:
@list |> map string_letter_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-lines-count">
<h3><a class="doc-anchor" href="#doc-string-lines-count">#</a> <code>string_lines_count</code></h3>
<p><code>string_lines_count</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_lines_count $x
# or in a pipeline:
@list |> map string_lines_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-multiply">
<h3><a class="doc-anchor" href="#doc-string-multiply">#</a> <code>string_multiply</code></h3>
<p><code>string_multiply</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = string_multiply $x
# or in a pipeline:
@list |> map string_multiply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-normalize-spaces">
<h3><a class="doc-anchor" href="#doc-string-normalize-spaces">#</a> <code>string_normalize_spaces</code></h3>
<p><code>string_normalize_spaces</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_normalize_spaces $x
# or in a pipeline:
@list |> map string_normalize_spaces |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-partition-at-word">
<h3><a class="doc-anchor" href="#doc-string-partition-at-word">#</a> <code>string_partition_at_word</code></h3>
<p><code>string_partition_at_word</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_partition_at_word $x
# or in a pipeline:
@list |> map string_partition_at_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-replicate">
<h3><a class="doc-anchor" href="#doc-string-replicate">#</a> <code>string_replicate</code></h3>
<p><code>string_replicate</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_replicate $x
# or in a pipeline:
@list |> map string_replicate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-snake-to-camel">
<h3><a class="doc-anchor" href="#doc-string-snake-to-camel">#</a> <code>string_snake_to_camel</code></h3>
<p><code>string_snake_to_camel</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_snake_to_camel $input
</code></pre>
</article>
<article class="doc-entry" id="doc-string-snake-to-kebab">
<h3><a class="doc-anchor" href="#doc-string-snake-to-kebab">#</a> <code>string_snake_to_kebab</code></h3>
<p><code>string_snake_to_kebab</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_snake_to_kebab $input
</code></pre>
</article>
<article class="doc-entry" id="doc-string-sort">
<h3><a class="doc-anchor" href="#doc-string-sort">#</a> <code>string_sort</code></h3>
<p><code>string_sort</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = string_sort $x
# or in a pipeline:
@list |> map string_sort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-split-at-first">
<h3><a class="doc-anchor" href="#doc-string-split-at-first">#</a> <code>string_split_at_first</code></h3>
<p><code>string_split_at_first</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_split_at_first $x
# or in a pipeline:
@list |> map string_split_at_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-take-first">
<h3><a class="doc-anchor" href="#doc-string-take-first">#</a> <code>string_take_first</code></h3>
<p><code>string_take_first</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = string_take_first $x
# or in a pipeline:
@list |> map string_take_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-take-last">
<h3><a class="doc-anchor" href="#doc-string-take-last">#</a> <code>string_take_last</code></h3>
<p><code>string_take_last</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = string_take_last $x
# or in a pipeline:
@list |> map string_take_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-take-while">
<h3><a class="doc-anchor" href="#doc-string-take-while">#</a> <code>string_take_while</code></h3>
<p><code>string_take_while</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_take_while $x
# or in a pipeline:
@list |> map string_take_while |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-to-charcodes">
<h3><a class="doc-anchor" href="#doc-string-to-charcodes">#</a> <code>string_to_charcodes</code></h3>
<p><code>string_to_charcodes</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_to_charcodes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-string-to-chars">
<h3><a class="doc-anchor" href="#doc-string-to-chars">#</a> <code>string_to_chars</code></h3>
<p><code>string_to_chars</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = string_to_chars $input
</code></pre>
</article>
<article class="doc-entry" id="doc-string-truncate-ellipsis">
<h3><a class="doc-anchor" href="#doc-string-truncate-ellipsis">#</a> <code>string_truncate_ellipsis</code></h3>
<p><code>string_truncate_ellipsis</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_truncate_ellipsis $x
# or in a pipeline:
@list |> map string_truncate_ellipsis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-uniq-chars">
<h3><a class="doc-anchor" href="#doc-string-uniq-chars">#</a> <code>string_uniq_chars</code></h3>
<p><code>string_uniq_chars</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_uniq_chars $x
# or in a pipeline:
@list |> map string_uniq_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-unique-chars">
<h3><a class="doc-anchor" href="#doc-string-unique-chars">#</a> <code>string_unique_chars</code></h3>
<p><code>string_unique_chars</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = string_unique_chars $x
# or in a pipeline:
@list |> map string_unique_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-words-count">
<h3><a class="doc-anchor" href="#doc-string-words-count">#</a> <code>string_words_count</code></h3>
<p><code>string_words_count</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = string_words_count $x
# or in a pipeline:
@list |> map string_words_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-xor">
<h3><a class="doc-anchor" href="#doc-string-xor">#</a> <code>string_xor</code></h3>
<p><code>string_xor</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = string_xor $x
# or in a pipeline:
@list |> map string_xor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strip-ansi">
<h3><a class="doc-anchor" href="#doc-strip-ansi">#</a> <code>strip_ansi</code></h3>
<p><code>strip_ansi</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = strip_ansi $x
# or in a pipeline:
@list |> map strip_ansi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strip-html">
<h3><a class="doc-anchor" href="#doc-strip-html">#</a> <code>strip_html</code></h3>
<p><code>strip_html</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = strip_html $x
# or in a pipeline:
@list |> map strip_html |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strip-prefix">
<h3><a class="doc-anchor" href="#doc-strip-prefix">#</a> <code>strip_prefix</code></h3>
<p><code>strip_prefix</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = strip_prefix $x
# or in a pipeline:
@list |> map strip_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strip-suffix">
<h3><a class="doc-anchor" href="#doc-strip-suffix">#</a> <code>strip_suffix</code></h3>
<p><code>strip_suffix</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = strip_suffix $x
# or in a pipeline:
@list |> map strip_suffix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strlen">
<h3><a class="doc-anchor" href="#doc-strlen">#</a> <code>strlen</code></h3>
<p><code>strlen</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = strlen $x
# or in a pipeline:
@list |> map strlen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strmul">
<h3><a class="doc-anchor" href="#doc-strmul">#</a> <code>strmul</code></h3>
<p><code>strmul</code> — string processing (uncategorized batch) builtin. Alias for <code>string_multiply</code>.</p>
<pre><code class="lang-perl">my $result = strmul $x
# or in a pipeline:
@list |> map strmul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strong-pseudoprime">
<h3><a class="doc-anchor" href="#doc-strong-pseudoprime">#</a> <code>strong_pseudoprime</code></h3>
<p><code>strong_pseudoprime</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = strong_pseudoprime $x
# or in a pipeline:
@list |> map strong_pseudoprime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strouhal-full">
<h3><a class="doc-anchor" href="#doc-strouhal-full">#</a> <code>strouhal_full</code></h3>
<p><code>strouhal_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = strouhal_full $x
# or in a pipeline:
@list |> map strouhal_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strsm">
<h3><a class="doc-anchor" href="#doc-strsm">#</a> <code>strsm</code></h3>
<p><code>strsm</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = strsm $x
# or in a pipeline:
@list |> map strsm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-struve-h0">
<h3><a class="doc-anchor" href="#doc-struve-h0">#</a> <code>struve_h0</code></h3>
<p><code>struve_h0</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = struve_h0 $x
# or in a pipeline:
@list |> map struve_h0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-struve-h1">
<h3><a class="doc-anchor" href="#doc-struve-h1">#</a> <code>struve_h1</code></h3>
<p><code>struve_h1</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = struve_h1 $x
# or in a pipeline:
@list |> map struve_h1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-student-pdf">
<h3><a class="doc-anchor" href="#doc-student-pdf">#</a> <code>student_pdf</code></h3>
<p><code>t_pdf</code> (alias <code>tpdf</code>) evaluates Student's t-distribution PDF at x with nu degrees of freedom.</p>
<pre><code class="lang-perl">p tpdf(0, 10) # peak of t(10)
p tpdf(2.228, 10)
</code></pre>
</article>
<article class="doc-entry" id="doc-stulz-min-call">
<h3><a class="doc-anchor" href="#doc-stulz-min-call">#</a> <code>stulz_min_call</code></h3>
<p><code>stulz_min_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = stulz_min_call $x
# or in a pipeline:
@list |> map stulz_min_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sturmian-word">
<h3><a class="doc-anchor" href="#doc-sturmian-word">#</a> <code>sturmian_word</code></h3>
<p><code>sturmian_word</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = sturmian_word $x
# or in a pipeline:
@list |> map sturmian_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sub">
<h3><a class="doc-anchor" href="#doc-sub">#</a> <code>sub</code></h3>
<p>The <code>sub</code> keyword is not supported in stryke. Use <code>fn</code> instead to define functions.</p>
</article>
<article class="doc-entry" id="doc-sub-script">
<h3><a class="doc-anchor" href="#doc-sub-script">#</a> <code>sub_script</code></h3>
<p><code>sub_script</code> — encoding / phonetics builtin. Alias for <code>subscript</code>.</p>
<pre><code class="lang-perl">my $result = sub_script $x
# or in a pipeline:
@list |> map sub_script |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subfact">
<h3><a class="doc-anchor" href="#doc-subfact">#</a> <code>subfact</code></h3>
<p><code>subfact</code> — math / numeric (uncategorized batch) builtin. Alias for <code>subfactorial</code>.</p>
<pre><code class="lang-perl">my $result = subfact $x
# or in a pipeline:
@list |> map subfact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subfactorial">
<h3><a class="doc-anchor" href="#doc-subfactorial">#</a> <code>subfactorial</code></h3>
<p><code>subfactorial</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = subfactorial $x
# or in a pipeline:
@list |> map subfactorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subgame-perfect-eq">
<h3><a class="doc-anchor" href="#doc-subgame-perfect-eq">#</a> <code>subgame_perfect_eq</code></h3>
<p><code>subgame_perfect_eq</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = subgame_perfect_eq $x
# or in a pipeline:
@list |> map subgame_perfect_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subgradient-step-size">
<h3><a class="doc-anchor" href="#doc-subgradient-step-size">#</a> <code>subgradient_step_size</code></h3>
<p><code>subgradient_step_size</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = subgradient_step_size $x
# or in a pipeline:
@list |> map subgradient_step_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subgraph-isomorphism">
<h3><a class="doc-anchor" href="#doc-subgraph-isomorphism">#</a> <code>subgraph_isomorphism</code></h3>
<p><code>subgraph_isomorphism</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = subgraph_isomorphism $x
# or in a pipeline:
@list |> map subgraph_isomorphism |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-submodular-curvature-bound">
<h3><a class="doc-anchor" href="#doc-submodular-curvature-bound">#</a> <code>submodular_curvature_bound</code></h3>
<p><code>submodular_curvature_bound</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = submodular_curvature_bound $x
# or in a pipeline:
@list |> map submodular_curvature_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-submodular-greedy-step">
<h3><a class="doc-anchor" href="#doc-submodular-greedy-step">#</a> <code>submodular_greedy_step</code></h3>
<p><code>submodular_greedy_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = submodular_greedy_step $x
# or in a pipeline:
@list |> map submodular_greedy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subname">
<h3><a class="doc-anchor" href="#doc-subname">#</a> <code>subname</code></h3>
<p><code>subname</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = subname $x
# or in a pipeline:
@list |> map subname |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subscript">
<h3><a class="doc-anchor" href="#doc-subscript">#</a> <code>subscript</code></h3>
<p><code>subscript</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = subscript $x
# or in a pipeline:
@list |> map subscript |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subseqs">
<h3><a class="doc-anchor" href="#doc-subseqs">#</a> <code>subseqs</code></h3>
<p><code>subseqs</code> — additional missing stdlib functions builtin. Alias for <code>subsequences</code>.</p>
<pre><code class="lang-perl">my $result = subseqs $x
# or in a pipeline:
@list |> map subseqs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subsequences">
<h3><a class="doc-anchor" href="#doc-subsequences">#</a> <code>subsequences</code></h3>
<p><code>subsequences</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = subsequences $x
# or in a pipeline:
@list |> map subsequences |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subset-construction">
<h3><a class="doc-anchor" href="#doc-subset-construction">#</a> <code>subset_construction</code></h3>
<p><code>subset_construction</code> — batch 68 builtin.</p>
<pre><code class="lang-perl">my $result = subset_construction $x
# or in a pipeline:
@list |> map subset_construction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-substitution-encrypt">
<h3><a class="doc-anchor" href="#doc-substitution-encrypt">#</a> <code>substitution_encrypt</code></h3>
<p><code>substitution_encrypt</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = substitution_encrypt $x
# or in a pipeline:
@list |> map substitution_encrypt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-substring">
<h3><a class="doc-anchor" href="#doc-substring">#</a> <code>substring</code></h3>
<p><code>substring</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = substring $x
# or in a pipeline:
@list |> map substring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-substring-count">
<h3><a class="doc-anchor" href="#doc-substring-count">#</a> <code>substring_count</code></h3>
<p><code>substring_count</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = substring_count $x
# or in a pipeline:
@list |> map substring_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-substring-similarity">
<h3><a class="doc-anchor" href="#doc-substring-similarity">#</a> <code>substring_similarity</code></h3>
<p><code>substring_similarity</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = substring_similarity $x
# or in a pipeline:
@list |> map substring_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subsumption-check">
<h3><a class="doc-anchor" href="#doc-subsumption-check">#</a> <code>subsumption_check</code></h3>
<p><code>subsumption_check</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = subsumption_check $x
# or in a pipeline:
@list |> map subsumption_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-succ">
<h3><a class="doc-anchor" href="#doc-succ">#</a> <code>succ</code></h3>
<p><code>succ</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = succ $x
# or in a pipeline:
@list |> map succ |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-suffix-array-naive">
<h3><a class="doc-anchor" href="#doc-suffix-array-naive">#</a> <code>suffix_array_naive</code></h3>
<p><code>suffix_array_naive</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = suffix_array_naive $x
# or in a pipeline:
@list |> map suffix_array_naive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-suffix-sums">
<h3><a class="doc-anchor" href="#doc-suffix-sums">#</a> <code>suffix_sums</code></h3>
<p><code>suffix_sums</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = suffix_sums $x
# or in a pipeline:
@list |> map suffix_sums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-by">
<h3><a class="doc-anchor" href="#doc-sum-by">#</a> <code>sum_by</code></h3>
<p><code>sum_by</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = sum_by $x
# or in a pipeline:
@list |> map sum_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-degrees">
<h3><a class="doc-anchor" href="#doc-sum-degrees">#</a> <code>sum_degrees</code></h3>
<p><code>sum_degrees</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = sum_degrees $x
# or in a pipeline:
@list |> map sum_degrees |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-divisors">
<h3><a class="doc-anchor" href="#doc-sum-divisors">#</a> <code>sum_divisors</code></h3>
<p><code>sum_divisors</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = sum_divisors $x
# or in a pipeline:
@list |> map sum_divisors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-list">
<h3><a class="doc-anchor" href="#doc-sum-list">#</a> <code>sum_list</code></h3>
<p><code>sum_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = sum_list $x
# or in a pipeline:
@list |> map sum_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-of">
<h3><a class="doc-anchor" href="#doc-sum-of">#</a> <code>sum_of</code></h3>
<p><code>sum_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = sum_of $x
# or in a pipeline:
@list |> map sum_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-squares">
<h3><a class="doc-anchor" href="#doc-sum-squares">#</a> <code>sum_squares</code></h3>
<p><code>sum_squares</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = sum_squares $x
# or in a pipeline:
@list |> map sum_squares |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-two-squares">
<h3><a class="doc-anchor" href="#doc-sum-two-squares">#</a> <code>sum_two_squares</code></h3>
<p><code>sum_two_squares</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = sum_two_squares $x
# or in a pipeline:
@list |> map sum_two_squares |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sumb">
<h3><a class="doc-anchor" href="#doc-sumb">#</a> <code>sumb</code></h3>
<p><code>sumb</code> — python/ruby stdlib builtin. Alias for <code>sum_by</code>.</p>
<pre><code class="lang-perl">my $result = sumb $x
# or in a pipeline:
@list |> map sumb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sumif">
<h3><a class="doc-anchor" href="#doc-sumif">#</a> <code>sumif</code></h3>
<p><code>sumif</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = sumif $x
# or in a pipeline:
@list |> map sumif |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sumifs">
<h3><a class="doc-anchor" href="#doc-sumifs">#</a> <code>sumifs</code></h3>
<p><code>sumifs</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = sumifs $x
# or in a pipeline:
@list |> map sumifs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sumproduct">
<h3><a class="doc-anchor" href="#doc-sumproduct">#</a> <code>sumproduct</code></h3>
<p><code>sumproduct</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = sumproduct $x
# or in a pipeline:
@list |> map sumproduct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sumsq">
<h3><a class="doc-anchor" href="#doc-sumsq">#</a> <code>sumsq</code></h3>
<p><code>sumsq</code> — extended stdlib builtin. Alias for <code>sum_squares</code>.</p>
<pre><code class="lang-perl">my $result = sumsq $x
# or in a pipeline:
@list |> map sumsq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sun-distance-au">
<h3><a class="doc-anchor" href="#doc-sun-distance-au">#</a> <code>sun_distance_au</code></h3>
<p><code>sun_distance_au</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = sun_distance_au $x
# or in a pipeline:
@list |> map sun_distance_au |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sun-position-low">
<h3><a class="doc-anchor" href="#doc-sun-position-low">#</a> <code>sun_position_low</code></h3>
<p><code>sun_position_low</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = sun_position_low $x
# or in a pipeline:
@list |> map sun_position_low |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sun-radius">
<h3><a class="doc-anchor" href="#doc-sun-radius">#</a> <code>sun_radius</code></h3>
<p><code>sun_radius</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = sun_radius $x
# or in a pipeline:
@list |> map sun_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sunion">
<h3><a class="doc-anchor" href="#doc-sunion">#</a> <code>sunion</code></h3>
<p><code>sunion</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = sunion $x
# or in a pipeline:
@list |> map sunion |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sunspot-relative-number">
<h3><a class="doc-anchor" href="#doc-sunspot-relative-number">#</a> <code>sunspot_relative_number</code></h3>
<p><code>sunspot_relative_number</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = sunspot_relative_number $x
# or in a pipeline:
@list |> map sunspot_relative_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sup">
<h3><a class="doc-anchor" href="#doc-sup">#</a> <code>sup</code></h3>
<p><code>sup</code> — encoding / phonetics builtin. Alias for <code>superscript</code>.</p>
<pre><code class="lang-perl">my $result = sup $x
# or in a pipeline:
@list |> map sup |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-superbee-limiter">
<h3><a class="doc-anchor" href="#doc-superbee-limiter">#</a> <code>superbee_limiter</code></h3>
<p><code>superbee_limiter</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = superbee_limiter $x
# or in a pipeline:
@list |> map superbee_limiter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-superdense-coding">
<h3><a class="doc-anchor" href="#doc-superdense-coding">#</a> <code>superdense_coding</code></h3>
<p><code>superdense_coding</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = superdense_coding $x
# or in a pipeline:
@list |> map superdense_coding |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-supergolden">
<h3><a class="doc-anchor" href="#doc-supergolden">#</a> <code>supergolden</code></h3>
<p><code>supergolden</code> — math constants builtin. Alias for <code>supergolden_ratio</code>.</p>
<pre><code class="lang-perl">my $result = supergolden $x
# or in a pipeline:
@list |> map supergolden |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-supergolden-ratio">
<h3><a class="doc-anchor" href="#doc-supergolden-ratio">#</a> <code>supergolden_ratio</code></h3>
<p><code>supergolden_ratio</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = supergolden_ratio $x
# or in a pipeline:
@list |> map supergolden_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-superscript">
<h3><a class="doc-anchor" href="#doc-superscript">#</a> <code>superscript</code></h3>
<p><code>superscript</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = superscript $x
# or in a pipeline:
@list |> map superscript |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-supply-elasticity">
<h3><a class="doc-anchor" href="#doc-supply-elasticity">#</a> <code>supply_elasticity</code></h3>
<p><code>supply_elasticity</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = supply_elasticity $x
# or in a pipeline:
@list |> map supply_elasticity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-surf-keypoints">
<h3><a class="doc-anchor" href="#doc-surf-keypoints">#</a> <code>surf_keypoints</code></h3>
<p><code>surf_keypoints</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = surf_keypoints $x
# or in a pipeline:
@list |> map surf_keypoints |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-surface-wave-ms">
<h3><a class="doc-anchor" href="#doc-surface-wave-ms">#</a> <code>surface_wave_ms</code></h3>
<p><code>surface_wave_ms</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = surface_wave_ms $x
# or in a pipeline:
@list |> map surface_wave_ms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-susceptible-to-infected">
<h3><a class="doc-anchor" href="#doc-susceptible-to-infected">#</a> <code>susceptible_to_infected</code></h3>
<p><code>susceptible_to_infected</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = susceptible_to_infected $input
</code></pre>
</article>
<article class="doc-entry" id="doc-sw">
<h3><a class="doc-anchor" href="#doc-sw">#</a> <code>sw</code></h3>
<p><code>sw</code> — trivial string ops builtin. Alias for <code>starts_with</code>.</p>
<pre><code class="lang-perl">my $result = sw $x
# or in a pipeline:
@list |> map sw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swamee-jain-factor">
<h3><a class="doc-anchor" href="#doc-swamee-jain-factor">#</a> <code>swamee_jain_factor</code></h3>
<p><code>swamee_jain_factor</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = swamee_jain_factor $x
# or in a pipeline:
@list |> map swamee_jain_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swampland-distance-check">
<h3><a class="doc-anchor" href="#doc-swampland-distance-check">#</a> <code>swampland_distance_check</code></h3>
<p><code>swampland_distance_check</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = swampland_distance_check $x
# or in a pipeline:
@list |> map swampland_distance_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-bits">
<h3><a class="doc-anchor" href="#doc-swap-bits">#</a> <code>swap_bits</code></h3>
<p><code>swap_bits</code> — batch 10 builtin. Alias for <code>swap_bits_pos</code>.</p>
<pre><code class="lang-perl">my $result = swap_bits $x
# or in a pipeline:
@list |> map swap_bits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-bits-pos">
<h3><a class="doc-anchor" href="#doc-swap-bits-pos">#</a> <code>swap_bits_pos</code></h3>
<p><code>swap_bits_pos</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = swap_bits_pos $x
# or in a pipeline:
@list |> map swap_bits_pos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-case">
<h3><a class="doc-anchor" href="#doc-swap-case">#</a> <code>swap_case</code></h3>
<p><code>swap_case</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = swap_case $x
# or in a pipeline:
@list |> map swap_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-free">
<h3><a class="doc-anchor" href="#doc-swap-free">#</a> <code>swap_free</code></h3>
<p><code>swap_free</code> — free swap space in bytes.</p>
<pre><code class="lang-perl">p format_bytes(swap_free)
my $pct = swap_total > 0 ? int(swap_free / swap_total * 100) : 100
p "$pct% swap free"
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-indices">
<h3><a class="doc-anchor" href="#doc-swap-indices">#</a> <code>swap_indices</code></h3>
<p><code>swap_indices</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = swap_indices $x
# or in a pipeline:
@list |> map swap_indices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-pairs">
<h3><a class="doc-anchor" href="#doc-swap-pairs">#</a> <code>swap_pairs</code></h3>
<p><code>swap_pairs</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = swap_pairs $x
# or in a pipeline:
@list |> map swap_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-total">
<h3><a class="doc-anchor" href="#doc-swap-total">#</a> <code>swap_total</code></h3>
<p><code>swap_total</code> — total swap space in bytes. Linux: <code>/proc/meminfo SwapTotal</code>. macOS: <code>vm.swapusage</code> sysctl. Returns 0 if swap is disabled, <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p swap_total # 8589934592
p format_bytes(swap_total) # 8.0 GiB
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-used">
<h3><a class="doc-anchor" href="#doc-swap-used">#</a> <code>swap_used</code></h3>
<p><code>swap_used</code> — used swap space in bytes (total - free).</p>
<pre><code class="lang-perl">p format_bytes(swap_used)
p "swap pressure" if swap_used > swap_total * 0.8
</code></pre>
</article>
<article class="doc-entry" id="doc-swave-velocity-depth">
<h3><a class="doc-anchor" href="#doc-swave-velocity-depth">#</a> <code>swave_velocity_depth</code></h3>
<p><code>swave_velocity_depth</code> — batch 65 builtin.</p>
<pre><code class="lang-perl">my $result = swave_velocity_depth $x
# or in a pipeline:
@list |> map swave_velocity_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swelling-strain-step">
<h3><a class="doc-anchor" href="#doc-swelling-strain-step">#</a> <code>swelling_strain_step</code></h3>
<p><code>swelling_strain_step</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = swelling_strain_step $x
# or in a pipeline:
@list |> map swelling_strain_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sym4-coeffs">
<h3><a class="doc-anchor" href="#doc-sym4-coeffs">#</a> <code>sym4_coeffs</code></h3>
<p><code>sym4_coeffs</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = sym4_coeffs $x
# or in a pipeline:
@list |> map sym4_coeffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sym-check">
<h3><a class="doc-anchor" href="#doc-sym-check">#</a> <code>sym_check</code></h3>
<p><code>sym_check</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = sym_check $x
# or in a pipeline:
@list |> map sym_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sym-links">
<h3><a class="doc-anchor" href="#doc-sym-links">#</a> <code>sym_links</code></h3>
<p><code>sym_links</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = sym_links $x
# or in a pipeline:
@list |> map sym_links |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-symmetric-diff">
<h3><a class="doc-anchor" href="#doc-symmetric-diff">#</a> <code>symmetric_diff</code></h3>
<p><code>symmetric_diff</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = symmetric_diff $x
# or in a pipeline:
@list |> map symmetric_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-symplectic-euler-step">
<h3><a class="doc-anchor" href="#doc-symplectic-euler-step">#</a> <code>symplectic_euler_step</code></h3>
<p><code>symplectic_euler_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = symplectic_euler_step $x
# or in a pipeline:
@list |> map symplectic_euler_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-synge-world-function">
<h3><a class="doc-anchor" href="#doc-synge-world-function">#</a> <code>synge_world_function</code></h3>
<p><code>synge_world_function</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = synge_world_function $x
# or in a pipeline:
@list |> map synge_world_function |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-synodic-period">
<h3><a class="doc-anchor" href="#doc-synodic-period">#</a> <code>synodic_period</code></h3>
<p><code>synodic_period</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = synodic_period $x
# or in a pipeline:
@list |> map synodic_period |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sys-uptime">
<h3><a class="doc-anchor" href="#doc-sys-uptime">#</a> <code>sys_uptime</code></h3>
<p><code>sys_uptime</code> — system uptime in seconds (float). On Linux reads <code>/proc/uptime</code>. On macOS uses <code>kern.boottime</code> sysctl. This is the wall-clock uptime of the machine, not the stryke process (see <code>uptime_secs</code> for process uptime).</p>
<pre><code class="lang-perl">p sys_uptime # 147951.5
my $days = int(sys_uptime / 86400)
p "up $days days"
</code></pre>
</article>
<article class="doc-entry" id="doc-t1ha">
<h3><a class="doc-anchor" href="#doc-t1ha">#</a> <code>t1ha</code></h3>
<p><code>t1ha</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = t1ha $x
# or in a pipeline:
@list |> map t1ha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-t-test-one-sample">
<h3><a class="doc-anchor" href="#doc-t-test-one-sample">#</a> <code>t_test_one_sample</code></h3>
<p><code>t_test_one_sample($mu, @sample)</code> (alias <code>ttest1</code>) — performs a one-sample t-test comparing a sample mean against a hypothesized population mean mu. Returns [t_statistic, degrees_of_freedom]. Use t-distribution tables for p-value lookup.</p>
<pre><code class="lang-perl">my @sample = (5.1, 4.9, 5.2, 5.0, 4.8)
my $result = ttest1(5.0, @sample)
p "t=$result->[0] df=$result->[1]"
</code></pre>
</article>
<article class="doc-entry" id="doc-t-test-two-sample">
<h3><a class="doc-anchor" href="#doc-t-test-two-sample">#</a> <code>t_test_two_sample</code></h3>
<p><code>t_test_two_sample(\@a, \@b)</code> (alias <code>ttest2</code>) — performs an independent two-sample t-test comparing means of two samples. Assumes equal variances. Returns [t_statistic, degrees_of_freedom].</p>
<pre><code class="lang-perl">my @a = (5.1, 5.3, 4.9)
my @b = (4.2, 4.5, 4.1)
my $r = ttest2(\@a, \@b)
p "t=$r->[0] df=$r->[1]"
</code></pre>
</article>
<article class="doc-entry" id="doc-tableau-branch-close">
<h3><a class="doc-anchor" href="#doc-tableau-branch-close">#</a> <code>tableau_branch_close</code></h3>
<p><code>tableau_branch_close</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = tableau_branch_close $x
# or in a pipeline:
@list |> map tableau_branch_close |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tabu-search-move-score">
<h3><a class="doc-anchor" href="#doc-tabu-search-move-score">#</a> <code>tabu_search_move_score</code></h3>
<p><code>tabu_search_move_score</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = tabu_search_move_score $x
# or in a pipeline:
@list |> map tabu_search_move_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tabulate">
<h3><a class="doc-anchor" href="#doc-tabulate">#</a> <code>tabulate</code></h3>
<p><code>tabulate</code> — frequency table of values. Returns hash of value => count. Like R's table().</p>
<pre><code class="lang-perl">my %t = %{tabulate([qw(a b a c b a)])}
p $t{a} # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-tackle-efficiency">
<h3><a class="doc-anchor" href="#doc-tackle-efficiency">#</a> <code>tackle_efficiency</code></h3>
<p><code>tackle_efficiency</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = tackle_efficiency $x
# or in a pipeline:
@list |> map tackle_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tafel-anodic-current">
<h3><a class="doc-anchor" href="#doc-tafel-anodic-current">#</a> <code>tafel_anodic_current</code></h3>
<p><code>tafel_anodic_current</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = tafel_anodic_current $x
# or in a pipeline:
@list |> map tafel_anodic_current |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tafel-cathodic-current">
<h3><a class="doc-anchor" href="#doc-tafel-cathodic-current">#</a> <code>tafel_cathodic_current</code></h3>
<p><code>tafel_cathodic_current</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = tafel_cathodic_current $x
# or in a pipeline:
@list |> map tafel_cathodic_current |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tail-lines">
<h3><a class="doc-anchor" href="#doc-tail-lines">#</a> <code>tail_lines</code></h3>
<p><code>tail_lines</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = tail_lines $x
# or in a pipeline:
@list |> map tail_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tail-n">
<h3><a class="doc-anchor" href="#doc-tail-n">#</a> <code>tail_n</code></h3>
<p><code>tail_n</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = tail_n $x
# or in a pipeline:
@list |> map tail_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tail-str">
<h3><a class="doc-anchor" href="#doc-tail-str">#</a> <code>tail_str</code></h3>
<p><code>tail_str</code> — string (batch 2) builtin. Alias for <code>right_str</code>.</p>
<pre><code class="lang-perl">my $result = tail_str $x
# or in a pipeline:
@list |> map tail_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tails">
<h3><a class="doc-anchor" href="#doc-tails">#</a> <code>tails</code></h3>
<p><code>tails</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = tails $x
# or in a pipeline:
@list |> map tails |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tajimas-d">
<h3><a class="doc-anchor" href="#doc-tajimas-d">#</a> <code>tajimas_d</code></h3>
<p><code>tajimas_d</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = tajimas_d $x
# or in a pipeline:
@list |> map tajimas_d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-take-every">
<h3><a class="doc-anchor" href="#doc-take-every">#</a> <code>take_every</code></h3>
<p><code>take_every</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = take_every $x
# or in a pipeline:
@list |> map take_every |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-take-last">
<h3><a class="doc-anchor" href="#doc-take-last">#</a> <code>take_last</code></h3>
<p><code>take_last</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = take_last $x
# or in a pipeline:
@list |> map take_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-take-n">
<h3><a class="doc-anchor" href="#doc-take-n">#</a> <code>take_n</code></h3>
<p><code>take_n</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = take_n $x
# or in a pipeline:
@list |> map take_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-talb">
<h3><a class="doc-anchor" href="#doc-talb">#</a> <code>talb</code></h3>
<p><code>talb</code> — ruby enumerable extras builtin. Alias for <code>tally_by</code>.</p>
<pre><code class="lang-perl">my $result = talb $x
# or in a pipeline:
@list |> map talb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tally-by">
<h3><a class="doc-anchor" href="#doc-tally-by">#</a> <code>tally_by</code></h3>
<p><code>tally_by</code> — ruby enumerable extras builtin.</p>
<pre><code class="lang-perl">my $result = tally_by $x
# or in a pipeline:
@list |> map tally_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tan">
<h3><a class="doc-anchor" href="#doc-tan">#</a> <code>tan</code></h3>
<p><code>tan</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = tan $x
# or in a pipeline:
@list |> map tan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tanh">
<h3><a class="doc-anchor" href="#doc-tanh">#</a> <code>tanh</code></h3>
<p><code>tanh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = tanh $x
# or in a pipeline:
@list |> map tanh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tanh-grad">
<h3><a class="doc-anchor" href="#doc-tanh-grad">#</a> <code>tanh_grad</code></h3>
<p><code>tanh_grad</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = tanh_grad $x
# or in a pipeline:
@list |> map tanh_grad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tanimoto-bits">
<h3><a class="doc-anchor" href="#doc-tanimoto-bits">#</a> <code>tanimoto_bits</code></h3>
<p><code>tanimoto_bits</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = tanimoto_bits $input
</code></pre>
</article>
<article class="doc-entry" id="doc-tap-debug">
<h3><a class="doc-anchor" href="#doc-tap-debug">#</a> <code>tap_debug</code></h3>
<p><code>tap_debug</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = tap_debug $x
# or in a pipeline:
@list |> map tap_debug |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tap-val">
<h3><a class="doc-anchor" href="#doc-tap-val">#</a> <code>tap_val</code></h3>
<p><code>tap_val</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = tap_val $x
# or in a pipeline:
@list |> map tap_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tapply">
<h3><a class="doc-anchor" href="#doc-tapply">#</a> <code>tapply</code></h3>
<p><code>tapply</code> — apply a function by group. Takes data, group labels, and function. Returns hash. Like R's tapply().</p>
<pre><code class="lang-perl">my %means = %{tapply([1,2,3,4], ["a","a","b","b"], fn { avg(@{$_[0]}) })}
p $means{a} # 1.5
p $means{b} # 3.5
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-header-checksum">
<h3><a class="doc-anchor" href="#doc-tar-header-checksum">#</a> <code>tar_header_checksum</code></h3>
<p><code>tar_header_checksum</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = tar_header_checksum $x
# or in a pipeline:
@list |> map tar_header_checksum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-member-record">
<h3><a class="doc-anchor" href="#doc-tar-member-record">#</a> <code>tar_member_record</code></h3>
<p><code>tar_member_record</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = tar_member_record $x
# or in a pipeline:
@list |> map tar_member_record |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-pad-512">
<h3><a class="doc-anchor" href="#doc-tar-pad-512">#</a> <code>tar_pad_512</code></h3>
<p><code>tar_pad_512</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = tar_pad_512 $x
# or in a pipeline:
@list |> map tar_pad_512 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-target-heart-rate">
<h3><a class="doc-anchor" href="#doc-target-heart-rate">#</a> <code>target_heart_rate</code></h3>
<p><code>target_heart_rate</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = target_heart_rate $x
# or in a pipeline:
@list |> map target_heart_rate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tarjan-scc-step">
<h3><a class="doc-anchor" href="#doc-tarjan-scc-step">#</a> <code>tarjan_scc_step</code></h3>
<p><code>tarjan_scc_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = tarjan_scc_step $x
# or in a pipeline:
@list |> map tarjan_scc_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tau">
<h3><a class="doc-anchor" href="#doc-tau">#</a> <code>tau</code></h3>
<p><code>tau</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = tau $x
# or in a pipeline:
@list |> map tau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tax">
<h3><a class="doc-anchor" href="#doc-tax">#</a> <code>tax</code></h3>
<p><code>tax</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = tax $x
# or in a pipeline:
@list |> map tax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tax-amount">
<h3><a class="doc-anchor" href="#doc-tax-amount">#</a> <code>tax_amount</code></h3>
<p><code>tax_amount</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = tax_amount $x
# or in a pipeline:
@list |> map tax_amount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tax-incidence">
<h3><a class="doc-anchor" href="#doc-tax-incidence">#</a> <code>tax_incidence</code></h3>
<p><code>tax_incidence</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = tax_incidence $x
# or in a pipeline:
@list |> map tax_incidence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-taylor-diagram-score">
<h3><a class="doc-anchor" href="#doc-taylor-diagram-score">#</a> <code>taylor_diagram_score</code></h3>
<p><code>taylor_diagram_score</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = taylor_diagram_score $x
# or in a pipeline:
@list |> map taylor_diagram_score |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-taylor-microscale-step">
<h3><a class="doc-anchor" href="#doc-taylor-microscale-step">#</a> <code>taylor_microscale_step</code></h3>
<p><code>taylor_microscale_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = taylor_microscale_step $x
# or in a pipeline:
@list |> map taylor_microscale_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-taylor-window">
<h3><a class="doc-anchor" href="#doc-taylor-window">#</a> <code>taylor_window</code></h3>
<p><code>taylor_window</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = taylor_window $x
# or in a pipeline:
@list |> map taylor_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tcrossprod">
<h3><a class="doc-anchor" href="#doc-tcrossprod">#</a> <code>tcrossprod</code></h3>
<p><code>tcrossprod</code> — M * t(M) (R's tcrossprod).</p>
<pre><code class="lang-perl">my $aat = tcrossprod([[1,2],[3,4]]) # [[5,11],[11,25]]
</code></pre>
</article>
<article class="doc-entry" id="doc-td">
<h3><a class="doc-anchor" href="#doc-td">#</a> <code>td</code></h3>
<p><code>td</code> — serialization (stryke-only encoders) builtin. Alias for <code>toml_decode</code>.</p>
<pre><code class="lang-perl">my $result = td $x
# or in a pipeline:
@list |> map td |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-td-lambda-update">
<h3><a class="doc-anchor" href="#doc-td-lambda-update">#</a> <code>td_lambda_update</code></h3>
<p><code>td_lambda_update</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = td_lambda_update $x
# or in a pipeline:
@list |> map td_lambda_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-td-zero-update">
<h3><a class="doc-anchor" href="#doc-td-zero-update">#</a> <code>td_zero_update</code></h3>
<p><code>td_zero_update</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = td_zero_update $x
# or in a pipeline:
@list |> map td_zero_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tdilate">
<h3><a class="doc-anchor" href="#doc-tdilate">#</a> <code>tdilate</code></h3>
<p><code>time_dilation($proper_time, $velocity)</code> (alias <code>tdilate</code>) — dilated time Δt = Δt₀ × γ. Time appears to slow for moving objects.</p>
<pre><code class="lang-perl">p tdilate(1, 0.99 * 3e8) # ~7.09 s (1 second at 99% c)
</code></pre>
</article>
<article class="doc-entry" id="doc-te">
<h3><a class="doc-anchor" href="#doc-te">#</a> <code>te</code></h3>
<p><code>te</code> — serialization (stryke-only encoders) builtin. Alias for <code>toml_encode</code>.</p>
<pre><code class="lang-perl">my $result = te $x
# or in a pipeline:
@list |> map te |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tee-iter">
<h3><a class="doc-anchor" href="#doc-tee-iter">#</a> <code>tee_iter</code></h3>
<p><code>tee_iter</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = tee_iter $x
# or in a pipeline:
@list |> map tee_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-teei">
<h3><a class="doc-anchor" href="#doc-teei">#</a> <code>teei</code></h3>
<p><code>teei</code> — python/ruby stdlib builtin. Alias for <code>tee_iter</code>.</p>
<pre><code class="lang-perl">my $result = teei $x
# or in a pipeline:
@list |> map teei |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-temp-dir">
<h3><a class="doc-anchor" href="#doc-temp-dir">#</a> <code>temp_dir</code></h3>
<p><code>temp_dir</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = temp_dir $x
# or in a pipeline:
@list |> map temp_dir |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-template-match">
<h3><a class="doc-anchor" href="#doc-template-match">#</a> <code>template_match</code></h3>
<p><code>template_match</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = template_match $x
# or in a pipeline:
@list |> map template_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tempo-to-ms">
<h3><a class="doc-anchor" href="#doc-tempo-to-ms">#</a> <code>tempo_to_ms</code></h3>
<p><code>tempo_to_ms</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = tempo_to_ms $input
</code></pre>
</article>
<article class="doc-entry" id="doc-tempplanck">
<h3><a class="doc-anchor" href="#doc-tempplanck">#</a> <code>tempplanck</code></h3>
<p><code>tempplanck</code> — physics constants builtin. Alias for <code>planck_temperature</code>.</p>
<pre><code class="lang-perl">my $result = tempplanck $x
# or in a pipeline:
@list |> map tempplanck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tensor-antisymmetrize-two">
<h3><a class="doc-anchor" href="#doc-tensor-antisymmetrize-two">#</a> <code>tensor_antisymmetrize_two</code></h3>
<p><code>tensor_antisymmetrize_two</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = tensor_antisymmetrize_two $x
# or in a pipeline:
@list |> map tensor_antisymmetrize_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tensor-contract-two">
<h3><a class="doc-anchor" href="#doc-tensor-contract-two">#</a> <code>tensor_contract_two</code></h3>
<p><code>tensor_contract_two</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = tensor_contract_two $x
# or in a pipeline:
@list |> map tensor_contract_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tensor-outer-two">
<h3><a class="doc-anchor" href="#doc-tensor-outer-two">#</a> <code>tensor_outer_two</code></h3>
<p><code>tensor_outer_two</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = tensor_outer_two $x
# or in a pipeline:
@list |> map tensor_outer_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tensor-symmetrize-two">
<h3><a class="doc-anchor" href="#doc-tensor-symmetrize-two">#</a> <code>tensor_symmetrize_two</code></h3>
<p><code>tensor_symmetrize_two</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = tensor_symmetrize_two $x
# or in a pipeline:
@list |> map tensor_symmetrize_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tensor-trace-index">
<h3><a class="doc-anchor" href="#doc-tensor-trace-index">#</a> <code>tensor_trace_index</code></h3>
<p><code>tensor_trace_index</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = tensor_trace_index $x
# or in a pipeline:
@list |> map tensor_trace_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-term-life-a-n-t">
<h3><a class="doc-anchor" href="#doc-term-life-a-n-t">#</a> <code>term_life_a_n_t</code></h3>
<p><code>term_life_a_n_t</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = term_life_a_n_t $x
# or in a pipeline:
@list |> map term_life_a_n_t |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-terminal-velocity">
<h3><a class="doc-anchor" href="#doc-terminal-velocity">#</a> <code>terminal_velocity</code></h3>
<p><code>terminal_velocity</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = terminal_velocity $x
# or in a pipeline:
@list |> map terminal_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-test-skip">
<h3><a class="doc-anchor" href="#doc-test-skip">#</a> <code>test_skip</code></h3>
<p><code>test_skip</code> — testing framework builtin.</p>
<pre><code class="lang-perl">my $result = test_skip $x
# or in a pipeline:
@list |> map test_skip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tetrahedral-number">
<h3><a class="doc-anchor" href="#doc-tetrahedral-number">#</a> <code>tetrahedral_number</code></h3>
<p><code>tetrahedral_number</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = tetrahedral_number $x
# or in a pipeline:
@list |> map tetrahedral_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-after">
<h3><a class="doc-anchor" href="#doc-text-after">#</a> <code>text_after</code></h3>
<p><code>text_after</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_after $x
# or in a pipeline:
@list |> map text_after |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-after-last">
<h3><a class="doc-anchor" href="#doc-text-after-last">#</a> <code>text_after_last</code></h3>
<p><code>text_after_last</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_after_last $x
# or in a pipeline:
@list |> map text_after_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-before">
<h3><a class="doc-anchor" href="#doc-text-before">#</a> <code>text_before</code></h3>
<p><code>text_before</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_before $x
# or in a pipeline:
@list |> map text_before |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-before-last">
<h3><a class="doc-anchor" href="#doc-text-before-last">#</a> <code>text_before_last</code></h3>
<p><code>text_before_last</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_before_last $x
# or in a pipeline:
@list |> map text_before_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-between">
<h3><a class="doc-anchor" href="#doc-text-between">#</a> <code>text_between</code></h3>
<p><code>text_between</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_between $x
# or in a pipeline:
@list |> map text_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tf2sos-step">
<h3><a class="doc-anchor" href="#doc-tf2sos-step">#</a> <code>tf2sos_step</code></h3>
<p><code>tf2sos_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = tf2sos_step $x
# or in a pipeline:
@list |> map tf2sos_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tf2zpk-step">
<h3><a class="doc-anchor" href="#doc-tf2zpk-step">#</a> <code>tf2zpk_step</code></h3>
<p><code>tf2zpk_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = tf2zpk_step $x
# or in a pipeline:
@list |> map tf2zpk_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tfld">
<h3><a class="doc-anchor" href="#doc-tfld">#</a> <code>tfld</code></h3>
<p><code>tfld</code> — rust iterator methods builtin. Alias for <code>try_fold</code>.</p>
<pre><code class="lang-perl">my $result = tfld $x
# or in a pipeline:
@list |> map tfld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-theil-sen-slope">
<h3><a class="doc-anchor" href="#doc-theil-sen-slope">#</a> <code>theil_sen_slope</code></h3>
<p><code>theil_sen_slope</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = theil_sen_slope $x
# or in a pipeline:
@list |> map theil_sen_slope |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-then-fn">
<h3><a class="doc-anchor" href="#doc-then-fn">#</a> <code>then_fn</code></h3>
<p><code>then_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = then_fn $x
# or in a pipeline:
@list |> map then_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thermal-mean-photons">
<h3><a class="doc-anchor" href="#doc-thermal-mean-photons">#</a> <code>thermal_mean_photons</code></h3>
<p><code>thermal_mean_photons</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = thermal_mean_photons $x
# or in a pipeline:
@list |> map thermal_mean_photons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thermal-runaway-threshold">
<h3><a class="doc-anchor" href="#doc-thermal-runaway-threshold">#</a> <code>thermal_runaway_threshold</code></h3>
<p><code>thermal_runaway_threshold</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = thermal_runaway_threshold $x
# or in a pipeline:
@list |> map thermal_runaway_threshold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thermal-wind-step">
<h3><a class="doc-anchor" href="#doc-thermal-wind-step">#</a> <code>thermal_wind_step</code></h3>
<p><code>thermal_wind_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = thermal_wind_step $x
# or in a pipeline:
@list |> map thermal_wind_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-theta2">
<h3><a class="doc-anchor" href="#doc-theta2">#</a> <code>theta2</code></h3>
<p><code>theta2</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = theta2 $x
# or in a pipeline:
@list |> map theta2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-theta3">
<h3><a class="doc-anchor" href="#doc-theta3">#</a> <code>theta3</code></h3>
<p><code>theta3</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = theta3 $x
# or in a pipeline:
@list |> map theta3 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thfn">
<h3><a class="doc-anchor" href="#doc-thfn">#</a> <code>thfn</code></h3>
<p><code>thfn</code> — python/ruby stdlib builtin. Alias for <code>then_fn</code>.</p>
<pre><code class="lang-perl">my $result = thfn $x
# or in a pipeline:
@list |> map thfn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thin-lens">
<h3><a class="doc-anchor" href="#doc-thin-lens">#</a> <code>thin_lens</code></h3>
<p><code>thin_lens($object_dist, $focal_length)</code> (alias <code>thinlens</code>) — image distance using 1/f = 1/do + 1/di.</p>
<pre><code class="lang-perl">p thinlens(30, 20) # 60 cm (real image)
p thinlens(10, 20) # -20 cm (virtual image)
</code></pre>
</article>
<article class="doc-entry" id="doc-thin-lens-v">
<h3><a class="doc-anchor" href="#doc-thin-lens-v">#</a> <code>thin_lens_v</code></h3>
<p><code>thin_lens_v</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = thin_lens_v $x
# or in a pipeline:
@list |> map thin_lens_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-third-elem">
<h3><a class="doc-anchor" href="#doc-third-elem">#</a> <code>third_elem</code></h3>
<p><code>third_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = third_elem $x
# or in a pipeline:
@list |> map third_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thompson-sample-beta">
<h3><a class="doc-anchor" href="#doc-thompson-sample-beta">#</a> <code>thompson_sample_beta</code></h3>
<p><code>thompson_sample_beta</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = thompson_sample_beta $x
# or in a pipeline:
@list |> map thompson_sample_beta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-three-opt-delta">
<h3><a class="doc-anchor" href="#doc-three-opt-delta">#</a> <code>three_opt_delta</code></h3>
<p><code>three_opt_delta</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = three_opt_delta $x
# or in a pipeline:
@list |> map three_opt_delta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-threshold-act">
<h3><a class="doc-anchor" href="#doc-threshold-act">#</a> <code>threshold_act</code></h3>
<p><code>threshold_act</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = threshold_act $x
# or in a pipeline:
@list |> map threshold_act |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-threshold-hard-value">
<h3><a class="doc-anchor" href="#doc-threshold-hard-value">#</a> <code>threshold_hard_value</code></h3>
<p><code>threshold_hard_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = threshold_hard_value $x
# or in a pipeline:
@list |> map threshold_hard_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-threshold-soft-value">
<h3><a class="doc-anchor" href="#doc-threshold-soft-value">#</a> <code>threshold_soft_value</code></h3>
<p><code>threshold_soft_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = threshold_soft_value $x
# or in a pipeline:
@list |> map threshold_soft_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thue-morse-string">
<h3><a class="doc-anchor" href="#doc-thue-morse-string">#</a> <code>thue_morse_string</code></h3>
<p><code>thue_morse_string</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = thue_morse_string $x
# or in a pipeline:
@list |> map thue_morse_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ti2">
<h3><a class="doc-anchor" href="#doc-ti2">#</a> <code>ti2</code></h3>
<p><code>ti2</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = ti2 $x
# or in a pipeline:
@list |> map ti2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tidal-force">
<h3><a class="doc-anchor" href="#doc-tidal-force">#</a> <code>tidal_force</code></h3>
<p><code>tidal_force</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = tidal_force $x
# or in a pipeline:
@list |> map tidal_force |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tied">
<h3><a class="doc-anchor" href="#doc-tied">#</a> <code>tied</code></h3>
<p><code>tied</code> — type / reflection builtin.</p>
<pre><code class="lang-perl">my $result = tied $x
# or in a pipeline:
@list |> map tied |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tile-xyz-to-lat-lng">
<h3><a class="doc-anchor" href="#doc-tile-xyz-to-lat-lng">#</a> <code>tile_xyz_to_lat_lng</code></h3>
<p><code>tile_xyz_to_lat_lng</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = tile_xyz_to_lat_lng $input
</code></pre>
</article>
<article class="doc-entry" id="doc-time-sig-subdivision">
<h3><a class="doc-anchor" href="#doc-time-sig-subdivision">#</a> <code>time_sig_subdivision</code></h3>
<p><code>time_sig_subdivision</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = time_sig_subdivision $x
# or in a pipeline:
@list |> map time_sig_subdivision |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-times-fn">
<h3><a class="doc-anchor" href="#doc-times-fn">#</a> <code>times_fn</code></h3>
<p><code>times_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = times_fn $x
# or in a pipeline:
@list |> map times_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-timf">
<h3><a class="doc-anchor" href="#doc-timf">#</a> <code>timf</code></h3>
<p><code>timf</code> — python/ruby stdlib builtin. Alias for <code>times_fn</code>.</p>
<pre><code class="lang-perl">my $result = timf $x
# or in a pipeline:
@list |> map timf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tip">
<h3><a class="doc-anchor" href="#doc-tip">#</a> <code>tip</code></h3>
<p><code>tip</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = tip $x
# or in a pipeline:
@list |> map tip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tip-amount">
<h3><a class="doc-anchor" href="#doc-tip-amount">#</a> <code>tip_amount</code></h3>
<p><code>tip_amount</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = tip_amount $x
# or in a pipeline:
@list |> map tip_amount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tisserand-param">
<h3><a class="doc-anchor" href="#doc-tisserand-param">#</a> <code>tisserand_param</code></h3>
<p><code>tisserand_param</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = tisserand_param $x
# or in a pipeline:
@list |> map tisserand_param |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tit-for-tat-step">
<h3><a class="doc-anchor" href="#doc-tit-for-tat-step">#</a> <code>tit_for_tat_step</code></h3>
<p><code>tit_for_tat_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = tit_for_tat_step $x
# or in a pipeline:
@list |> map tit_for_tat_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-title">
<h3><a class="doc-anchor" href="#doc-title">#</a> <code>title</code></h3>
<p><code>title</code> — trivial string ops builtin. Alias for <code>title_case</code>.</p>
<pre><code class="lang-perl">my $result = title $x
# or in a pipeline:
@list |> map title |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-title-case">
<h3><a class="doc-anchor" href="#doc-title-case">#</a> <code>title_case</code></h3>
<p><code>title_case</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = title_case $x
# or in a pipeline:
@list |> map title_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-title-words">
<h3><a class="doc-anchor" href="#doc-title-words">#</a> <code>title_words</code></h3>
<p><code>title_words</code> — batch 9 builtin. Alias for <code>capitalize_words</code>.</p>
<pre><code class="lang-perl">my $result = title_words $x
# or in a pipeline:
@list |> map title_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-titration-endpoint-index">
<h3><a class="doc-anchor" href="#doc-titration-endpoint-index">#</a> <code>titration_endpoint_index</code></h3>
<p><code>titration_endpoint_index</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = titration_endpoint_index $x
# or in a pipeline:
@list |> map titration_endpoint_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-titration-ph-endpoint">
<h3><a class="doc-anchor" href="#doc-titration-ph-endpoint">#</a> <code>titration_ph_endpoint</code></h3>
<p><code>titration_ph_endpoint</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = titration_ph_endpoint $x
# or in a pipeline:
@list |> map titration_ph_endpoint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-titration-volume">
<h3><a class="doc-anchor" href="#doc-titration-volume">#</a> <code>titration_volume</code></h3>
<p><code>titration_volume</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = titration_volume $x
# or in a pipeline:
@list |> map titration_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tkeys">
<h3><a class="doc-anchor" href="#doc-tkeys">#</a> <code>tkeys</code></h3>
<p><code>tkeys</code> — python/ruby stdlib builtin. Alias for <code>transform_keys</code>.</p>
<pre><code class="lang-perl">my $result = tkeys $x
# or in a pipeline:
@list |> map tkeys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tle-mean-motion">
<h3><a class="doc-anchor" href="#doc-tle-mean-motion">#</a> <code>tle_mean_motion</code></h3>
<p><code>tle_mean_motion</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = tle_mean_motion $x
# or in a pipeline:
@list |> map tle_mean_motion |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tm-marmur">
<h3><a class="doc-anchor" href="#doc-tm-marmur">#</a> <code>tm_marmur</code></h3>
<p><code>tm_marmur</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = tm_marmur $x
# or in a pipeline:
@list |> map tm_marmur |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tm-wallace">
<h3><a class="doc-anchor" href="#doc-tm-wallace">#</a> <code>tm_wallace</code></h3>
<p><code>tm_wallace</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = tm_wallace $x
# or in a pipeline:
@list |> map tm_wallace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-to-array">
<h3><a class="doc-anchor" href="#doc-to-array">#</a> <code>to_array</code></h3>
<p><code>to_array</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_array $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-ascii">
<h3><a class="doc-anchor" href="#doc-to-ascii">#</a> <code>to_ascii</code></h3>
<p><code>to_ascii</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = to_ascii $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-base">
<h3><a class="doc-anchor" href="#doc-to-base">#</a> <code>to_base</code></h3>
<p><code>to_base</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = to_base $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-bin">
<h3><a class="doc-anchor" href="#doc-to-bin">#</a> <code>to_bin</code></h3>
<p><code>to_bin</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = to_bin $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-bool">
<h3><a class="doc-anchor" href="#doc-to-bool">#</a> <code>to_bool</code></h3>
<p><code>to_bool</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_bool $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-csv-line">
<h3><a class="doc-anchor" href="#doc-to-csv-line">#</a> <code>to_csv_line</code></h3>
<p><code>to_csv_line</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_csv_line $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-emoji-num">
<h3><a class="doc-anchor" href="#doc-to-emoji-num">#</a> <code>to_emoji_num</code></h3>
<p><code>to_emoji_num</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = to_emoji_num $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-float">
<h3><a class="doc-anchor" href="#doc-to-float">#</a> <code>to_float</code></h3>
<p><code>to_float</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_float $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-float-each">
<h3><a class="doc-anchor" href="#doc-to-float-each">#</a> <code>to_float_each</code></h3>
<p><code>to_float_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_float_each $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-hash">
<h3><a class="doc-anchor" href="#doc-to-hash">#</a> <code>to_hash</code></h3>
<p><code>to_hash LIST</code> — collect a flat list of key-value pairs into a Perl hash.</p>
<p>The list is consumed two elements at a time: odd-positioned elements become keys and even-positioned elements become values. If there is an odd number of elements, the last key maps to <code>undef</code>. This is a terminal operation that materializes the full stream. Useful for converting pipeline output into a lookup table.</p>
<pre><code class="lang-perl">my %h = qw(a 1 b 2) |> to_hash
@pairs |> to_hash
my %freq = @words |> map { _, 1 } |> to_hash
</code></pre>
</article>
<article class="doc-entry" id="doc-to-hex">
<h3><a class="doc-anchor" href="#doc-to-hex">#</a> <code>to_hex</code></h3>
<p><code>to_hex</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = to_hex $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-int">
<h3><a class="doc-anchor" href="#doc-to-int">#</a> <code>to_int</code></h3>
<p><code>to_int</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_int $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-int-each">
<h3><a class="doc-anchor" href="#doc-to-int-each">#</a> <code>to_int_each</code></h3>
<p><code>to_int_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_int_each $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-oct">
<h3><a class="doc-anchor" href="#doc-to-oct">#</a> <code>to_oct</code></h3>
<p><code>to_oct</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = to_oct $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-pairs">
<h3><a class="doc-anchor" href="#doc-to-pairs">#</a> <code>to_pairs</code></h3>
<p><code>to_pairs</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_pairs $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-reversed">
<h3><a class="doc-anchor" href="#doc-to-reversed">#</a> <code>to_reversed</code></h3>
<p><code>to_reversed</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = to_reversed $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-set">
<h3><a class="doc-anchor" href="#doc-to-set">#</a> <code>to_set</code></h3>
<p><code>to_set LIST</code> — collect a list or iterator into a <code>set</code> object with O(1) membership testing.</p>
<p>The resulting set contains only unique elements (duplicates are discarded). This is a terminal operation that materializes the full stream. The returned set supports <code>->contains($val)</code>, <code>->union($other)</code>, <code>->intersection($other)</code>, and <code>->difference($other)</code>. Use this when you need fast repeated lookups against a collection of values.</p>
<pre><code class="lang-perl">my $s = 1:5 |> to_set
@words |> to_set # deduplicated set
my $allowed = to_set @whitelist
p $allowed->contains("foo")
</code></pre>
</article>
<article class="doc-entry" id="doc-to-sorted">
<h3><a class="doc-anchor" href="#doc-to-sorted">#</a> <code>to_sorted</code></h3>
<p><code>to_sorted</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = to_sorted $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-spliced">
<h3><a class="doc-anchor" href="#doc-to-spliced">#</a> <code>to_spliced</code></h3>
<p><code>to_spliced</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = to_spliced $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-string">
<h3><a class="doc-anchor" href="#doc-to-string">#</a> <code>to_string</code></h3>
<p><code>to_string</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_string $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-string-val">
<h3><a class="doc-anchor" href="#doc-to-string-val">#</a> <code>to_string_val</code></h3>
<p><code>to_string_val</code> — misc / utility builtin.</p>
<pre><code class="lang-perl">my $result = to_string_val $input
</code></pre>
</article>
<article class="doc-entry" id="doc-toasc">
<h3><a class="doc-anchor" href="#doc-toasc">#</a> <code>toasc</code></h3>
<p><code>toasc</code> — extended stdlib builtin. Alias for <code>to_ascii</code>.</p>
<pre><code class="lang-perl">my $result = toasc $x
# or in a pipeline:
@list |> map toasc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tobit-log-likelihood">
<h3><a class="doc-anchor" href="#doc-tobit-log-likelihood">#</a> <code>tobit_log_likelihood</code></h3>
<p><code>tobit_log_likelihood</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = tobit_log_likelihood $x
# or in a pipeline:
@list |> map tobit_log_likelihood |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-today">
<h3><a class="doc-anchor" href="#doc-today">#</a> <code>today</code></h3>
<p><code>today</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = today $x
# or in a pipeline:
@list |> map today |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-todd-genus-eval">
<h3><a class="doc-anchor" href="#doc-todd-genus-eval">#</a> <code>todd_genus_eval</code></h3>
<p><code>todd_genus_eval</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = todd_genus_eval $x
# or in a pipeline:
@list |> map todd_genus_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-toffoli-gate">
<h3><a class="doc-anchor" href="#doc-toffoli-gate">#</a> <code>toffoli_gate</code></h3>
<p><code>toffoli_gate</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = toffoli_gate $x
# or in a pipeline:
@list |> map toffoli_gate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-token">
<h3><a class="doc-anchor" href="#doc-token">#</a> <code>token</code></h3>
<p><code>token</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = token $x
# or in a pipeline:
@list |> map token |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tomorrow">
<h3><a class="doc-anchor" href="#doc-tomorrow">#</a> <code>tomorrow</code></h3>
<p><code>tomorrow</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = tomorrow $x
# or in a pipeline:
@list |> map tomorrow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-top">
<h3><a class="doc-anchor" href="#doc-top">#</a> <code>top</code></h3>
<p><code>top</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = top $x
# or in a pipeline:
@list |> map top |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-top-trading-cycle">
<h3><a class="doc-anchor" href="#doc-top-trading-cycle">#</a> <code>top_trading_cycle</code></h3>
<p><code>top_trading_cycle</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = top_trading_cycle $x
# or in a pipeline:
@list |> map top_trading_cycle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-top-trading-cycles-step">
<h3><a class="doc-anchor" href="#doc-top-trading-cycles-step">#</a> <code>top_trading_cycles_step</code></h3>
<p><code>top_trading_cycles_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = top_trading_cycles_step $x
# or in a pipeline:
@list |> map top_trading_cycles_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-topk-indices">
<h3><a class="doc-anchor" href="#doc-topk-indices">#</a> <code>topk_indices</code></h3>
<p><code>topk_indices</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = topk_indices $x
# or in a pipeline:
@list |> map topk_indices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-topo-kahn-step">
<h3><a class="doc-anchor" href="#doc-topo-kahn-step">#</a> <code>topo_kahn_step</code></h3>
<p><code>topo_kahn_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = topo_kahn_step $x
# or in a pipeline:
@list |> map topo_kahn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-topological-sort">
<h3><a class="doc-anchor" href="#doc-topological-sort">#</a> <code>topological_sort</code></h3>
<p><code>topological_sort</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = topological_sort $x
# or in a pipeline:
@list |> map topological_sort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-topological-sort-kahn">
<h3><a class="doc-anchor" href="#doc-topological-sort-kahn">#</a> <code>topological_sort_kahn</code></h3>
<p><code>topological_sort_kahn</code> — batch 24 builtin.</p>
<pre><code class="lang-perl">my $result = topological_sort_kahn $x
# or in a pipeline:
@list |> map topological_sort_kahn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-toposort">
<h3><a class="doc-anchor" href="#doc-toposort">#</a> <code>toposort</code></h3>
<p><code>toposort</code> — extended stdlib builtin. Alias for <code>topological_sort</code>.</p>
<pre><code class="lang-perl">my $result = toposort $x
# or in a pipeline:
@list |> map toposort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-torque">
<h3><a class="doc-anchor" href="#doc-torque">#</a> <code>torque</code></h3>
<p><code>torque($force, $lever_arm, $angle)</code> — compute torque τ = r×F×sin(θ) (N⋅m). Angle in degrees, default 90.</p>
<pre><code class="lang-perl">p torque(50, 0.5) # 25 N⋅m (perpendicular force)
p torque(50, 0.5, 30) # 12.5 N⋅m
</code></pre>
</article>
<article class="doc-entry" id="doc-torsion-coefficient">
<h3><a class="doc-anchor" href="#doc-torsion-coefficient">#</a> <code>torsion_coefficient</code></h3>
<p><code>torsion_coefficient</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = torsion_coefficient $x
# or in a pipeline:
@list |> map torsion_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tortuosity-estimate-bruggeman">
<h3><a class="doc-anchor" href="#doc-tortuosity-estimate-bruggeman">#</a> <code>tortuosity_estimate_bruggeman</code></h3>
<p><code>tortuosity_estimate_bruggeman</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = tortuosity_estimate_bruggeman $x
# or in a pipeline:
@list |> map tortuosity_estimate_bruggeman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-torus-surface">
<h3><a class="doc-anchor" href="#doc-torus-surface">#</a> <code>torus_surface</code></h3>
<p><code>torus_surface($major_r, $minor_r)</code> — computes the surface area of a torus. Returns <code>4π²Rr</code>.</p>
<pre><code class="lang-perl">p torus_surface(10, 2) # ~789.6
</code></pre>
</article>
<article class="doc-entry" id="doc-torus-volume">
<h3><a class="doc-anchor" href="#doc-torus-volume">#</a> <code>torus_volume</code></h3>
<p><code>torus_volume($major_r, $minor_r)</code> — computes the volume of a torus with major radius R (center to tube center) and minor radius r (tube radius). Returns <code>2π²Rr²</code>.</p>
<pre><code class="lang-perl">p torus_volume(10, 2) # ~789.6
</code></pre>
</article>
<article class="doc-entry" id="doc-torussurf">
<h3><a class="doc-anchor" href="#doc-torussurf">#</a> <code>torussurf</code></h3>
<p><code>torussurf</code> — geometry (extended) builtin. Alias for <code>torus_surface</code>.</p>
<pre><code class="lang-perl">my $result = torussurf $x
# or in a pipeline:
@list |> map torussurf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-torusvol">
<h3><a class="doc-anchor" href="#doc-torusvol">#</a> <code>torusvol</code></h3>
<p><code>torusvol</code> — geometry (extended) builtin. Alias for <code>torus_volume</code>.</p>
<pre><code class="lang-perl">my $result = torusvol $x
# or in a pipeline:
@list |> map torusvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-total-solar-irradiance-step">
<h3><a class="doc-anchor" href="#doc-total-solar-irradiance-step">#</a> <code>total_solar_irradiance_step</code></h3>
<p><code>total_solar_irradiance_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = total_solar_irradiance_step $x
# or in a pipeline:
@list |> map total_solar_irradiance_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-total-variation-distance">
<h3><a class="doc-anchor" href="#doc-total-variation-distance">#</a> <code>total_variation_distance</code></h3>
<p><code>total_variation_distance</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = total_variation_distance $x
# or in a pipeline:
@list |> map total_variation_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-totient-sum">
<h3><a class="doc-anchor" href="#doc-totient-sum">#</a> <code>totient_sum</code></h3>
<p><code>totient_sum</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = totient_sum $x
# or in a pipeline:
@list |> map totient_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-totsum">
<h3><a class="doc-anchor" href="#doc-totsum">#</a> <code>totsum</code></h3>
<p><code>totsum</code> — math / numeric (uncategorized batch) builtin. Alias for <code>totient_sum</code>.</p>
<pre><code class="lang-perl">my $result = totsum $x
# or in a pipeline:
@list |> map totsum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-touch">
<h3><a class="doc-anchor" href="#doc-touch">#</a> <code>touch</code></h3>
<p><code>touch</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = touch $x
# or in a pipeline:
@list |> map touch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tov-mass-limit">
<h3><a class="doc-anchor" href="#doc-tov-mass-limit">#</a> <code>tov_mass_limit</code></h3>
<p><code>tov_mass_limit</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = tov_mass_limit $x
# or in a pipeline:
@list |> map tov_mass_limit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tower-of-hanoi">
<h3><a class="doc-anchor" href="#doc-tower-of-hanoi">#</a> <code>tower_of_hanoi</code></h3>
<p><code>tower_of_hanoi</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = tower_of_hanoi $x
# or in a pipeline:
@list |> map tower_of_hanoi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tplanck">
<h3><a class="doc-anchor" href="#doc-tplanck">#</a> <code>tplanck</code></h3>
<p><code>tplanck</code> — physics constants builtin. Alias for <code>planck_time</code>.</p>
<pre><code class="lang-perl">my $result = tplanck $x
# or in a pipeline:
@list |> map tplanck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trace-distance">
<h3><a class="doc-anchor" href="#doc-trace-distance">#</a> <code>trace_distance</code></h3>
<p><code>trace_distance</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = trace_distance $x
# or in a pipeline:
@list |> map trace_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trade-wind-speed">
<h3><a class="doc-anchor" href="#doc-trade-wind-speed">#</a> <code>trade_wind_speed</code></h3>
<p><code>trade_wind_speed</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = trade_wind_speed $x
# or in a pipeline:
@list |> map trade_wind_speed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tragedy-commons-metric">
<h3><a class="doc-anchor" href="#doc-tragedy-commons-metric">#</a> <code>tragedy_commons_metric</code></h3>
<p><code>tragedy_commons_metric</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = tragedy_commons_metric $x
# or in a pipeline:
@list |> map tragedy_commons_metric |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trailing-zeros">
<h3><a class="doc-anchor" href="#doc-trailing-zeros">#</a> <code>trailing_zeros</code></h3>
<p><code>trailing_zeros</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = trailing_zeros $x
# or in a pipeline:
@list |> map trailing_zeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trait">
<h3><a class="doc-anchor" href="#doc-trait">#</a> <code>trait</code></h3>
<p><code>trait</code> declares an interface that classes can implement via <code>impl</code>. Traits define method signatures that implementing classes must provide.</p>
<p><strong>Declaration:</strong></p>
<pre><code class="lang-perl">trait Printable {
fn to_str # required (no body)
fn debug { ... } # optional default impl
}
</code></pre>
<p><strong>Implementation:</strong></p>
<pre><code class="lang-perl">class Item impl Printable {
name: Str
fn to_str { $self->name }
}
</code></pre>
<p><strong>Multiple traits:</strong></p>
<pre><code class="lang-perl">class Widget impl Printable, Comparable {
...
}
</code></pre>
<p>Note: trait method bodies provide default implementations; classes can override them.</p>
</article>
<article class="doc-entry" id="doc-trans-check">
<h3><a class="doc-anchor" href="#doc-trans-check">#</a> <code>trans_check</code></h3>
<p><code>trans_check</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = trans_check $x
# or in a pipeline:
@list |> map trans_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transcribe-dna-rna">
<h3><a class="doc-anchor" href="#doc-transcribe-dna-rna">#</a> <code>transcribe_dna_rna</code></h3>
<p><code>transcribe_dna_rna</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = transcribe_dna_rna $x
# or in a pipeline:
@list |> map transcribe_dna_rna |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transform-keys">
<h3><a class="doc-anchor" href="#doc-transform-keys">#</a> <code>transform_keys</code></h3>
<p><code>transform_keys</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = transform_keys $x
# or in a pipeline:
@list |> map transform_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transform-values">
<h3><a class="doc-anchor" href="#doc-transform-values">#</a> <code>transform_values</code></h3>
<p><code>transform_values</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = transform_values $x
# or in a pipeline:
@list |> map transform_values |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transition-arc-eager">
<h3><a class="doc-anchor" href="#doc-transition-arc-eager">#</a> <code>transition_arc_eager</code></h3>
<p><code>transition_arc_eager</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = transition_arc_eager $x
# or in a pipeline:
@list |> map transition_arc_eager |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transition-arc-standard">
<h3><a class="doc-anchor" href="#doc-transition-arc-standard">#</a> <code>transition_arc_standard</code></h3>
<p><code>transition_arc_standard</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = transition_arc_standard $x
# or in a pipeline:
@list |> map transition_arc_standard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transitivity">
<h3><a class="doc-anchor" href="#doc-transitivity">#</a> <code>transitivity</code></h3>
<p><code>transitivity</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = transitivity $x
# or in a pipeline:
@list |> map transitivity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-translate">
<h3><a class="doc-anchor" href="#doc-translate">#</a> <code>translate</code></h3>
<p><code>translate</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = translate $x
# or in a pipeline:
@list |> map translate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-translate-dna">
<h3><a class="doc-anchor" href="#doc-translate-dna">#</a> <code>translate_dna</code></h3>
<p><code>translate_dna</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = translate_dna $x
# or in a pipeline:
@list |> map translate_dna |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-translate-point">
<h3><a class="doc-anchor" href="#doc-translate-point">#</a> <code>translate_point</code></h3>
<p><code>translate_point($x, $y, $dx, $dy)</code> — translates a 2D point by offset (dx, dy). Returns [$x+$dx, $y+$dy]. Basic vector addition.</p>
<pre><code class="lang-perl">my $p = translate_point(1, 2, 3, 4)
p @$p # (4, 6)
</code></pre>
</article>
<article class="doc-entry" id="doc-transmission-pair-index">
<h3><a class="doc-anchor" href="#doc-transmission-pair-index">#</a> <code>transmission_pair_index</code></h3>
<p><code>transmission_pair_index</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = transmission_pair_index $x
# or in a pipeline:
@list |> map transmission_pair_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transmittance">
<h3><a class="doc-anchor" href="#doc-transmittance">#</a> <code>transmittance</code></h3>
<p><code>transmittance</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = transmittance $x
# or in a pipeline:
@list |> map transmittance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transmittance-to-a">
<h3><a class="doc-anchor" href="#doc-transmittance-to-a">#</a> <code>transmittance_to_a</code></h3>
<p><code>transmittance_to_a</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = transmittance_to_a $input
</code></pre>
</article>
<article class="doc-entry" id="doc-transpose">
<h3><a class="doc-anchor" href="#doc-transpose">#</a> <code>transpose</code></h3>
<p><code>transpose</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = transpose $x
# or in a pipeline:
@list |> map transpose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transpose-axis">
<h3><a class="doc-anchor" href="#doc-transpose-axis">#</a> <code>transpose_axis</code></h3>
<p><code>transpose_axis</code> — batch 54 builtin.</p>
<pre><code class="lang-perl">my $result = transpose_axis $x
# or in a pipeline:
@list |> map transpose_axis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transpose-freq-semitones">
<h3><a class="doc-anchor" href="#doc-transpose-freq-semitones">#</a> <code>transpose_freq_semitones</code></h3>
<p><code>transpose_freq_semitones</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = transpose_freq_semitones $x
# or in a pipeline:
@list |> map transpose_freq_semitones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transpose-semi">
<h3><a class="doc-anchor" href="#doc-transpose-semi">#</a> <code>transpose_semi</code></h3>
<p><code>transpose_semi</code> — batch 9 builtin. Alias for <code>transpose_freq_semitones</code>.</p>
<pre><code class="lang-perl">my $result = transpose_semi $x
# or in a pipeline:
@list |> map transpose_semi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transpt">
<h3><a class="doc-anchor" href="#doc-transpt">#</a> <code>transpt</code></h3>
<p><code>transpt</code> — geometry (extended) builtin. Alias for <code>translate_point</code>.</p>
<pre><code class="lang-perl">my $result = transpt $x
# or in a pipeline:
@list |> map transpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trapezoid">
<h3><a class="doc-anchor" href="#doc-trapezoid">#</a> <code>trapezoid</code></h3>
<p><code>trapz</code> (alias <code>trapezoid</code>) integrates evenly-spaced samples using the trapezoidal rule. Optional dx (default 1).</p>
<pre><code class="lang-perl">my @y = map { _ ** 2 } 0:100
p trapz(\@y, 0.01) # ≈ 0.3333
</code></pre>
</article>
<article class="doc-entry" id="doc-trapezoidal-lte">
<h3><a class="doc-anchor" href="#doc-trapezoidal-lte">#</a> <code>trapezoidal_lte</code></h3>
<p><code>trapezoidal_lte</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = trapezoidal_lte $x
# or in a pipeline:
@list |> map trapezoidal_lte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trapped-surface-check">
<h3><a class="doc-anchor" href="#doc-trapped-surface-check">#</a> <code>trapped_surface_check</code></h3>
<p><code>trapped_surface_check</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = trapped_surface_check $x
# or in a pipeline:
@list |> map trapped_surface_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trasatti-voltammetry-charge">
<h3><a class="doc-anchor" href="#doc-trasatti-voltammetry-charge">#</a> <code>trasatti_voltammetry_charge</code></h3>
<p><code>trasatti_voltammetry_charge</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = trasatti_voltammetry_charge $x
# or in a pipeline:
@list |> map trasatti_voltammetry_charge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tree-kernel-collins">
<h3><a class="doc-anchor" href="#doc-tree-kernel-collins">#</a> <code>tree_kernel_collins</code></h3>
<p><code>tree_kernel_collins</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = tree_kernel_collins $x
# or in a pipeline:
@list |> map tree_kernel_collins |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trev">
<h3><a class="doc-anchor" href="#doc-trev">#</a> <code>trev</code></h3>
<p><code>trev</code> — javascript array/object methods builtin. Alias for <code>to_reversed</code>.</p>
<pre><code class="lang-perl">my $result = trev $x
# or in a pipeline:
@list |> map trev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-treynor-ratio">
<h3><a class="doc-anchor" href="#doc-treynor-ratio">#</a> <code>treynor_ratio</code></h3>
<p><code>treynor_ratio</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = treynor_ratio $x
# or in a pipeline:
@list |> map treynor_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trial-smallest-factor">
<h3><a class="doc-anchor" href="#doc-trial-smallest-factor">#</a> <code>trial_smallest_factor</code></h3>
<p><code>trial_smallest_factor</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = trial_smallest_factor $x
# or in a pipeline:
@list |> map trial_smallest_factor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangle-area-heron">
<h3><a class="doc-anchor" href="#doc-triangle-area-heron">#</a> <code>triangle_area_heron</code></h3>
<p><code>triangle_area_heron</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = triangle_area_heron $x
# or in a pipeline:
@list |> map triangle_area_heron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangle-area-pts">
<h3><a class="doc-anchor" href="#doc-triangle-area-pts">#</a> <code>triangle_area_pts</code></h3>
<p><code>triangle_area_pts</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = triangle_area_pts $x
# or in a pipeline:
@list |> map triangle_area_pts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangle-circumradius">
<h3><a class="doc-anchor" href="#doc-triangle-circumradius">#</a> <code>triangle_circumradius</code></h3>
<p><code>triangle_circumradius</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = triangle_circumradius $x
# or in a pipeline:
@list |> map triangle_circumradius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangle-hypotenuse">
<h3><a class="doc-anchor" href="#doc-triangle-hypotenuse">#</a> <code>triangle_hypotenuse</code></h3>
<p><code>triangle_hypotenuse</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = triangle_hypotenuse $x
# or in a pipeline:
@list |> map triangle_hypotenuse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangle-inradius">
<h3><a class="doc-anchor" href="#doc-triangle-inradius">#</a> <code>triangle_inradius</code></h3>
<p><code>triangle_inradius</code> — batch 28 builtin.</p>
<pre><code class="lang-perl">my $result = triangle_inradius $x
# or in a pipeline:
@list |> map triangle_inradius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangles-count">
<h3><a class="doc-anchor" href="#doc-triangles-count">#</a> <code>triangles_count</code></h3>
<p><code>triangles_count</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = triangles_count $x
# or in a pipeline:
@list |> map triangles_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangular-number">
<h3><a class="doc-anchor" href="#doc-triangular-number">#</a> <code>triangular_number</code></h3>
<p><code>triangular_number</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = triangular_number $x
# or in a pipeline:
@list |> map triangular_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangular-seq">
<h3><a class="doc-anchor" href="#doc-triangular-seq">#</a> <code>triangular_seq</code></h3>
<p><code>triangular_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = triangular_seq $x
# or in a pipeline:
@list |> map triangular_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trib">
<h3><a class="doc-anchor" href="#doc-trib">#</a> <code>trib</code></h3>
<p><code>trib</code> — math / numeric (uncategorized batch) builtin. Alias for <code>tribonacci</code>.</p>
<pre><code class="lang-perl">my $result = trib $x
# or in a pipeline:
@list |> map trib |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tribonacci">
<h3><a class="doc-anchor" href="#doc-tribonacci">#</a> <code>tribonacci</code></h3>
<p><code>tribonacci</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = tribonacci $x
# or in a pipeline:
@list |> map tribonacci |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trigamma">
<h3><a class="doc-anchor" href="#doc-trigamma">#</a> <code>trigamma</code></h3>
<p><code>trigamma</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = trigamma $x
# or in a pipeline:
@list |> map trigamma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trigger-strategy-payoff">
<h3><a class="doc-anchor" href="#doc-trigger-strategy-payoff">#</a> <code>trigger_strategy_payoff</code></h3>
<p><code>trigger_strategy_payoff</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = trigger_strategy_payoff $x
# or in a pipeline:
@list |> map trigger_strategy_payoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trigram">
<h3><a class="doc-anchor" href="#doc-trigram">#</a> <code>trigram</code></h3>
<p><code>trigram</code> — string processing (uncategorized batch) builtin. Alias for <code>trigrams</code>.</p>
<pre><code class="lang-perl">my $result = trigram $x
# or in a pipeline:
@list |> map trigram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trigram-perplexity">
<h3><a class="doc-anchor" href="#doc-trigram-perplexity">#</a> <code>trigram_perplexity</code></h3>
<p><code>trigram_perplexity</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = trigram_perplexity $x
# or in a pipeline:
@list |> map trigram_perplexity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trigrams">
<h3><a class="doc-anchor" href="#doc-trigrams">#</a> <code>trigrams</code></h3>
<p><code>trigrams</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = trigrams $x
# or in a pipeline:
@list |> map trigrams |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trim-each">
<h3><a class="doc-anchor" href="#doc-trim-each">#</a> <code>trim_each</code></h3>
<p><code>trim_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = trim_each $x
# or in a pipeline:
@list |> map trim_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trim-left">
<h3><a class="doc-anchor" href="#doc-trim-left">#</a> <code>trim_left</code></h3>
<p><code>trim_left</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = trim_left $x
# or in a pipeline:
@list |> map trim_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trim-right">
<h3><a class="doc-anchor" href="#doc-trim-right">#</a> <code>trim_right</code></h3>
<p><code>trim_right</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = trim_right $x
# or in a pipeline:
@list |> map trim_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trimmed-mean">
<h3><a class="doc-anchor" href="#doc-trimmed-mean">#</a> <code>trimmed_mean</code></h3>
<p><code>trimmed_mean</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = trimmed_mean $x
# or in a pipeline:
@list |> map trimmed_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trinomial-call">
<h3><a class="doc-anchor" href="#doc-trinomial-call">#</a> <code>trinomial_call</code></h3>
<p><code>trinomial_call</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = trinomial_call $x
# or in a pipeline:
@list |> map trinomial_call |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trinum">
<h3><a class="doc-anchor" href="#doc-trinum">#</a> <code>trinum</code></h3>
<p><code>trinum</code> — number theory / primes builtin. Alias for <code>triangular_number</code>.</p>
<pre><code class="lang-perl">my $result = trinum $x
# or in a pipeline:
@list |> map trinum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triple">
<h3><a class="doc-anchor" href="#doc-triple">#</a> <code>triple</code></h3>
<p><code>triple</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = triple $x
# or in a pipeline:
@list |> map triple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trpo-kl-constraint">
<h3><a class="doc-anchor" href="#doc-trpo-kl-constraint">#</a> <code>trpo_kl_constraint</code></h3>
<p><code>trpo_kl_constraint</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = trpo_kl_constraint $x
# or in a pipeline:
@list |> map trpo_kl_constraint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trueskill-match-quality">
<h3><a class="doc-anchor" href="#doc-trueskill-match-quality">#</a> <code>trueskill_match_quality</code></h3>
<p><code>trueskill_match_quality</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = trueskill_match_quality $x
# or in a pipeline:
@list |> map trueskill_match_quality |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trueskill-update">
<h3><a class="doc-anchor" href="#doc-trueskill-update">#</a> <code>trueskill_update</code></h3>
<p><code>trueskill_update</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = trueskill_update $x
# or in a pipeline:
@list |> map trueskill_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trunc">
<h3><a class="doc-anchor" href="#doc-trunc">#</a> <code>trunc</code></h3>
<p><code>trunc</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = trunc $x
# or in a pipeline:
@list |> map trunc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truncate-at">
<h3><a class="doc-anchor" href="#doc-truncate-at">#</a> <code>truncate_at</code></h3>
<p><code>truncate_at</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = truncate_at $x
# or in a pipeline:
@list |> map truncate_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truncn">
<h3><a class="doc-anchor" href="#doc-truncn">#</a> <code>truncn</code></h3>
<p><code>truncn</code> — trivial numeric / predicate builtins builtin. Alias for <code>trunc</code>.</p>
<pre><code class="lang-perl">my $result = truncn $x
# or in a pipeline:
@list |> map truncn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trust-game-repayment">
<h3><a class="doc-anchor" href="#doc-trust-game-repayment">#</a> <code>trust_game_repayment</code></h3>
<p><code>trust_game_repayment</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = trust_game_repayment $x
# or in a pipeline:
@list |> map trust_game_repayment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truth-table">
<h3><a class="doc-anchor" href="#doc-truth-table">#</a> <code>truth_table</code></h3>
<p><code>truth_table</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = truth_table $x
# or in a pipeline:
@list |> map truth_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truthful-mechanism-check">
<h3><a class="doc-anchor" href="#doc-truthful-mechanism-check">#</a> <code>truthful_mechanism_check</code></h3>
<p><code>truthful_mechanism_check</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = truthful_mechanism_check $x
# or in a pipeline:
@list |> map truthful_mechanism_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truthy-count">
<h3><a class="doc-anchor" href="#doc-truthy-count">#</a> <code>truthy_count</code></h3>
<p><code>truthy_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = truthy_count $x
# or in a pipeline:
@list |> map truthy_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-try-fn">
<h3><a class="doc-anchor" href="#doc-try-fn">#</a> <code>try_fn</code></h3>
<p><code>try_fn</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = try_fn $x
# or in a pipeline:
@list |> map try_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-try-fold">
<h3><a class="doc-anchor" href="#doc-try-fold">#</a> <code>try_fold</code></h3>
<p><code>try_fold</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = try_fold $x
# or in a pipeline:
@list |> map try_fold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ts-headline">
<h3><a class="doc-anchor" href="#doc-ts-headline">#</a> <code>ts_headline</code></h3>
<p><code>ts_headline</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = ts_headline $x
# or in a pipeline:
@list |> map ts_headline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ts-match">
<h3><a class="doc-anchor" href="#doc-ts-match">#</a> <code>ts_match</code></h3>
<p><code>ts_match</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = ts_match $x
# or in a pipeline:
@list |> map ts_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ts-rank">
<h3><a class="doc-anchor" href="#doc-ts-rank">#</a> <code>ts_rank</code></h3>
<p><code>ts_rank</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = ts_rank $x
# or in a pipeline:
@list |> map ts_rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tsirelson-bound">
<h3><a class="doc-anchor" href="#doc-tsirelson-bound">#</a> <code>tsirelson_bound</code></h3>
<p><code>tsirelson_bound</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = tsirelson_bound $x
# or in a pipeline:
@list |> map tsirelson_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tsp-christofides">
<h3><a class="doc-anchor" href="#doc-tsp-christofides">#</a> <code>tsp_christofides</code></h3>
<p><code>tsp_christofides</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = tsp_christofides $x
# or in a pipeline:
@list |> map tsp_christofides |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tsp-held-karp">
<h3><a class="doc-anchor" href="#doc-tsp-held-karp">#</a> <code>tsp_held_karp</code></h3>
<p><code>tsp_held_karp</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = tsp_held_karp $x
# or in a pipeline:
@list |> map tsp_held_karp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tsp-held-karp-step">
<h3><a class="doc-anchor" href="#doc-tsp-held-karp-step">#</a> <code>tsp_held_karp_step</code></h3>
<p><code>tsp_held_karp_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = tsp_held_karp_step $x
# or in a pipeline:
@list |> map tsp_held_karp_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tsp-lower-bound-mst">
<h3><a class="doc-anchor" href="#doc-tsp-lower-bound-mst">#</a> <code>tsp_lower_bound_mst</code></h3>
<p><code>tsp_lower_bound_mst</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = tsp_lower_bound_mst $x
# or in a pipeline:
@list |> map tsp_lower_bound_mst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tsp-nn-step">
<h3><a class="doc-anchor" href="#doc-tsp-nn-step">#</a> <code>tsp_nn_step</code></h3>
<p><code>tsp_nn_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = tsp_nn_step $x
# or in a pipeline:
@list |> map tsp_nn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tspl">
<h3><a class="doc-anchor" href="#doc-tspl">#</a> <code>tspl</code></h3>
<p><code>tspl</code> — javascript array/object methods builtin. Alias for <code>to_spliced</code>.</p>
<pre><code class="lang-perl">my $result = tspl $x
# or in a pipeline:
@list |> map tspl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tsrt">
<h3><a class="doc-anchor" href="#doc-tsrt">#</a> <code>tsrt</code></h3>
<p><code>tsrt</code> — javascript array/object methods builtin. Alias for <code>to_sorted</code>.</p>
<pre><code class="lang-perl">my $result = tsrt $x
# or in a pipeline:
@list |> map tsrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tstr">
<h3><a class="doc-anchor" href="#doc-tstr">#</a> <code>tstr</code></h3>
<p><code>tstr</code> — misc / utility builtin. Alias for <code>to_string_val</code>.</p>
<pre><code class="lang-perl">my $result = tstr $x
# or in a pipeline:
@list |> map tstr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tt-to-tdb">
<h3><a class="doc-anchor" href="#doc-tt-to-tdb">#</a> <code>tt_to_tdb</code></h3>
<p><code>tt_to_tdb</code> — batch 55 builtin.</p>
<pre><code class="lang-perl">my $result = tt_to_tdb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ttable">
<h3><a class="doc-anchor" href="#doc-ttable">#</a> <code>ttable</code></h3>
<p><code>ttable</code> — algorithms / puzzles builtin. Alias for <code>truth_table</code>.</p>
<pre><code class="lang-perl">my $result = ttable $x
# or in a pipeline:
@list |> map ttable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ttl">
<h3><a class="doc-anchor" href="#doc-ttl">#</a> <code>ttl</code></h3>
<p><code>ttl</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = ttl $x
# or in a pipeline:
@list |> map ttl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tukey-lambda-quantile">
<h3><a class="doc-anchor" href="#doc-tukey-lambda-quantile">#</a> <code>tukey_lambda_quantile</code></h3>
<p><code>tukey_lambda_quantile</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = tukey_lambda_quantile $x
# or in a pipeline:
@list |> map tukey_lambda_quantile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tukey-w">
<h3><a class="doc-anchor" href="#doc-tukey-w">#</a> <code>tukey_w</code></h3>
<p><code>tukey_w</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = tukey_w $x
# or in a pipeline:
@list |> map tukey_w |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tukey-window">
<h3><a class="doc-anchor" href="#doc-tukey-window">#</a> <code>tukey_window</code></h3>
<p><code>tukey_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = tukey_window $x
# or in a pipeline:
@list |> map tukey_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tunneling-prob">
<h3><a class="doc-anchor" href="#doc-tunneling-prob">#</a> <code>tunneling_prob</code></h3>
<p><code>tunneling_prob</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = tunneling_prob $x
# or in a pipeline:
@list |> map tunneling_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-turaev-alexander-step">
<h3><a class="doc-anchor" href="#doc-turaev-alexander-step">#</a> <code>turaev_alexander_step</code></h3>
<p><code>turaev_alexander_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = turaev_alexander_step $x
# or in a pipeline:
@list |> map turaev_alexander_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-turbulence-intensity-step">
<h3><a class="doc-anchor" href="#doc-turbulence-intensity-step">#</a> <code>turbulence_intensity_step</code></h3>
<p><code>turbulence_intensity_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = turbulence_intensity_step $x
# or in a pipeline:
@list |> map turbulence_intensity_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-turbulent-dissipation-eps">
<h3><a class="doc-anchor" href="#doc-turbulent-dissipation-eps">#</a> <code>turbulent_dissipation_eps</code></h3>
<p><code>turbulent_dissipation_eps</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = turbulent_dissipation_eps $x
# or in a pipeline:
@list |> map turbulent_dissipation_eps |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-turbulent-kinetic-energy-step">
<h3><a class="doc-anchor" href="#doc-turbulent-kinetic-energy-step">#</a> <code>turbulent_kinetic_energy_step</code></h3>
<p><code>turbulent_kinetic_energy_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = turbulent_kinetic_energy_step $x
# or in a pipeline:
@list |> map turbulent_kinetic_energy_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tvals">
<h3><a class="doc-anchor" href="#doc-tvals">#</a> <code>tvals</code></h3>
<p><code>tvals</code> — python/ruby stdlib builtin. Alias for <code>transform_values</code>.</p>
<pre><code class="lang-perl">my $result = tvals $x
# or in a pipeline:
@list |> map tvals |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tversky">
<h3><a class="doc-anchor" href="#doc-tversky">#</a> <code>tversky</code></h3>
<p><code>tversky</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = tversky $x
# or in a pipeline:
@list |> map tversky |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-twin-primes">
<h3><a class="doc-anchor" href="#doc-twin-primes">#</a> <code>twin_primes</code></h3>
<p><code>twin_primes</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = twin_primes $x
# or in a pipeline:
@list |> map twin_primes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-twinp">
<h3><a class="doc-anchor" href="#doc-twinp">#</a> <code>twinp</code></h3>
<p><code>twinp</code> — number theory / primes builtin. Alias for <code>twin_primes</code>.</p>
<pre><code class="lang-perl">my $result = twinp $x
# or in a pipeline:
@list |> map twinp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-twist-tensor-step">
<h3><a class="doc-anchor" href="#doc-twist-tensor-step">#</a> <code>twist_tensor_step</code></h3>
<p><code>twist_tensor_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = twist_tensor_step $x
# or in a pipeline:
@list |> map twist_tensor_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-two-opt-swap-delta">
<h3><a class="doc-anchor" href="#doc-two-opt-swap-delta">#</a> <code>two_opt_swap_delta</code></h3>
<p><code>two_opt_swap_delta</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = two_opt_swap_delta $x
# or in a pipeline:
@list |> map two_opt_swap_delta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-two-sls-iv">
<h3><a class="doc-anchor" href="#doc-two-sls-iv">#</a> <code>two_sls_iv</code></h3>
<p><code>two_sls_iv</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = two_sls_iv $x
# or in a pipeline:
@list |> map two_sls_iv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-two-watched-literals">
<h3><a class="doc-anchor" href="#doc-two-watched-literals">#</a> <code>two_watched_literals</code></h3>
<p><code>two_watched_literals</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = two_watched_literals $x
# or in a pipeline:
@list |> map two_watched_literals |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txaft">
<h3><a class="doc-anchor" href="#doc-txaft">#</a> <code>txaft</code></h3>
<p><code>txaft</code> — extended stdlib builtin. Alias for <code>text_after</code>.</p>
<pre><code class="lang-perl">my $result = txaft $x
# or in a pipeline:
@list |> map txaft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txaftl">
<h3><a class="doc-anchor" href="#doc-txaftl">#</a> <code>txaftl</code></h3>
<p><code>txaftl</code> — extended stdlib builtin. Alias for <code>text_after_last</code>.</p>
<pre><code class="lang-perl">my $result = txaftl $x
# or in a pipeline:
@list |> map txaftl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txbef">
<h3><a class="doc-anchor" href="#doc-txbef">#</a> <code>txbef</code></h3>
<p><code>txbef</code> — extended stdlib builtin. Alias for <code>text_before</code>.</p>
<pre><code class="lang-perl">my $result = txbef $x
# or in a pipeline:
@list |> map txbef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txbefl">
<h3><a class="doc-anchor" href="#doc-txbefl">#</a> <code>txbefl</code></h3>
<p><code>txbefl</code> — extended stdlib builtin. Alias for <code>text_before_last</code>.</p>
<pre><code class="lang-perl">my $result = txbefl $x
# or in a pipeline:
@list |> map txbefl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txbtwn">
<h3><a class="doc-anchor" href="#doc-txbtwn">#</a> <code>txbtwn</code></h3>
<p><code>txbtwn</code> — extended stdlib builtin. Alias for <code>text_between</code>.</p>
<pre><code class="lang-perl">my $result = txbtwn $x
# or in a pipeline:
@list |> map txbtwn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-type">
<h3><a class="doc-anchor" href="#doc-type">#</a> <code>type</code></h3>
<p><code>type</code> — misc / utility builtin. Alias for <code>type_of</code>.</p>
<pre><code class="lang-perl">my $result = type $x
# or in a pipeline:
@list |> map type |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-type-each">
<h3><a class="doc-anchor" href="#doc-type-each">#</a> <code>type_each</code></h3>
<p><code>type_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = type_each $x
# or in a pipeline:
@list |> map type_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-type-of">
<h3><a class="doc-anchor" href="#doc-type-of">#</a> <code>type_of</code></h3>
<p><code>type_of</code> — misc / utility builtin.</p>
<pre><code class="lang-perl">my $result = type_of $x
# or in a pipeline:
@list |> map type_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-type-redis">
<h3><a class="doc-anchor" href="#doc-type-redis">#</a> <code>type_redis</code></h3>
<p><code>type_redis</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = type_redis $x
# or in a pipeline:
@list |> map type_redis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-typeof">
<h3><a class="doc-anchor" href="#doc-typeof">#</a> <code>typeof</code></h3>
<p><code>typeof</code> — misc / utility builtin. Alias for <code>type_of</code>.</p>
<pre><code class="lang-perl">my $result = typeof $x
# or in a pipeline:
@list |> map typeof |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tz">
<h3><a class="doc-anchor" href="#doc-tz">#</a> <code>tz</code></h3>
<p><code>tz</code> — base conversion builtin. Alias for <code>trailing_zeros</code>.</p>
<pre><code class="lang-perl">my $result = tz $x
# or in a pipeline:
@list |> map tz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ubound">
<h3><a class="doc-anchor" href="#doc-ubound">#</a> <code>ubound</code></h3>
<p><code>ubound</code> — extended stdlib builtin. Alias for <code>upper_bound</code>.</p>
<pre><code class="lang-perl">my $result = ubound $x
# or in a pipeline:
@list |> map ubound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ucb1-action-value">
<h3><a class="doc-anchor" href="#doc-ucb1-action-value">#</a> <code>ucb1_action_value</code></h3>
<p><code>ucb1_action_value</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = ucb1_action_value $x
# or in a pipeline:
@list |> map ucb1_action_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ucm-unobserved-components">
<h3><a class="doc-anchor" href="#doc-ucm-unobserved-components">#</a> <code>ucm_unobserved_components</code></h3>
<p><code>ucm_unobserved_components</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = ucm_unobserved_components $x
# or in a pipeline:
@list |> map ucm_unobserved_components |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ud">
<h3><a class="doc-anchor" href="#doc-ud">#</a> <code>ud</code></h3>
<p><code>ud</code> — crypto / encoding builtin. Alias for <code>url_decode</code>.</p>
<pre><code class="lang-perl">my $result = ud $x
# or in a pipeline:
@list |> map ud |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ue">
<h3><a class="doc-anchor" href="#doc-ue">#</a> <code>ue</code></h3>
<p><code>ue</code> — crypto / encoding builtin. Alias for <code>url_encode</code>.</p>
<pre><code class="lang-perl">my $result = ue $x
# or in a pipeline:
@list |> map ue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ugz">
<h3><a class="doc-anchor" href="#doc-ugz">#</a> <code>ugz</code></h3>
<p><code>ugz</code> — crypto / encoding builtin. Alias for <code>gunzip</code>.</p>
<pre><code class="lang-perl">my $result = ugz $x
# or in a pipeline:
@list |> map ugz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uid">
<h3><a class="doc-anchor" href="#doc-uid">#</a> <code>uid</code></h3>
<p><code>uid</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = uid $x
# or in a pipeline:
@list |> map uid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uin">
<h3><a class="doc-anchor" href="#doc-uin">#</a> <code>uin</code></h3>
<p><code>uin</code> — algebraic match builtin. Alias for <code>update_in</code>.</p>
<pre><code class="lang-perl">my $result = uin $x
# or in a pipeline:
@list |> map uin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ultimatum-acceptance-prob">
<h3><a class="doc-anchor" href="#doc-ultimatum-acceptance-prob">#</a> <code>ultimatum_acceptance_prob</code></h3>
<p><code>ultimatum_acceptance_prob</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = ultimatum_acceptance_prob $x
# or in a pipeline:
@list |> map ultimatum_acceptance_prob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uncertainty-position">
<h3><a class="doc-anchor" href="#doc-uncertainty-position">#</a> <code>uncertainty_position</code></h3>
<p><code>uncertainty_position</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = uncertainty_position $x
# or in a pipeline:
@list |> map uncertainty_position |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-undef-count">
<h3><a class="doc-anchor" href="#doc-undef-count">#</a> <code>undef_count</code></h3>
<p><code>undef_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = undef_count $x
# or in a pipeline:
@list |> map undef_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-underline">
<h3><a class="doc-anchor" href="#doc-underline">#</a> <code>underline</code></h3>
<p><code>underline</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = underline $x
# or in a pipeline:
@list |> map underline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unfold">
<h3><a class="doc-anchor" href="#doc-unfold">#</a> <code>unfold</code></h3>
<p><code>unfold</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = unfold $x
# or in a pipeline:
@list |> map unfold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unfoldr">
<h3><a class="doc-anchor" href="#doc-unfoldr">#</a> <code>unfoldr</code></h3>
<p><code>unfoldr</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = unfoldr $x
# or in a pipeline:
@list |> map unfoldr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unfr">
<h3><a class="doc-anchor" href="#doc-unfr">#</a> <code>unfr</code></h3>
<p><code>unfr</code> — haskell list functions builtin. Alias for <code>unfoldr</code>.</p>
<pre><code class="lang-perl">my $result = unfr $x
# or in a pipeline:
@list |> map unfr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unicode-to-native">
<h3><a class="doc-anchor" href="#doc-unicode-to-native">#</a> <code>unicode_to_native</code></h3>
<p><code>unicode_to_native</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = unicode_to_native $input
</code></pre>
</article>
<article class="doc-entry" id="doc-unification-robinson">
<h3><a class="doc-anchor" href="#doc-unification-robinson">#</a> <code>unification_robinson</code></h3>
<p><code>unification_robinson</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = unification_robinson $x
# or in a pipeline:
@list |> map unification_robinson |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-union-list">
<h3><a class="doc-anchor" href="#doc-union-list">#</a> <code>union_list</code></h3>
<p><code>union_list</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = union_list $x
# or in a pipeline:
@list |> map union_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unionl">
<h3><a class="doc-anchor" href="#doc-unionl">#</a> <code>unionl</code></h3>
<p><code>unionl</code> — additional missing stdlib functions builtin. Alias for <code>union_list</code>.</p>
<pre><code class="lang-perl">my $result = unionl $x
# or in a pipeline:
@list |> map unionl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uniq-by">
<h3><a class="doc-anchor" href="#doc-uniq-by">#</a> <code>uniq_by</code></h3>
<p><code>uniq_by</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = uniq_by $x
# or in a pipeline:
@list |> map uniq_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unique-count">
<h3><a class="doc-anchor" href="#doc-unique-count">#</a> <code>unique_count</code></h3>
<p><code>unique_count</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = unique_count $x
# or in a pipeline:
@list |> map unique_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unique-count-of">
<h3><a class="doc-anchor" href="#doc-unique-count-of">#</a> <code>unique_count_of</code></h3>
<p><code>unique_count_of</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = unique_count_of $x
# or in a pipeline:
@list |> map unique_count_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unique-words">
<h3><a class="doc-anchor" href="#doc-unique-words">#</a> <code>unique_words</code></h3>
<p><code>unique_words</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = unique_words $x
# or in a pipeline:
@list |> map unique_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uniqw">
<h3><a class="doc-anchor" href="#doc-uniqw">#</a> <code>uniqw</code></h3>
<p><code>uniqw</code> — string processing (uncategorized batch) builtin. Alias for <code>unique_words</code>.</p>
<pre><code class="lang-perl">my $result = uniqw $x
# or in a pipeline:
@list |> map uniqw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unit-vec">
<h3><a class="doc-anchor" href="#doc-unit-vec">#</a> <code>unit_vec</code></h3>
<p><code>unit_vec</code> — matrix / linear algebra builtin. Alias for <code>vec_normalize</code>.</p>
<pre><code class="lang-perl">my $result = unit_vec $x
# or in a pipeline:
@list |> map unit_vec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unit-vector">
<h3><a class="doc-anchor" href="#doc-unit-vector">#</a> <code>unit_vector</code></h3>
<p><code>unit_vector</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = unit_vector $x
# or in a pipeline:
@list |> map unit_vector |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-universal-code-length">
<h3><a class="doc-anchor" href="#doc-universal-code-length">#</a> <code>universal_code_length</code></h3>
<p><code>universal_code_length</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = universal_code_length $x
# or in a pipeline:
@list |> map universal_code_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-universal-enveloping-dim">
<h3><a class="doc-anchor" href="#doc-universal-enveloping-dim">#</a> <code>universal_enveloping_dim</code></h3>
<p><code>universal_enveloping_dim</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = universal_enveloping_dim $x
# or in a pipeline:
@list |> map universal_enveloping_dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unix-epoch">
<h3><a class="doc-anchor" href="#doc-unix-epoch">#</a> <code>unix_epoch</code></h3>
<p><code>unix_epoch</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = unix_epoch $x
# or in a pipeline:
@list |> map unix_epoch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unix-epoch-ms">
<h3><a class="doc-anchor" href="#doc-unix-epoch-ms">#</a> <code>unix_epoch_ms</code></h3>
<p><code>unix_epoch_ms</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = unix_epoch_ms $x
# or in a pipeline:
@list |> map unix_epoch_ms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unix-epoch-to-iso">
<h3><a class="doc-anchor" href="#doc-unix-epoch-to-iso">#</a> <code>unix_epoch_to_iso</code></h3>
<p><code>unix_epoch_to_iso</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = unix_epoch_to_iso $input
</code></pre>
</article>
<article class="doc-entry" id="doc-unlines">
<h3><a class="doc-anchor" href="#doc-unlines">#</a> <code>unlines</code></h3>
<p><code>unlines</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = unlines $x
# or in a pipeline:
@list |> map unlines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unlns">
<h3><a class="doc-anchor" href="#doc-unlns">#</a> <code>unlns</code></h3>
<p><code>unlns</code> — go/general functional utilities builtin. Alias for <code>unlines</code>.</p>
<pre><code class="lang-perl">my $result = unlns $x
# or in a pipeline:
@list |> map unlns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unquote">
<h3><a class="doc-anchor" href="#doc-unquote">#</a> <code>unquote</code></h3>
<p><code>unquote</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = unquote $x
# or in a pipeline:
@list |> map unquote |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unruh-temperature-full">
<h3><a class="doc-anchor" href="#doc-unruh-temperature-full">#</a> <code>unruh_temperature_full</code></h3>
<p><code>unruh_temperature_full</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = unruh_temperature_full $x
# or in a pipeline:
@list |> map unruh_temperature_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unscented-sigma-point">
<h3><a class="doc-anchor" href="#doc-unscented-sigma-point">#</a> <code>unscented_sigma_point</code></h3>
<p><code>unscented_sigma_point</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = unscented_sigma_point $x
# or in a pipeline:
@list |> map unscented_sigma_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unsharp-mask-kernel">
<h3><a class="doc-anchor" href="#doc-unsharp-mask-kernel">#</a> <code>unsharp_mask_kernel</code></h3>
<p><code>unsharp_mask_kernel</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = unsharp_mask_kernel $x
# or in a pipeline:
@list |> map unsharp_mask_kernel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unsharp-mask-step">
<h3><a class="doc-anchor" href="#doc-unsharp-mask-step">#</a> <code>unsharp_mask_step</code></h3>
<p><code>unsharp_mask_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = unsharp_mask_step $x
# or in a pipeline:
@list |> map unsharp_mask_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-untie">
<h3><a class="doc-anchor" href="#doc-untie">#</a> <code>untie</code></h3>
<p><code>untie</code> — type / reflection builtin.</p>
<pre><code class="lang-perl">my $result = untie $x
# or in a pipeline:
@list |> map untie |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unwds">
<h3><a class="doc-anchor" href="#doc-unwds">#</a> <code>unwds</code></h3>
<p><code>unwds</code> — go/general functional utilities builtin. Alias for <code>unwords</code>.</p>
<pre><code class="lang-perl">my $result = unwds $x
# or in a pipeline:
@list |> map unwds |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unweaken">
<h3><a class="doc-anchor" href="#doc-unweaken">#</a> <code>unweaken</code></h3>
<p><code>unweaken</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = unweaken $x
# or in a pipeline:
@list |> map unweaken |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unwords">
<h3><a class="doc-anchor" href="#doc-unwords">#</a> <code>unwords</code></h3>
<p><code>unwords</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = unwords $x
# or in a pipeline:
@list |> map unwords |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unzip">
<h3><a class="doc-anchor" href="#doc-unzip">#</a> <code>unzip</code></h3>
<p><code>unzip</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = unzip $x
# or in a pipeline:
@list |> map unzip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unzip-archive">
<h3><a class="doc-anchor" href="#doc-unzip-archive">#</a> <code>unzip_archive</code></h3>
<p><code>unzip_archive</code> — crypto / encoding builtin. Alias for <code>zip_extract</code>.</p>
<pre><code class="lang-perl">my $result = unzip_archive $x
# or in a pipeline:
@list |> map unzip_archive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unzip-pairs">
<h3><a class="doc-anchor" href="#doc-unzip-pairs">#</a> <code>unzip_pairs</code></h3>
<p><code>unzip_pairs</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = unzip_pairs $x
# or in a pipeline:
@list |> map unzip_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upc-check">
<h3><a class="doc-anchor" href="#doc-upc-check">#</a> <code>upc_check</code></h3>
<p><code>upc_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = upc_check $x
# or in a pipeline:
@list |> map upc_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upcase-each">
<h3><a class="doc-anchor" href="#doc-upcase-each">#</a> <code>upcase_each</code></h3>
<p><code>upcase_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = upcase_each $x
# or in a pipeline:
@list |> map upcase_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upda">
<h3><a class="doc-anchor" href="#doc-upda">#</a> <code>upda</code></h3>
<p><code>upda</code> — go/general functional utilities builtin. Alias for <code>update_at</code>.</p>
<pre><code class="lang-perl">my $result = upda $x
# or in a pipeline:
@list |> map upda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-update-at">
<h3><a class="doc-anchor" href="#doc-update-at">#</a> <code>update_at</code></h3>
<p><code>update_at</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = update_at $x
# or in a pipeline:
@list |> map update_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-update-in">
<h3><a class="doc-anchor" href="#doc-update-in">#</a> <code>update_in</code></h3>
<p><code>update_in</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = update_in $x
# or in a pipeline:
@list |> map update_in |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upfirdn-step">
<h3><a class="doc-anchor" href="#doc-upfirdn-step">#</a> <code>upfirdn_step</code></h3>
<p><code>upfirdn_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = upfirdn_step $x
# or in a pipeline:
@list |> map upfirdn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upper-bound">
<h3><a class="doc-anchor" href="#doc-upper-bound">#</a> <code>upper_bound</code></h3>
<p><code>upper_bound</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = upper_bound $x
# or in a pipeline:
@list |> map upper_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upper-snake">
<h3><a class="doc-anchor" href="#doc-upper-snake">#</a> <code>upper_snake</code></h3>
<p><code>upper_snake</code> — string (batch 2) builtin. Alias for <code>constant_case</code>.</p>
<pre><code class="lang-perl">my $result = upper_snake $x
# or in a pipeline:
@list |> map upper_snake |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upper-triangular-q">
<h3><a class="doc-anchor" href="#doc-upper-triangular-q">#</a> <code>upper_triangular_q</code></h3>
<p><code>upper_triangular_q</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = upper_triangular_q $x
# or in a pipeline:
@list |> map upper_triangular_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uppercase">
<h3><a class="doc-anchor" href="#doc-uppercase">#</a> <code>uppercase</code></h3>
<p><code>uppercase</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = uppercase $x
# or in a pipeline:
@list |> map uppercase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upsample">
<h3><a class="doc-anchor" href="#doc-upsample">#</a> <code>upsample</code></h3>
<p><code>upsample(\@signal, $factor)</code> (alias <code>interpolate</code>) — increases sample rate by inserting zeros and filtering. Factor must be positive integer.</p>
<pre><code class="lang-perl">my $upsampled = interpolate(\@signal, 4) # 4x sample rate
</code></pre>
</article>
<article class="doc-entry" id="doc-uptime-secs">
<h3><a class="doc-anchor" href="#doc-uptime-secs">#</a> <code>uptime_secs</code></h3>
<p><code>uptime_secs</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = uptime_secs $x
# or in a pipeline:
@list |> map uptime_secs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upto">
<h3><a class="doc-anchor" href="#doc-upto">#</a> <code>upto</code></h3>
<p><code>upto</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = upto $x
# or in a pipeline:
@list |> map upto |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uqb">
<h3><a class="doc-anchor" href="#doc-uqb">#</a> <code>uqb</code></h3>
<p><code>uqb</code> — python/ruby stdlib builtin. Alias for <code>uniq_by</code>.</p>
<pre><code class="lang-perl">my $result = uqb $x
# or in a pipeline:
@list |> map uqb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uri-normalize">
<h3><a class="doc-anchor" href="#doc-uri-normalize">#</a> <code>uri_normalize</code></h3>
<p><code>uri_normalize</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = uri_normalize $x
# or in a pipeline:
@list |> map uri_normalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uri-resolve">
<h3><a class="doc-anchor" href="#doc-uri-resolve">#</a> <code>uri_resolve</code></h3>
<p><code>uri_resolve</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = uri_resolve $x
# or in a pipeline:
@list |> map uri_resolve |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uri-template-expand">
<h3><a class="doc-anchor" href="#doc-uri-template-expand">#</a> <code>uri_template_expand</code></h3>
<p><code>uri_template_expand</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = uri_template_expand $x
# or in a pipeline:
@list |> map uri_template_expand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-decode-form">
<h3><a class="doc-anchor" href="#doc-url-decode-form">#</a> <code>url_decode_form</code></h3>
<p><code>url_decode_form</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = url_decode_form $x
# or in a pipeline:
@list |> map url_decode_form |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-encode-form">
<h3><a class="doc-anchor" href="#doc-url-encode-form">#</a> <code>url_encode_form</code></h3>
<p><code>url_encode_form</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = url_encode_form $x
# or in a pipeline:
@list |> map url_encode_form |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-host">
<h3><a class="doc-anchor" href="#doc-url-host">#</a> <code>url_host</code></h3>
<p><code>url_host</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = url_host $x
# or in a pipeline:
@list |> map url_host |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-origin">
<h3><a class="doc-anchor" href="#doc-url-origin">#</a> <code>url_origin</code></h3>
<p><code>url_origin</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = url_origin $x
# or in a pipeline:
@list |> map url_origin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-path">
<h3><a class="doc-anchor" href="#doc-url-path">#</a> <code>url_path</code></h3>
<p><code>url_path</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = url_path $x
# or in a pipeline:
@list |> map url_path |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-query">
<h3><a class="doc-anchor" href="#doc-url-query">#</a> <code>url_query</code></h3>
<p><code>url_query</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = url_query $x
# or in a pipeline:
@list |> map url_query |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-scheme">
<h3><a class="doc-anchor" href="#doc-url-scheme">#</a> <code>url_scheme</code></h3>
<p><code>url_scheme</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = url_scheme $x
# or in a pipeline:
@list |> map url_scheme |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-urld">
<h3><a class="doc-anchor" href="#doc-urld">#</a> <code>urld</code></h3>
<p><code>urld</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = urld $x
# or in a pipeline:
@list |> map urld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-urle">
<h3><a class="doc-anchor" href="#doc-urle">#</a> <code>urle</code></h3>
<p><code>urle</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = urle $x
# or in a pipeline:
@list |> map urle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-us-to-ns">
<h3><a class="doc-anchor" href="#doc-us-to-ns">#</a> <code>us_to_ns</code></h3>
<p><code>us_to_ns</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = us_to_ns $input
</code></pre>
</article>
<article class="doc-entry" id="doc-usamp">
<h3><a class="doc-anchor" href="#doc-usamp">#</a> <code>usamp</code></h3>
<p><code>usamp</code> — dsp / signal (extended) builtin. Alias for <code>upsample</code>.</p>
<pre><code class="lang-perl">my $result = usamp $x
# or in a pipeline:
@list |> map usamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-username">
<h3><a class="doc-anchor" href="#doc-username">#</a> <code>username</code></h3>
<p><code>username</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = username $x
# or in a pipeline:
@list |> map username |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-utc">
<h3><a class="doc-anchor" href="#doc-utc">#</a> <code>utc</code></h3>
<p><code>utc</code> — date / time builtin. Alias for <code>datetime_utc</code>.</p>
<pre><code class="lang-perl">my $result = utc $x
# or in a pipeline:
@list |> map utc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-utci-simple">
<h3><a class="doc-anchor" href="#doc-utci-simple">#</a> <code>utci_simple</code></h3>
<p><code>utci_simple</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = utci_simple $x
# or in a pipeline:
@list |> map utci_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-utilitarian-solution">
<h3><a class="doc-anchor" href="#doc-utilitarian-solution">#</a> <code>utilitarian_solution</code></h3>
<p><code>utilitarian_solution</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = utilitarian_solution $x
# or in a pipeline:
@list |> map utilitarian_solution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-utm-from-lat-lng">
<h3><a class="doc-anchor" href="#doc-utm-from-lat-lng">#</a> <code>utm_from_lat_lng</code></h3>
<p><code>utm_from_lat_lng</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = utm_from_lat_lng $x
# or in a pipeline:
@list |> map utm_from_lat_lng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-utm-to-lat-lng">
<h3><a class="doc-anchor" href="#doc-utm-to-lat-lng">#</a> <code>utm_to_lat_lng</code></h3>
<p><code>utm_to_lat_lng</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = utm_to_lat_lng $input
</code></pre>
</article>
<article class="doc-entry" id="doc-uuencode-step">
<h3><a class="doc-anchor" href="#doc-uuencode-step">#</a> <code>uuencode_step</code></h3>
<p><code>uuencode_step</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = uuencode_step $x
# or in a pipeline:
@list |> map uuencode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uuid-v4">
<h3><a class="doc-anchor" href="#doc-uuid-v4">#</a> <code>uuid_v4</code></h3>
<p><code>uuid_v4</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = uuid_v4 $x
# or in a pipeline:
@list |> map uuid_v4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uzp">
<h3><a class="doc-anchor" href="#doc-uzp">#</a> <code>uzp</code></h3>
<p><code>uzp</code> — go/general functional utilities builtin. Alias for <code>unzip_pairs</code>.</p>
<pre><code class="lang-perl">my $result = uzp $x
# or in a pipeline:
@list |> map uzp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uzst">
<h3><a class="doc-anchor" href="#doc-uzst">#</a> <code>uzst</code></h3>
<p><code>uzst</code> — crypto / encoding builtin. Alias for <code>zstd_decode</code>.</p>
<pre><code class="lang-perl">my $result = uzst $x
# or in a pipeline:
@list |> map uzst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-v-polynomial-eval">
<h3><a class="doc-anchor" href="#doc-v-polynomial-eval">#</a> <code>v_polynomial_eval</code></h3>
<p><code>v_polynomial_eval</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = v_polynomial_eval $x
# or in a pipeline:
@list |> map v_polynomial_eval |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vaccination-coverage-required">
<h3><a class="doc-anchor" href="#doc-vaccination-coverage-required">#</a> <code>vaccination_coverage_required</code></h3>
<p><code>vaccination_coverage_required</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = vaccination_coverage_required $x
# or in a pipeline:
@list |> map vaccination_coverage_required |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vacuum-energy-density">
<h3><a class="doc-anchor" href="#doc-vacuum-energy-density">#</a> <code>vacuum_energy_density</code></h3>
<p><code>vacuum_energy_density</code> — batch 31 builtin.</p>
<pre><code class="lang-perl">my $result = vacuum_energy_density $x
# or in a pipeline:
@list |> map vacuum_energy_density |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vacuum-permeability">
<h3><a class="doc-anchor" href="#doc-vacuum-permeability">#</a> <code>vacuum_permeability</code></h3>
<p><code>vacuum_permeability</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = vacuum_permeability $x
# or in a pipeline:
@list |> map vacuum_permeability |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-value-iteration-step">
<h3><a class="doc-anchor" href="#doc-value-iteration-step">#</a> <code>value_iteration_step</code></h3>
<p><code>value_iteration_step</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = value_iteration_step $x
# or in a pipeline:
@list |> map value_iteration_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-values-at">
<h3><a class="doc-anchor" href="#doc-values-at">#</a> <code>values_at</code></h3>
<p><code>values_at</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = values_at $x
# or in a pipeline:
@list |> map values_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-values-sorted">
<h3><a class="doc-anchor" href="#doc-values-sorted">#</a> <code>values_sorted</code></h3>
<p><code>values_sorted</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = values_sorted $x
# or in a pipeline:
@list |> map values_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-van-leer-limiter">
<h3><a class="doc-anchor" href="#doc-van-leer-limiter">#</a> <code>van_leer_limiter</code></h3>
<p><code>van_leer_limiter</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = van_leer_limiter $x
# or in a pipeline:
@list |> map van_leer_limiter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-van-t-hoff-kp">
<h3><a class="doc-anchor" href="#doc-van-t-hoff-kp">#</a> <code>van_t_hoff_kp</code></h3>
<p><code>van_t_hoff_kp</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = van_t_hoff_kp $x
# or in a pipeline:
@list |> map van_t_hoff_kp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vang">
<h3><a class="doc-anchor" href="#doc-vang">#</a> <code>vang</code></h3>
<p><code>vang</code> — geometry (extended) builtin. Alias for <code>vector_angle</code>.</p>
<pre><code class="lang-perl">my $result = vang $x
# or in a pipeline:
@list |> map vang |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vant-hoff">
<h3><a class="doc-anchor" href="#doc-vant-hoff">#</a> <code>vant_hoff</code></h3>
<p><code>vant_hoff</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = vant_hoff $x
# or in a pipeline:
@list |> map vant_hoff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-var-fit">
<h3><a class="doc-anchor" href="#doc-var-fit">#</a> <code>var_fit</code></h3>
<p><code>var_fit</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = var_fit $x
# or in a pipeline:
@list |> map var_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-var-historical">
<h3><a class="doc-anchor" href="#doc-var-historical">#</a> <code>var_historical</code></h3>
<p><code>var_historical</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = var_historical $x
# or in a pipeline:
@list |> map var_historical |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-variance-decomposition">
<h3><a class="doc-anchor" href="#doc-variance-decomposition">#</a> <code>variance_decomposition</code></h3>
<p><code>variance_decomposition</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = variance_decomposition $x
# or in a pipeline:
@list |> map variance_decomposition |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vary-match">
<h3><a class="doc-anchor" href="#doc-vary-match">#</a> <code>vary_match</code></h3>
<p><code>vary_match</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = vary_match $x
# or in a pipeline:
@list |> map vary_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vasicek-bond">
<h3><a class="doc-anchor" href="#doc-vasicek-bond">#</a> <code>vasicek_bond</code></h3>
<p><code>vasicek_bond</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = vasicek_bond $x
# or in a pipeline:
@list |> map vasicek_bond |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vat">
<h3><a class="doc-anchor" href="#doc-vat">#</a> <code>vat</code></h3>
<p><code>vat</code> — python/ruby stdlib builtin. Alias for <code>values_at</code>.</p>
<pre><code class="lang-perl">my $result = vat $x
# or in a pipeline:
@list |> map vat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vcg-payment">
<h3><a class="doc-anchor" href="#doc-vcg-payment">#</a> <code>vcg_payment</code></h3>
<p><code>vcg_payment</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = vcg_payment $x
# or in a pipeline:
@list |> map vcg_payment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vcg-payment-step">
<h3><a class="doc-anchor" href="#doc-vcg-payment-step">#</a> <code>vcg_payment_step</code></h3>
<p><code>vcg_payment_step</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = vcg_payment_step $x
# or in a pipeline:
@list |> map vcg_payment_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vcross">
<h3><a class="doc-anchor" href="#doc-vcross">#</a> <code>vcross</code></h3>
<p><code>vector_cross(\@a, \@b)</code> (alias <code>vcross</code>) — computes the cross product of two 3D vectors. Returns a 3-element arrayref perpendicular to both inputs.</p>
<pre><code class="lang-perl">my $c = vcross([1,0,0], [0,1,0])
p @$c # (0, 0, 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-vdot">
<h3><a class="doc-anchor" href="#doc-vdot">#</a> <code>vdot</code></h3>
<p><code>vector_dot(\@a, \@b)</code> (alias <code>vdot</code>) — computes the dot product of two vectors. Returns the scalar sum of element-wise products.</p>
<pre><code class="lang-perl">p vdot([1,2,3], [4,5,6]) # 32
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-add">
<h3><a class="doc-anchor" href="#doc-vec-add">#</a> <code>vec_add</code></h3>
<p><code>vec_add</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = vec_add $x
# or in a pipeline:
@list |> map vec_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-clj">
<h3><a class="doc-anchor" href="#doc-vec-clj">#</a> <code>vec_clj</code></h3>
<p><code>vec_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = vec_clj $x
# or in a pipeline:
@list |> map vec_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-dot">
<h3><a class="doc-anchor" href="#doc-vec-dot">#</a> <code>vec_dot</code></h3>
<p><code>vec_dot</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = vec_dot $x
# or in a pipeline:
@list |> map vec_dot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-l2">
<h3><a class="doc-anchor" href="#doc-vec-l2">#</a> <code>vec_l2</code></h3>
<p><code>vec_l2</code> — batch 11 builtin. Alias for <code>l2_norm</code>.</p>
<pre><code class="lang-perl">my $result = vec_l2 $x
# or in a pipeline:
@list |> map vec_l2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-normalize">
<h3><a class="doc-anchor" href="#doc-vec-normalize">#</a> <code>vec_normalize</code></h3>
<p><code>vec_normalize</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = vec_normalize $x
# or in a pipeline:
@list |> map vec_normalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-outer">
<h3><a class="doc-anchor" href="#doc-vec-outer">#</a> <code>vec_outer</code></h3>
<p><code>vec_outer</code> — batch 11 builtin. Alias for <code>outer_product</code>.</p>
<pre><code class="lang-perl">my $result = vec_outer $x
# or in a pipeline:
@list |> map vec_outer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-scale">
<h3><a class="doc-anchor" href="#doc-vec-scale">#</a> <code>vec_scale</code></h3>
<p><code>vec_scale</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = vec_scale $x
# or in a pipeline:
@list |> map vec_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-set-value">
<h3><a class="doc-anchor" href="#doc-vec-set-value">#</a> <code>vec_set_value</code></h3>
<p><code>vec_set_value</code> — internal builtin.</p>
<pre><code class="lang-perl">my $result = vec_set_value $x
# or in a pipeline:
@list |> map vec_set_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-sub">
<h3><a class="doc-anchor" href="#doc-vec-sub">#</a> <code>vec_sub</code></h3>
<p><code>vec_sub</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = vec_sub $x
# or in a pipeline:
@list |> map vec_sub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vecc">
<h3><a class="doc-anchor" href="#doc-vecc">#</a> <code>vecc</code></h3>
<p><code>vecc</code> — algebraic match builtin. Alias for <code>vec_clj</code>.</p>
<pre><code class="lang-perl">my $result = vecc $x
# or in a pipeline:
@list |> map vecc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vecm-alpha-beta">
<h3><a class="doc-anchor" href="#doc-vecm-alpha-beta">#</a> <code>vecm_alpha_beta</code></h3>
<p><code>vecm_alpha_beta</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = vecm_alpha_beta $x
# or in a pipeline:
@list |> map vecm_alpha_beta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vecm-fit">
<h3><a class="doc-anchor" href="#doc-vecm-fit">#</a> <code>vecm_fit</code></h3>
<p><code>vecm_fit</code> — batch 78 builtin.</p>
<pre><code class="lang-perl">my $result = vecm_fit $x
# or in a pipeline:
@list |> map vecm_fit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vector-angle">
<h3><a class="doc-anchor" href="#doc-vector-angle">#</a> <code>vector_angle</code></h3>
<p><code>vector_angle(\@a, \@b)</code> (alias <code>vangle</code>) — computes the angle in radians between two vectors using the dot product formula.</p>
<pre><code class="lang-perl">p vangle([1,0], [0,1]) # ~1.5708 (π/2)
p vangle([1,0], [1,0]) # 0
</code></pre>
</article>
<article class="doc-entry" id="doc-vector-magnitude">
<h3><a class="doc-anchor" href="#doc-vector-magnitude">#</a> <code>vector_magnitude</code></h3>
<p><code>vector_magnitude(\@v)</code> (alias <code>vmag</code>) — computes the Euclidean length (L2 norm) of a vector.</p>
<pre><code class="lang-perl">p vmag([3, 4]) # 5
p vmag([1, 2, 2]) # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-vector-normalize">
<h3><a class="doc-anchor" href="#doc-vector-normalize">#</a> <code>vector_normalize</code></h3>
<p><code>vector_normalize(\@v)</code> (alias <code>vnorm</code>) — returns a unit vector in the same direction. Divides by magnitude.</p>
<pre><code class="lang-perl">my $u = vnorm([3, 4])
p @$u # (0.6, 0.8)
</code></pre>
</article>
<article class="doc-entry" id="doc-vector-project">
<h3><a class="doc-anchor" href="#doc-vector-project">#</a> <code>vector_project</code></h3>
<p><code>vector_project</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = vector_project $x
# or in a pipeline:
@list |> map vector_project |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vector-reject">
<h3><a class="doc-anchor" href="#doc-vector-reject">#</a> <code>vector_reject</code></h3>
<p><code>vector_reject</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = vector_reject $x
# or in a pipeline:
@list |> map vector_reject |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-velocity-potential-step">
<h3><a class="doc-anchor" href="#doc-velocity-potential-step">#</a> <code>velocity_potential_step</code></h3>
<p><code>velocity_potential_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = velocity_potential_step $x
# or in a pipeline:
@list |> map velocity_potential_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-verlinde-count-step">
<h3><a class="doc-anchor" href="#doc-verlinde-count-step">#</a> <code>verlinde_count_step</code></h3>
<p><code>verlinde_count_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = verlinde_count_step $x
# or in a pipeline:
@list |> map verlinde_count_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-verma-character-step">
<h3><a class="doc-anchor" href="#doc-verma-character-step">#</a> <code>verma_character_step</code></h3>
<p><code>verma_character_step</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = verma_character_step $x
# or in a pipeline:
@list |> map verma_character_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-verner-8-combine">
<h3><a class="doc-anchor" href="#doc-verner-8-combine">#</a> <code>verner_8_combine</code></h3>
<p><code>verner_8_combine</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = verner_8_combine $x
# or in a pipeline:
@list |> map verner_8_combine |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-versin">
<h3><a class="doc-anchor" href="#doc-versin">#</a> <code>versin</code></h3>
<p><code>versin</code> — trig extensions builtin.</p>
<pre><code class="lang-perl">my $result = versin $x
# or in a pipeline:
@list |> map versin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-versine">
<h3><a class="doc-anchor" href="#doc-versine">#</a> <code>versine</code></h3>
<p><code>versine</code> — trig extensions builtin. Alias for <code>versin</code>.</p>
<pre><code class="lang-perl">my $result = versine $x
# or in a pipeline:
@list |> map versine |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-version-cmp">
<h3><a class="doc-anchor" href="#doc-version-cmp">#</a> <code>version_cmp</code></h3>
<p><code>version_cmp</code> — file stat / path builtin. Alias for <code>compare_versions</code>.</p>
<pre><code class="lang-perl">my $result = version_cmp $x
# or in a pipeline:
@list |> map version_cmp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vertex-connectivity">
<h3><a class="doc-anchor" href="#doc-vertex-connectivity">#</a> <code>vertex_connectivity</code></h3>
<p><code>vertex_connectivity</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = vertex_connectivity $x
# or in a pipeline:
@list |> map vertex_connectivity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vertex-cover-lp-round">
<h3><a class="doc-anchor" href="#doc-vertex-cover-lp-round">#</a> <code>vertex_cover_lp_round</code></h3>
<p><code>vertex_cover_lp_round</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = vertex_cover_lp_round $x
# or in a pipeline:
@list |> map vertex_cover_lp_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vf2-consistent">
<h3><a class="doc-anchor" href="#doc-vf2-consistent">#</a> <code>vf2_consistent</code></h3>
<p><code>vf2_consistent</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = vf2_consistent $x
# or in a pipeline:
@list |> map vf2_consistent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vickrey-auction">
<h3><a class="doc-anchor" href="#doc-vickrey-auction">#</a> <code>vickrey_auction</code></h3>
<p><code>vickrey_auction</code> — batch 73 builtin.</p>
<pre><code class="lang-perl">my $result = vickrey_auction $x
# or in a pipeline:
@list |> map vickrey_auction |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vigenere-decrypt">
<h3><a class="doc-anchor" href="#doc-vigenere-decrypt">#</a> <code>vigenere_decrypt</code></h3>
<p><code>vigenere_decrypt</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = vigenere_decrypt $x
# or in a pipeline:
@list |> map vigenere_decrypt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vigenere-encrypt">
<h3><a class="doc-anchor" href="#doc-vigenere-encrypt">#</a> <code>vigenere_encrypt</code></h3>
<p><code>vigenere_encrypt</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = vigenere_encrypt $x
# or in a pipeline:
@list |> map vigenere_encrypt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vin-check">
<h3><a class="doc-anchor" href="#doc-vin-check">#</a> <code>vin_check</code></h3>
<p><code>vin_check</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = vin_check $x
# or in a pipeline:
@list |> map vin_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vincenty-dist">
<h3><a class="doc-anchor" href="#doc-vincenty-dist">#</a> <code>vincenty_dist</code></h3>
<p><code>vincenty_dist</code> — batch 58 builtin.</p>
<pre><code class="lang-perl">my $result = vincenty_dist $x
# or in a pipeline:
@list |> map vincenty_dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-virtual-temperature-full">
<h3><a class="doc-anchor" href="#doc-virtual-temperature-full">#</a> <code>virtual_temperature_full</code></h3>
<p><code>virtual_temperature_full</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = virtual_temperature_full $x
# or in a pipeline:
@list |> map virtual_temperature_full |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-viterbi-pos-tag">
<h3><a class="doc-anchor" href="#doc-viterbi-pos-tag">#</a> <code>viterbi_pos_tag</code></h3>
<p><code>viterbi_pos_tag</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = viterbi_pos_tag $x
# or in a pipeline:
@list |> map viterbi_pos_tag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vlookup">
<h3><a class="doc-anchor" href="#doc-vlookup">#</a> <code>vlookup</code></h3>
<p><code>vlookup</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = vlookup $x
# or in a pipeline:
@list |> map vlookup |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vo2-max-estimate">
<h3><a class="doc-anchor" href="#doc-vo2-max-estimate">#</a> <code>vo2_max_estimate</code></h3>
<p><code>vo2_max_estimate</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = vo2_max_estimate $x
# or in a pipeline:
@list |> map vo2_max_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-void">
<h3><a class="doc-anchor" href="#doc-void">#</a> <code>void</code></h3>
<p><code>void</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = void $x
# or in a pipeline:
@list |> map void |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-voigt-profile">
<h3><a class="doc-anchor" href="#doc-voigt-profile">#</a> <code>voigt_profile</code></h3>
<p><code>voigt_profile</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = voigt_profile $x
# or in a pipeline:
@list |> map voigt_profile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-voigt-profile-simple">
<h3><a class="doc-anchor" href="#doc-voigt-profile-simple">#</a> <code>voigt_profile_simple</code></h3>
<p><code>voigt_profile_simple</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = voigt_profile_simple $x
# or in a pipeline:
@list |> map voigt_profile_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-voltage-divider">
<h3><a class="doc-anchor" href="#doc-voltage-divider">#</a> <code>voltage_divider</code></h3>
<p><code>voltage_divider</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = voltage_divider $x
# or in a pipeline:
@list |> map voltage_divider |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-voltaic-efficiency">
<h3><a class="doc-anchor" href="#doc-voltaic-efficiency">#</a> <code>voltaic_efficiency</code></h3>
<p><code>voltaic_efficiency</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = voltaic_efficiency $x
# or in a pipeline:
@list |> map voltaic_efficiency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-volume-form-riemannian">
<h3><a class="doc-anchor" href="#doc-volume-form-riemannian">#</a> <code>volume_form_riemannian</code></h3>
<p><code>volume_form_riemannian</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = volume_form_riemannian $x
# or in a pipeline:
@list |> map volume_form_riemannian |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vqe-step">
<h3><a class="doc-anchor" href="#doc-vqe-step">#</a> <code>vqe_step</code></h3>
<p><code>vqe_step</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = vqe_step $x
# or in a pipeline:
@list |> map vqe_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vsepr-geometry">
<h3><a class="doc-anchor" href="#doc-vsepr-geometry">#</a> <code>vsepr_geometry</code></h3>
<p><code>vsepr_geometry</code> — batch 63 builtin.</p>
<pre><code class="lang-perl">my $result = vsepr_geometry $x
# or in a pipeline:
@list |> map vsepr_geometry |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-w-state">
<h3><a class="doc-anchor" href="#doc-w-state">#</a> <code>w_state</code></h3>
<p><code>w_state</code> — batch 80 builtin.</p>
<pre><code class="lang-perl">my $result = w_state $x
# or in a pipeline:
@list |> map w_state |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-w-state-n">
<h3><a class="doc-anchor" href="#doc-w-state-n">#</a> <code>w_state_n</code></h3>
<p><code>w_state_n</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = w_state_n $x
# or in a pipeline:
@list |> map w_state_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wacc">
<h3><a class="doc-anchor" href="#doc-wacc">#</a> <code>wacc</code></h3>
<p><code>wacc($equity, $debt, $cost_equity, $cost_debt, $tax_rate)</code> — computes Weighted Average Cost of Capital. Returns the blended cost of capital accounting for the tax shield on debt.</p>
<pre><code class="lang-perl">p wacc(60, 40, 0.10, 0.05, 0.25) # ~7.5%
</code></pre>
</article>
<article class="doc-entry" id="doc-wald-test-stat">
<h3><a class="doc-anchor" href="#doc-wald-test-stat">#</a> <code>wald_test_stat</code></h3>
<p><code>wald_test_stat</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = wald_test_stat $x
# or in a pipeline:
@list |> map wald_test_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-walden-product">
<h3><a class="doc-anchor" href="#doc-walden-product">#</a> <code>walden_product</code></h3>
<p><code>walden_product</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = walden_product $x
# or in a pipeline:
@list |> map walden_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-walker-circulation-step">
<h3><a class="doc-anchor" href="#doc-walker-circulation-step">#</a> <code>walker_circulation_step</code></h3>
<p><code>walker_circulation_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = walker_circulation_step $x
# or in a pipeline:
@list |> map walker_circulation_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-walksat-step">
<h3><a class="doc-anchor" href="#doc-walksat-step">#</a> <code>walksat_step</code></h3>
<p><code>walksat_step</code> — batch 67 builtin.</p>
<pre><code class="lang-perl">my $result = walksat_step $x
# or in a pipeline:
@list |> map walksat_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-war-above-replacement">
<h3><a class="doc-anchor" href="#doc-war-above-replacement">#</a> <code>war_above_replacement</code></h3>
<p><code>war_above_replacement</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = war_above_replacement $x
# or in a pipeline:
@list |> map war_above_replacement |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-warburg-impedance">
<h3><a class="doc-anchor" href="#doc-warburg-impedance">#</a> <code>warburg_impedance</code></h3>
<p><code>warburg_impedance</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = warburg_impedance $x
# or in a pipeline:
@list |> map warburg_impedance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-warped-product-step-zero">
<h3><a class="doc-anchor" href="#doc-warped-product-step-zero">#</a> <code>warped_product_step_zero</code></h3>
<p><code>warped_product_step_zero</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = warped_product_step_zero $x
# or in a pipeline:
@list |> map warped_product_step_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-warshall-step">
<h3><a class="doc-anchor" href="#doc-warshall-step">#</a> <code>warshall_step</code></h3>
<p><code>warshall_step</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = warshall_step $x
# or in a pipeline:
@list |> map warshall_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wasserstein-dist-emp">
<h3><a class="doc-anchor" href="#doc-wasserstein-dist-emp">#</a> <code>wasserstein_dist_emp</code></h3>
<p><code>wasserstein_dist_emp</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = wasserstein_dist_emp $x
# or in a pipeline:
@list |> map wasserstein_dist_emp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-watershed-segment">
<h3><a class="doc-anchor" href="#doc-watershed-segment">#</a> <code>watershed_segment</code></h3>
<p><code>watershed_segment</code> — batch 77 builtin.</p>
<pre><code class="lang-perl">my $result = watershed_segment $x
# or in a pipeline:
@list |> map watershed_segment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wattersons-theta">
<h3><a class="doc-anchor" href="#doc-wattersons-theta">#</a> <code>wattersons_theta</code></h3>
<p><code>wattersons_theta</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = wattersons_theta $x
# or in a pipeline:
@list |> map wattersons_theta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-watts-to-hp">
<h3><a class="doc-anchor" href="#doc-watts-to-hp">#</a> <code>watts_to_hp</code></h3>
<p><code>watts_to_hp</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = watts_to_hp $input
</code></pre>
</article>
<article class="doc-entry" id="doc-wave-string-speed">
<h3><a class="doc-anchor" href="#doc-wave-string-speed">#</a> <code>wave_string_speed</code></h3>
<p><code>wave_string_speed</code> — batch 23 builtin.</p>
<pre><code class="lang-perl">my $result = wave_string_speed $x
# or in a pipeline:
@list |> map wave_string_speed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wavelength-freq">
<h3><a class="doc-anchor" href="#doc-wavelength-freq">#</a> <code>wavelength_freq</code></h3>
<p><code>wavelength_freq</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = wavelength_freq $x
# or in a pipeline:
@list |> map wavelength_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wc">
<h3><a class="doc-anchor" href="#doc-wc">#</a> <code>wc</code></h3>
<p><code>wc</code> — trivial string ops builtin. Alias for <code>word_count</code>.</p>
<pre><code class="lang-perl">my $result = wc $x
# or in a pipeline:
@list |> map wc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wcag-contrast">
<h3><a class="doc-anchor" href="#doc-wcag-contrast">#</a> <code>wcag_contrast</code></h3>
<p><code>wcag_contrast</code> — batch 9 builtin. Alias for <code>contrast_ratio_wcag</code>.</p>
<pre><code class="lang-perl">my $result = wcag_contrast $x
# or in a pipeline:
@list |> map wcag_contrast |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wcag-luminance">
<h3><a class="doc-anchor" href="#doc-wcag-luminance">#</a> <code>wcag_luminance</code></h3>
<p><code>wcag_luminance</code> — batch 9 builtin. Alias for <code>relative_luminance</code>.</p>
<pre><code class="lang-perl">my $result = wcag_luminance $x
# or in a pipeline:
@list |> map wcag_luminance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wcag-pass">
<h3><a class="doc-anchor" href="#doc-wcag-pass">#</a> <code>wcag_pass</code></h3>
<p><code>wcag_pass</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = wcag_pass $x
# or in a pipeline:
@list |> map wcag_pass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wcount">
<h3><a class="doc-anchor" href="#doc-wcount">#</a> <code>wcount</code></h3>
<p><code>wcount</code> — extended stdlib batch 3 builtin. Alias for <code>count_words</code>.</p>
<pre><code class="lang-perl">my $result = wcount $x
# or in a pipeline:
@list |> map wcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weak-composition-count">
<h3><a class="doc-anchor" href="#doc-weak-composition-count">#</a> <code>weak_composition_count</code></h3>
<p><code>weak_composition_count</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = weak_composition_count $x
# or in a pipeline:
@list |> map weak_composition_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weaken">
<h3><a class="doc-anchor" href="#doc-weaken">#</a> <code>weaken</code></h3>
<p><code>weaken</code> — list / aggregate builtin.</p>
<pre><code class="lang-perl">my $result = weaken $x
# or in a pipeline:
@list |> map weaken |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weber-number">
<h3><a class="doc-anchor" href="#doc-weber-number">#</a> <code>weber_number</code></h3>
<p><code>weber_number</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = weber_number $x
# or in a pipeline:
@list |> map weber_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weber-number-step">
<h3><a class="doc-anchor" href="#doc-weber-number-step">#</a> <code>weber_number_step</code></h3>
<p><code>weber_number_step</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = weber_number_step $x
# or in a pipeline:
@list |> map weber_number_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-week-number-iso">
<h3><a class="doc-anchor" href="#doc-week-number-iso">#</a> <code>week_number_iso</code></h3>
<p><code>week_number_iso</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = week_number_iso $x
# or in a pipeline:
@list |> map week_number_iso |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-week-of-year">
<h3><a class="doc-anchor" href="#doc-week-of-year">#</a> <code>week_of_year</code></h3>
<p><code>week_of_year</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = week_of_year $x
# or in a pipeline:
@list |> map week_of_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weekday-name">
<h3><a class="doc-anchor" href="#doc-weekday-name">#</a> <code>weekday_name</code></h3>
<p><code>weekday_name</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = weekday_name $x
# or in a pipeline:
@list |> map weekday_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weekday-name-short">
<h3><a class="doc-anchor" href="#doc-weekday-name-short">#</a> <code>weekday_name_short</code></h3>
<p><code>weekday_name_short</code> — batch 52 builtin.</p>
<pre><code class="lang-perl">my $result = weekday_name_short $x
# or in a pipeline:
@list |> map weekday_name_short |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weekday-short">
<h3><a class="doc-anchor" href="#doc-weekday-short">#</a> <code>weekday_short</code></h3>
<p><code>weekday_short</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = weekday_short $x
# or in a pipeline:
@list |> map weekday_short |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weeks-between">
<h3><a class="doc-anchor" href="#doc-weeks-between">#</a> <code>weeks_between</code></h3>
<p><code>weeks_between</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = weeks_between $x
# or in a pipeline:
@list |> map weeks_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weibpdf">
<h3><a class="doc-anchor" href="#doc-weibpdf">#</a> <code>weibpdf</code></h3>
<p><code>weibull_pdf</code> (alias <code>weibpdf</code>) evaluates the Weibull distribution PDF at x with shape k and scale lambda.</p>
<pre><code class="lang-perl">p weibpdf(1.0, 1.5, 1.0)
</code></pre>
</article>
<article class="doc-entry" id="doc-weighted-match-kuhn-step">
<h3><a class="doc-anchor" href="#doc-weighted-match-kuhn-step">#</a> <code>weighted_match_kuhn_step</code></h3>
<p><code>weighted_match_kuhn_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = weighted_match_kuhn_step $x
# or in a pipeline:
@list |> map weighted_match_kuhn_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weighted-mean">
<h3><a class="doc-anchor" href="#doc-weighted-mean">#</a> <code>weighted_mean</code></h3>
<p><code>weighted_mean</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = weighted_mean $x
# or in a pipeline:
@list |> map weighted_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weighted-sample">
<h3><a class="doc-anchor" href="#doc-weighted-sample">#</a> <code>weighted_sample</code></h3>
<p><code>weighted_sample</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = weighted_sample $x
# or in a pipeline:
@list |> map weighted_sample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weighted-set-cover-step">
<h3><a class="doc-anchor" href="#doc-weighted-set-cover-step">#</a> <code>weighted_set_cover_step</code></h3>
<p><code>weighted_set_cover_step</code> — batch 41 builtin.</p>
<pre><code class="lang-perl">my $result = weighted_set_cover_step $x
# or in a pipeline:
@list |> map weighted_set_cover_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weighted-var">
<h3><a class="doc-anchor" href="#doc-weighted-var">#</a> <code>weighted_var</code></h3>
<p><code>weighted_var</code> — weighted variance. Args: values, weights.</p>
<pre><code class="lang-perl">p wvar([1,2,3,4], [1,1,1,1]) # same as var
</code></pre>
</article>
<article class="doc-entry" id="doc-weingarten-map-step">
<h3><a class="doc-anchor" href="#doc-weingarten-map-step">#</a> <code>weingarten_map_step</code></h3>
<p><code>weingarten_map_step</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = weingarten_map_step $x
# or in a pipeline:
@list |> map weingarten_map_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-welch-psd-avg">
<h3><a class="doc-anchor" href="#doc-welch-psd-avg">#</a> <code>welch_psd_avg</code></h3>
<p><code>welch_psd_avg</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = welch_psd_avg $x
# or in a pipeline:
@list |> map welch_psd_avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-welch-ttest">
<h3><a class="doc-anchor" href="#doc-welch-ttest">#</a> <code>welch_ttest</code></h3>
<p><code>welch_ttest</code> (alias <code>welcht</code>) performs Welch's t-test for two independent samples with unequal variances. Returns [t-statistic, degrees of freedom].</p>
<pre><code class="lang-perl">my ($t, $df) = @{welcht([1,2,3,4,5], [3,4,5,6,7])}
p "t=$t df=$df"
</code></pre>
</article>
<article class="doc-entry" id="doc-welch-window">
<h3><a class="doc-anchor" href="#doc-welch-window">#</a> <code>welch_window</code></h3>
<p><code>welch_window</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = welch_window $x
# or in a pipeline:
@list |> map welch_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-welsh-powell">
<h3><a class="doc-anchor" href="#doc-welsh-powell">#</a> <code>welsh_powell</code></h3>
<p><code>welsh_powell</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = welsh_powell $x
# or in a pipeline:
@list |> map welsh_powell |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-werckmeister-iii">
<h3><a class="doc-anchor" href="#doc-werckmeister-iii">#</a> <code>werckmeister_iii</code></h3>
<p><code>werckmeister_iii</code> — batch 64 builtin.</p>
<pre><code class="lang-perl">my $result = werckmeister_iii $x
# or in a pipeline:
@list |> map werckmeister_iii |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-westerlies-jet-speed">
<h3><a class="doc-anchor" href="#doc-westerlies-jet-speed">#</a> <code>westerlies_jet_speed</code></h3>
<p><code>westerlies_jet_speed</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = westerlies_jet_speed $x
# or in a pipeline:
@list |> map westerlies_jet_speed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wet-bulb-potential">
<h3><a class="doc-anchor" href="#doc-wet-bulb-potential">#</a> <code>wet_bulb_potential</code></h3>
<p><code>wet_bulb_potential</code> — batch 42 builtin.</p>
<pre><code class="lang-perl">my $result = wet_bulb_potential $x
# or in a pipeline:
@list |> map wet_bulb_potential |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weyl-group-order">
<h3><a class="doc-anchor" href="#doc-weyl-group-order">#</a> <code>weyl_group_order</code></h3>
<p><code>weyl_group_order</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = weyl_group_order $x
# or in a pipeline:
@list |> map weyl_group_order |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weyl-tensor-step-zero">
<h3><a class="doc-anchor" href="#doc-weyl-tensor-step-zero">#</a> <code>weyl_tensor_step_zero</code></h3>
<p><code>weyl_tensor_step_zero</code> — batch 39 builtin.</p>
<pre><code class="lang-perl">my $result = weyl_tensor_step_zero $x
# or in a pipeline:
@list |> map weyl_tensor_step_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wfrm">
<h3><a class="doc-anchor" href="#doc-wfrm">#</a> <code>wfrm</code></h3>
<p><code>wfrm</code> — go/general functional utilities builtin. Alias for <code>words_from</code>.</p>
<pre><code class="lang-perl">my $result = wfrm $x
# or in a pipeline:
@list |> map wfrm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wh">
<h3><a class="doc-anchor" href="#doc-wh">#</a> <code>wh</code></h3>
<p><code>wh</code> — filesystem extensions builtin. Alias for <code>which</code>.</p>
<pre><code class="lang-perl">my $result = wh $x
# or in a pipeline:
@list |> map wh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wha">
<h3><a class="doc-anchor" href="#doc-wha">#</a> <code>wha</code></h3>
<p>Return a list of all absolute paths matching the given command name across every directory in <code>PATH</code>, not just the first match. The short alias <code>wha</code> keeps things concise. This is useful for detecting shadowed executables or auditing which versions of a tool are installed.</p>
<pre><code class="lang-perl">my @all = which_all("python3")
@all |> e p # /usr/local/bin/python3
# /usr/bin/python3
p scalar wha("perl") # number of perls on PATH
</code></pre>
</article>
<article class="doc-entry" id="doc-when-false">
<h3><a class="doc-anchor" href="#doc-when-false">#</a> <code>when_false</code></h3>
<p><code>when_false</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = when_false $x
# or in a pipeline:
@list |> map when_false |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-when-true">
<h3><a class="doc-anchor" href="#doc-when-true">#</a> <code>when_true</code></h3>
<p><code>when_true</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = when_true $x
# or in a pipeline:
@list |> map when_true |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-which-fn">
<h3><a class="doc-anchor" href="#doc-which-fn">#</a> <code>which_fn</code></h3>
<p><code>which_fn</code> — return indices where a predicate is true. Like R's which().</p>
<pre><code class="lang-perl">my @idx = @{which_fn([1,5,3,8,2], fn { $_[0] > 3 })} # [1, 3]
</code></pre>
</article>
<article class="doc-entry" id="doc-white">
<h3><a class="doc-anchor" href="#doc-white">#</a> <code>white</code></h3>
<p><code>white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = white $x
# or in a pipeline:
@list |> map white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-white-bold">
<h3><a class="doc-anchor" href="#doc-white-bold">#</a> <code>white_bold</code></h3>
<p><code>white_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = white_bold $x
# or in a pipeline:
@list |> map white_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-white-robust-se">
<h3><a class="doc-anchor" href="#doc-white-robust-se">#</a> <code>white_robust_se</code></h3>
<p><code>white_robust_se</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = white_robust_se $x
# or in a pipeline:
@list |> map white_robust_se |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-white-test-stat">
<h3><a class="doc-anchor" href="#doc-white-test-stat">#</a> <code>white_test_stat</code></h3>
<p><code>white_test_stat</code> — batch 36 builtin.</p>
<pre><code class="lang-perl">my $result = white_test_stat $x
# or in a pipeline:
@list |> map white_test_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-whittaker-m">
<h3><a class="doc-anchor" href="#doc-whittaker-m">#</a> <code>whittaker_m</code></h3>
<p><code>whittaker_m</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = whittaker_m $x
# or in a pipeline:
@list |> map whittaker_m |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-whole-life-a">
<h3><a class="doc-anchor" href="#doc-whole-life-a">#</a> <code>whole_life_a</code></h3>
<p><code>whole_life_a</code> — batch 60 builtin.</p>
<pre><code class="lang-perl">my $result = whole_life_a $x
# or in a pipeline:
@list |> map whole_life_a |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wieferich-check">
<h3><a class="doc-anchor" href="#doc-wieferich-check">#</a> <code>wieferich_check</code></h3>
<p><code>wieferich_check</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = wieferich_check $x
# or in a pipeline:
@list |> map wieferich_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wien">
<h3><a class="doc-anchor" href="#doc-wien">#</a> <code>wien</code></h3>
<p><code>wien</code> — physics formulas builtin. Alias for <code>wien_displacement</code>.</p>
<pre><code class="lang-perl">my $result = wien $x
# or in a pipeline:
@list |> map wien |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wien-constant">
<h3><a class="doc-anchor" href="#doc-wien-constant">#</a> <code>wien_constant</code></h3>
<p><code>wien_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = wien_constant $x
# or in a pipeline:
@list |> map wien_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wien-displacement">
<h3><a class="doc-anchor" href="#doc-wien-displacement">#</a> <code>wien_displacement</code></h3>
<p><code>wien_displacement</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = wien_displacement $x
# or in a pipeline:
@list |> map wien_displacement |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wiener-filter">
<h3><a class="doc-anchor" href="#doc-wiener-filter">#</a> <code>wiener_filter</code></h3>
<p><code>wiener_filter</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = wiener_filter $x
# or in a pipeline:
@list |> map wiener_filter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wigner-3j-bound">
<h3><a class="doc-anchor" href="#doc-wigner-3j-bound">#</a> <code>wigner_3j_bound</code></h3>
<p><code>wigner_3j_bound</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = wigner_3j_bound $x
# or in a pipeline:
@list |> map wigner_3j_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wilcoxon">
<h3><a class="doc-anchor" href="#doc-wilcoxon">#</a> <code>wilcoxon</code></h3>
<p><code>wilcoxon</code> — batch 53 builtin.</p>
<pre><code class="lang-perl">my $result = wilcoxon $x
# or in a pipeline:
@list |> map wilcoxon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wilson-test">
<h3><a class="doc-anchor" href="#doc-wilson-test">#</a> <code>wilson_test</code></h3>
<p><code>wilson_test</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = wilson_test $x
# or in a pipeline:
@list |> map wilson_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wilson-theta-step">
<h3><a class="doc-anchor" href="#doc-wilson-theta-step">#</a> <code>wilson_theta_step</code></h3>
<p><code>wilson_theta_step</code> — batch 34 builtin.</p>
<pre><code class="lang-perl">my $result = wilson_theta_step $x
# or in a pipeline:
@list |> map wilson_theta_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-win-probability">
<h3><a class="doc-anchor" href="#doc-win-probability">#</a> <code>win_probability</code></h3>
<p><code>win_probability</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = win_probability $x
# or in a pipeline:
@list |> map win_probability |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wincirc">
<h3><a class="doc-anchor" href="#doc-wincirc">#</a> <code>wincirc</code></h3>
<p><code>wincirc</code> — additional missing stdlib functions builtin. Alias for <code>windowed_circular</code>.</p>
<pre><code class="lang-perl">my $result = wincirc $x
# or in a pipeline:
@list |> map wincirc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wind-chill">
<h3><a class="doc-anchor" href="#doc-wind-chill">#</a> <code>wind_chill</code></h3>
<p><code>wind_chill</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = wind_chill $x
# or in a pipeline:
@list |> map wind_chill |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wind-chill-celsius">
<h3><a class="doc-anchor" href="#doc-wind-chill-celsius">#</a> <code>wind_chill_celsius</code></h3>
<p><code>wind_chill_celsius</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = wind_chill_celsius $x
# or in a pipeline:
@list |> map wind_chill_celsius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-window-n">
<h3><a class="doc-anchor" href="#doc-window-n">#</a> <code>window_n</code></h3>
<p><code>window_n</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = window_n $x
# or in a pipeline:
@list |> map window_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-windowed-circular">
<h3><a class="doc-anchor" href="#doc-windowed-circular">#</a> <code>windowed_circular</code></h3>
<p><code>windowed_circular</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = windowed_circular $x
# or in a pipeline:
@list |> map windowed_circular |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-winn">
<h3><a class="doc-anchor" href="#doc-winn">#</a> <code>winn</code></h3>
<p><code>winn</code> — go/general functional utilities builtin. Alias for <code>window_n</code>.</p>
<pre><code class="lang-perl">my $result = winn $x
# or in a pipeline:
@list |> map winn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-winsor">
<h3><a class="doc-anchor" href="#doc-winsor">#</a> <code>winsor</code></h3>
<p><code>winsor</code> — math / numeric (uncategorized batch) builtin. Alias for <code>winsorize</code>.</p>
<pre><code class="lang-perl">my $result = winsor $x
# or in a pipeline:
@list |> map winsor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-winsorize">
<h3><a class="doc-anchor" href="#doc-winsorize">#</a> <code>winsorize</code></h3>
<p><code>winsorize</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = winsorize $x
# or in a pipeline:
@list |> map winsorize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-winsorized-variance-arr">
<h3><a class="doc-anchor" href="#doc-winsorized-variance-arr">#</a> <code>winsorized_variance_arr</code></h3>
<p><code>winsorized_variance_arr</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = winsorized_variance_arr $x
# or in a pipeline:
@list |> map winsorized_variance_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wire-resistance">
<h3><a class="doc-anchor" href="#doc-wire-resistance">#</a> <code>wire_resistance</code></h3>
<p><code>wire_resistance</code> — batch 12 builtin.</p>
<pre><code class="lang-perl">my $result = wire_resistance $x
# or in a pipeline:
@list |> map wire_resistance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-without">
<h3><a class="doc-anchor" href="#doc-without">#</a> <code>without</code></h3>
<p><code>without</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = without $x
# or in a pipeline:
@list |> map without |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-without-nth">
<h3><a class="doc-anchor" href="#doc-without-nth">#</a> <code>without_nth</code></h3>
<p><code>without_nth</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = without_nth $x
# or in a pipeline:
@list |> map without_nth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wmean">
<h3><a class="doc-anchor" href="#doc-wmean">#</a> <code>wmean</code></h3>
<p><code>wmean</code> — math / numeric (uncategorized batch) builtin. Alias for <code>weighted_mean</code>.</p>
<pre><code class="lang-perl">my $result = wmean $x
# or in a pipeline:
@list |> map wmean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-woba-weight">
<h3><a class="doc-anchor" href="#doc-woba-weight">#</a> <code>woba_weight</code></h3>
<p><code>woba_weight</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = woba_weight $x
# or in a pipeline:
@list |> map woba_weight |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wofz">
<h3><a class="doc-anchor" href="#doc-wofz">#</a> <code>wofz</code></h3>
<p><code>wofz</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = wofz $x
# or in a pipeline:
@list |> map wofz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wolfe-strong-q">
<h3><a class="doc-anchor" href="#doc-wolfe-strong-q">#</a> <code>wolfe_strong_q</code></h3>
<p><code>wolfe_strong_q</code> — batch 19 builtin.</p>
<pre><code class="lang-perl">my $result = wolfe_strong_q $x
# or in a pipeline:
@list |> map wolfe_strong_q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-woodall-number">
<h3><a class="doc-anchor" href="#doc-woodall-number">#</a> <code>woodall_number</code></h3>
<p><code>woodall_number</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = woodall_number $x
# or in a pipeline:
@list |> map woodall_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-alignment-ibm1">
<h3><a class="doc-anchor" href="#doc-word-alignment-ibm1">#</a> <code>word_alignment_ibm1</code></h3>
<p><code>word_alignment_ibm1</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = word_alignment_ibm1 $x
# or in a pipeline:
@list |> map word_alignment_ibm1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-alignment-ibm2">
<h3><a class="doc-anchor" href="#doc-word-alignment-ibm2">#</a> <code>word_alignment_ibm2</code></h3>
<p><code>word_alignment_ibm2</code> — batch 69 builtin.</p>
<pre><code class="lang-perl">my $result = word_alignment_ibm2 $x
# or in a pipeline:
@list |> map word_alignment_ibm2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-count">
<h3><a class="doc-anchor" href="#doc-word-count">#</a> <code>word_count</code></h3>
<p><code>word_count</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = word_count $x
# or in a pipeline:
@list |> map word_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-count-simple">
<h3><a class="doc-anchor" href="#doc-word-count-simple">#</a> <code>word_count_simple</code></h3>
<p><code>word_count_simple</code> — batch 11 builtin. Alias for <code>string_words_count</code>.</p>
<pre><code class="lang-perl">my $result = word_count_simple $x
# or in a pipeline:
@list |> map word_count_simple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-frequencies">
<h3><a class="doc-anchor" href="#doc-word-frequencies">#</a> <code>word_frequencies</code></h3>
<p><code>word_frequencies</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = word_frequencies $x
# or in a pipeline:
@list |> map word_frequencies |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-similarity">
<h3><a class="doc-anchor" href="#doc-word-similarity">#</a> <code>word_similarity</code></h3>
<p><code>word_similarity</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = word_similarity $x
# or in a pipeline:
@list |> map word_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-wrap-text">
<h3><a class="doc-anchor" href="#doc-word-wrap-text">#</a> <code>word_wrap_text</code></h3>
<p><code>word_wrap_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = word_wrap_text $x
# or in a pipeline:
@list |> map word_wrap_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wordfreq">
<h3><a class="doc-anchor" href="#doc-wordfreq">#</a> <code>wordfreq</code></h3>
<p><code>wordfreq</code> — string processing (uncategorized batch) builtin. Alias for <code>word_frequencies</code>.</p>
<pre><code class="lang-perl">my $result = wordfreq $x
# or in a pipeline:
@list |> map wordfreq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-words-from">
<h3><a class="doc-anchor" href="#doc-words-from">#</a> <code>words_from</code></h3>
<p><code>words_from</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = words_from $x
# or in a pipeline:
@list |> map words_from |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-work">
<h3><a class="doc-anchor" href="#doc-work">#</a> <code>work</code></h3>
<p><code>work($force, $distance, $angle)</code> — compute work W = F×d×cos(θ) (Joules). Angle in degrees, default 0.</p>
<pre><code class="lang-perl">p work(100, 10) # 1000 J (force parallel to motion)
p work(100, 10, 60) # 500 J (force at 60°)
</code></pre>
</article>
<article class="doc-entry" id="doc-woy">
<h3><a class="doc-anchor" href="#doc-woy">#</a> <code>woy</code></h3>
<p><code>woy</code> — extended stdlib batch 3 builtin. Alias for <code>week_of_year</code>.</p>
<pre><code class="lang-perl">my $result = woy $x
# or in a pipeline:
@list |> map woy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wpa">
<h3><a class="doc-anchor" href="#doc-wpa">#</a> <code>wpa</code></h3>
<p><code>wpa</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = wpa $x
# or in a pipeline:
@list |> map wpa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrap-around">
<h3><a class="doc-anchor" href="#doc-wrap-around">#</a> <code>wrap_around</code></h3>
<p><code>wrap_around</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = wrap_around $x
# or in a pipeline:
@list |> map wrap_around |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrap-index">
<h3><a class="doc-anchor" href="#doc-wrap-index">#</a> <code>wrap_index</code></h3>
<p><code>wrap_index</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = wrap_index $x
# or in a pipeline:
@list |> map wrap_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrap-range">
<h3><a class="doc-anchor" href="#doc-wrap-range">#</a> <code>wrap_range</code></h3>
<p><code>wrap_range</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = wrap_range $x
# or in a pipeline:
@list |> map wrap_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrap-text">
<h3><a class="doc-anchor" href="#doc-wrap-text">#</a> <code>wrap_text</code></h3>
<p><code>wrap_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = wrap_text $x
# or in a pipeline:
@list |> map wrap_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrc-plus">
<h3><a class="doc-anchor" href="#doc-wrc-plus">#</a> <code>wrc_plus</code></h3>
<p><code>wrc_plus</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = wrc_plus $x
# or in a pipeline:
@list |> map wrc_plus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wright-omega">
<h3><a class="doc-anchor" href="#doc-wright-omega">#</a> <code>wright_omega</code></h3>
<p><code>wright_omega</code> — batch 29 builtin.</p>
<pre><code class="lang-perl">my $result = wright_omega $x
# or in a pipeline:
@list |> map wright_omega |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-writhe-polygon">
<h3><a class="doc-anchor" href="#doc-writhe-polygon">#</a> <code>writhe_polygon</code></h3>
<p><code>writhe_polygon</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = writhe_polygon $x
# or in a pipeline:
@list |> map writhe_polygon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrprng">
<h3><a class="doc-anchor" href="#doc-wrprng">#</a> <code>wrprng</code></h3>
<p><code>wrprng</code> — extended stdlib builtin. Alias for <code>wrap_range</code>.</p>
<pre><code class="lang-perl">my $result = wrprng $x
# or in a pipeline:
@list |> map wrprng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrpt">
<h3><a class="doc-anchor" href="#doc-wrpt">#</a> <code>wrpt</code></h3>
<p><code>wrpt</code> — extended stdlib builtin. Alias for <code>wrap_text</code>.</p>
<pre><code class="lang-perl">my $result = wrpt $x
# or in a pipeline:
@list |> map wrpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wsamp">
<h3><a class="doc-anchor" href="#doc-wsamp">#</a> <code>wsamp</code></h3>
<p><code>wsamp</code> — extended stdlib builtin. Alias for <code>weighted_sample</code>.</p>
<pre><code class="lang-perl">my $result = wsamp $x
# or in a pipeline:
@list |> map wsamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wwrap">
<h3><a class="doc-anchor" href="#doc-wwrap">#</a> <code>wwrap</code></h3>
<p><code>wwrap</code> — extended stdlib builtin. Alias for <code>word_wrap_text</code>.</p>
<pre><code class="lang-perl">my $result = wwrap $x
# or in a pipeline:
@list |> map wwrap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-www-auth-parse">
<h3><a class="doc-anchor" href="#doc-www-auth-parse">#</a> <code>www_auth_parse</code></h3>
<p><code>www_auth_parse</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = www_auth_parse $x
# or in a pipeline:
@list |> map www_auth_parse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wyhash-mix">
<h3><a class="doc-anchor" href="#doc-wyhash-mix">#</a> <code>wyhash_mix</code></h3>
<p><code>wyhash_mix</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = wyhash_mix $x
# or in a pipeline:
@list |> map wyhash_mix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wynn-epsilon">
<h3><a class="doc-anchor" href="#doc-wynn-epsilon">#</a> <code>wynn_epsilon</code></h3>
<p><code>wynn_epsilon</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = wynn_epsilon $x
# or in a pipeline:
@list |> map wynn_epsilon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-x25519-field-mul">
<h3><a class="doc-anchor" href="#doc-x25519-field-mul">#</a> <code>x25519_field_mul</code></h3>
<p><code>x25519_field_mul</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = x25519_field_mul $x
# or in a pipeline:
@list |> map x25519_field_mul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xadd">
<h3><a class="doc-anchor" href="#doc-xadd">#</a> <code>xadd</code></h3>
<p><code>xadd</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = xadd $x
# or in a pipeline:
@list |> map xadd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xd">
<h3><a class="doc-anchor" href="#doc-xd">#</a> <code>xd</code></h3>
<p><code>xd</code> — serialization (stryke-only encoders) builtin. Alias for <code>xml_decode</code>.</p>
<pre><code class="lang-perl">my $result = xd $x
# or in a pipeline:
@list |> map xd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xe">
<h3><a class="doc-anchor" href="#doc-xe">#</a> <code>xe</code></h3>
<p><code>xe</code> — serialization (stryke-only encoders) builtin. Alias for <code>xml_encode</code>.</p>
<pre><code class="lang-perl">my $result = xe $x
# or in a pipeline:
@list |> map xe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xentropy">
<h3><a class="doc-anchor" href="#doc-xentropy">#</a> <code>xentropy</code></h3>
<p><code>xentropy</code> — math / numeric (uncategorized batch) builtin. Alias for <code>cross_entropy</code>.</p>
<pre><code class="lang-perl">my $result = xentropy $x
# or in a pipeline:
@list |> map xentropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xfip">
<h3><a class="doc-anchor" href="#doc-xfip">#</a> <code>xfip</code></h3>
<p><code>xfip</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = xfip $x
# or in a pipeline:
@list |> map xfip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xirr">
<h3><a class="doc-anchor" href="#doc-xirr">#</a> <code>xirr</code></h3>
<p><code>xirr(\@cashflows, \@dates)</code> — computes IRR for irregularly-spaced cash flows. Dates can be epoch timestamps or date strings. More accurate than <code>irr</code> for real-world investments.</p>
<pre><code class="lang-perl">my @cf = (-1000, 500, 600)
my @dates = ('2020-01-01', '2020-07-01', '2021-01-01')
p xirr(\@cf, \@dates)
</code></pre>
</article>
<article class="doc-entry" id="doc-xlen">
<h3><a class="doc-anchor" href="#doc-xlen">#</a> <code>xlen</code></h3>
<p><code>xlen</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = xlen $x
# or in a pipeline:
@list |> map xlen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xlookup">
<h3><a class="doc-anchor" href="#doc-xlookup">#</a> <code>xlookup</code></h3>
<p><code>xlookup</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = xlookup $x
# or in a pipeline:
@list |> map xlookup |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xmlagg">
<h3><a class="doc-anchor" href="#doc-xmlagg">#</a> <code>xmlagg</code></h3>
<p><code>xmlagg</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = xmlagg $x
# or in a pipeline:
@list |> map xmlagg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xmlforest">
<h3><a class="doc-anchor" href="#doc-xmlforest">#</a> <code>xmlforest</code></h3>
<p><code>xmlforest</code> — batch 70 builtin.</p>
<pre><code class="lang-perl">my $result = xmlforest $x
# or in a pipeline:
@list |> map xmlforest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xnpv">
<h3><a class="doc-anchor" href="#doc-xnpv">#</a> <code>xnpv</code></h3>
<p><code>xnpv</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = xnpv $x
# or in a pipeline:
@list |> map xnpv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xor-bool">
<h3><a class="doc-anchor" href="#doc-xor-bool">#</a> <code>xor_bool</code></h3>
<p><code>xor_bool</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = xor_bool $x
# or in a pipeline:
@list |> map xor_bool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xor-break-singlebyte">
<h3><a class="doc-anchor" href="#doc-xor-break-singlebyte">#</a> <code>xor_break_singlebyte</code></h3>
<p><code>xor_break_singlebyte</code> — batch 35 builtin.</p>
<pre><code class="lang-perl">my $result = xor_break_singlebyte $x
# or in a pipeline:
@list |> map xor_break_singlebyte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xor-brute-keylen">
<h3><a class="doc-anchor" href="#doc-xor-brute-keylen">#</a> <code>xor_brute_keylen</code></h3>
<p><code>xor_brute_keylen</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = xor_brute_keylen $x
# or in a pipeline:
@list |> map xor_brute_keylen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xor-byte-string">
<h3><a class="doc-anchor" href="#doc-xor-byte-string">#</a> <code>xor_byte_string</code></h3>
<p><code>xor_byte_string</code> — batches 17-18 builtin.</p>
<pre><code class="lang-perl">my $result = xor_byte_string $x
# or in a pipeline:
@list |> map xor_byte_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xor-cipher-byte">
<h3><a class="doc-anchor" href="#doc-xor-cipher-byte">#</a> <code>xor_cipher_byte</code></h3>
<p><code>xor_cipher_byte</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = xor_cipher_byte $x
# or in a pipeline:
@list |> map xor_cipher_byte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xor-strings">
<h3><a class="doc-anchor" href="#doc-xor-strings">#</a> <code>xor_strings</code></h3>
<p><code>xor_strings</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = xor_strings $x
# or in a pipeline:
@list |> map xor_strings |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xorshift32">
<h3><a class="doc-anchor" href="#doc-xorshift32">#</a> <code>xorshift32</code></h3>
<p><code>xorshift32</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = xorshift32 $x
# or in a pipeline:
@list |> map xorshift32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xorshift32-step">
<h3><a class="doc-anchor" href="#doc-xorshift32-step">#</a> <code>xorshift32_step</code></h3>
<p><code>xorshift32_step</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = xorshift32_step $x
# or in a pipeline:
@list |> map xorshift32_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xorshift64">
<h3><a class="doc-anchor" href="#doc-xorshift64">#</a> <code>xorshift64</code></h3>
<p><code>xorshift64</code> — batch 26 builtin.</p>
<pre><code class="lang-perl">my $result = xorshift64 $x
# or in a pipeline:
@list |> map xorshift64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xrange">
<h3><a class="doc-anchor" href="#doc-xrange">#</a> <code>xrange</code></h3>
<p><code>xrange</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = xrange $x
# or in a pipeline:
@list |> map xrange |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xtea-round">
<h3><a class="doc-anchor" href="#doc-xtea-round">#</a> <code>xtea_round</code></h3>
<p><code>xtea_round</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = xtea_round $x
# or in a pipeline:
@list |> map xtea_round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xyz-to-lab">
<h3><a class="doc-anchor" href="#doc-xyz-to-lab">#</a> <code>xyz_to_lab</code></h3>
<p><code>xyz_to_lab</code> — batch 30 builtin.</p>
<pre><code class="lang-perl">my $result = xyz_to_lab $input
</code></pre>
</article>
<article class="doc-entry" id="doc-xyz-to-rgb">
<h3><a class="doc-anchor" href="#doc-xyz-to-rgb">#</a> <code>xyz_to_rgb</code></h3>
<p><code>xyz_to_rgb</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = xyz_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-yamanouchi-word-count">
<h3><a class="doc-anchor" href="#doc-yamanouchi-word-count">#</a> <code>yamanouchi_word_count</code></h3>
<p><code>yamanouchi_word_count</code> — batch 37 builtin.</p>
<pre><code class="lang-perl">my $result = yamanouchi_word_count $x
# or in a pipeline:
@list |> map yamanouchi_word_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yards-per-attempt">
<h3><a class="doc-anchor" href="#doc-yards-per-attempt">#</a> <code>yards_per_attempt</code></h3>
<p><code>yards_per_attempt</code> — batch 56 builtin.</p>
<pre><code class="lang-perl">my $result = yards_per_attempt $x
# or in a pipeline:
@list |> map yards_per_attempt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yards-to-m">
<h3><a class="doc-anchor" href="#doc-yards-to-m">#</a> <code>yards_to_m</code></h3>
<p><code>yards_to_m</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = yards_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-yd">
<h3><a class="doc-anchor" href="#doc-yd">#</a> <code>yd</code></h3>
<p><code>yd</code> — serialization (stryke-only encoders) builtin. Alias for <code>yaml_decode</code>.</p>
<pre><code class="lang-perl">my $result = yd $x
# or in a pipeline:
@list |> map yd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ye">
<h3><a class="doc-anchor" href="#doc-ye">#</a> <code>ye</code></h3>
<p><code>ye</code> — serialization (stryke-only encoders) builtin. Alias for <code>yaml_encode</code>.</p>
<pre><code class="lang-perl">my $result = ye $x
# or in a pipeline:
@list |> map ye |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-years-between">
<h3><a class="doc-anchor" href="#doc-years-between">#</a> <code>years_between</code></h3>
<p><code>years_between</code> — batch 9 builtin.</p>
<pre><code class="lang-perl">my $result = years_between $x
# or in a pipeline:
@list |> map years_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yellow">
<h3><a class="doc-anchor" href="#doc-yellow">#</a> <code>yellow</code></h3>
<p><code>yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = yellow $x
# or in a pipeline:
@list |> map yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yellow-bold">
<h3><a class="doc-anchor" href="#doc-yellow-bold">#</a> <code>yellow_bold</code></h3>
<p><code>yellow_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = yellow_bold $x
# or in a pipeline:
@list |> map yellow_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yen-k-shortest">
<h3><a class="doc-anchor" href="#doc-yen-k-shortest">#</a> <code>yen_k_shortest</code></h3>
<p><code>yen_k_shortest</code> — batch 75 builtin.</p>
<pre><code class="lang-perl">my $result = yen_k_shortest $x
# or in a pipeline:
@list |> map yen_k_shortest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yesterday">
<h3><a class="doc-anchor" href="#doc-yesterday">#</a> <code>yesterday</code></h3>
<p><code>yesterday</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = yesterday $x
# or in a pipeline:
@list |> map yesterday |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yield-to-maturity">
<h3><a class="doc-anchor" href="#doc-yield-to-maturity">#</a> <code>yield_to_maturity</code></h3>
<p><code>yield_to_maturity</code> — batch 57 builtin.</p>
<pre><code class="lang-perl">my $result = yield_to_maturity $input
</code></pre>
</article>
<article class="doc-entry" id="doc-yielddisc">
<h3><a class="doc-anchor" href="#doc-yielddisc">#</a> <code>yielddisc</code></h3>
<p><code>yielddisc</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = yielddisc $x
# or in a pipeline:
@list |> map yielddisc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yieldmat">
<h3><a class="doc-anchor" href="#doc-yieldmat">#</a> <code>yieldmat</code></h3>
<p><code>yieldmat</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = yieldmat $x
# or in a pipeline:
@list |> map yieldmat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ylll-pml">
<h3><a class="doc-anchor" href="#doc-ylll-pml">#</a> <code>ylll_pml</code></h3>
<p><code>ylll_pml</code> — batch 61 builtin.</p>
<pre><code class="lang-perl">my $result = ylll_pml $x
# or in a pipeline:
@list |> map ylll_pml |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yn">
<h3><a class="doc-anchor" href="#doc-yn">#</a> <code>yn</code></h3>
<p><code>yn</code> — batch 72 builtin.</p>
<pre><code class="lang-perl">my $result = yn $x
# or in a pipeline:
@list |> map yn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ytm-newton">
<h3><a class="doc-anchor" href="#doc-ytm-newton">#</a> <code>ytm_newton</code></h3>
<p><code>ytm_newton</code> — batch 20 builtin.</p>
<pre><code class="lang-perl">my $result = ytm_newton $x
# or in a pipeline:
@list |> map ytm_newton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yuv-to-rgb">
<h3><a class="doc-anchor" href="#doc-yuv-to-rgb">#</a> <code>yuv_to_rgb</code></h3>
<p><code>yuv_to_rgb</code> — batch 82 builtin.</p>
<pre><code class="lang-perl">my $result = yuv_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-z-array">
<h3><a class="doc-anchor" href="#doc-z-array">#</a> <code>z_array</code></h3>
<p><code>z_array</code> — batch 10 builtin.</p>
<pre><code class="lang-perl">my $result = z_array $x
# or in a pipeline:
@list |> map z_array |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-z-func">
<h3><a class="doc-anchor" href="#doc-z-func">#</a> <code>z_func</code></h3>
<p><code>z_func</code> — batch 10 builtin. Alias for <code>z_array</code>.</p>
<pre><code class="lang-perl">my $result = z_func $x
# or in a pipeline:
@list |> map z_func |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-z-function-alt">
<h3><a class="doc-anchor" href="#doc-z-function-alt">#</a> <code>z_function_alt</code></h3>
<p><code>z_function_alt</code> — batches 14-16 builtin.</p>
<pre><code class="lang-perl">my $result = z_function_alt $x
# or in a pipeline:
@list |> map z_function_alt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-z-score">
<h3><a class="doc-anchor" href="#doc-z-score">#</a> <code>z_score</code></h3>
<p><code>z_score($value, $mean, $stddev)</code> — computes the z-score (standard score) of a value given the population mean and standard deviation. Returns how many standard deviations the value is from the mean. Useful for standardizing data and detecting outliers.</p>
<pre><code class="lang-perl">my $z = z_score(85, 75, 10)
p $z # 1 (one stddev above mean)
p z_score(50, 60, 5) # -2
</code></pre>
</article>
<article class="doc-entry" id="doc-z-score-robust">
<h3><a class="doc-anchor" href="#doc-z-score-robust">#</a> <code>z_score_robust</code></h3>
<p><code>z_score_robust</code> — batch 11 builtin.</p>
<pre><code class="lang-perl">my $result = z_score_robust $x
# or in a pipeline:
@list |> map z_score_robust |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-z-scores">
<h3><a class="doc-anchor" href="#doc-z-scores">#</a> <code>z_scores</code></h3>
<p><code>z_scores(@data)</code> — computes z-scores for all values in a list, returning an arrayref of standardized values. Each z-score indicates how many standard deviations that value is from the mean of the dataset. Useful for comparing values across different scales.</p>
<pre><code class="lang-perl">my @grades = (70, 80, 90)
my $zs = z_scores(@grades)
p @$zs # (-1, 0, 1)
@data |> z_scores |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-zadd">
<h3><a class="doc-anchor" href="#doc-zadd">#</a> <code>zadd</code></h3>
<p><code>zadd</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zadd $x
# or in a pipeline:
@list |> map zadd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zalgo">
<h3><a class="doc-anchor" href="#doc-zalgo">#</a> <code>zalgo</code></h3>
<p><code>zalgo</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = zalgo $x
# or in a pipeline:
@list |> map zalgo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zall">
<h3><a class="doc-anchor" href="#doc-zall">#</a> <code>zall</code></h3>
<p><code>zall</code> — go/general functional utilities builtin. Alias for <code>zip_all</code>.</p>
<pre><code class="lang-perl">my $result = zall $x
# or in a pipeline:
@list |> map zall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zcard">
<h3><a class="doc-anchor" href="#doc-zcard">#</a> <code>zcard</code></h3>
<p><code>zcard</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zcard $x
# or in a pipeline:
@list |> map zcard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zcount">
<h3><a class="doc-anchor" href="#doc-zcount">#</a> <code>zcount</code></h3>
<p><code>zcount</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zcount $x
# or in a pipeline:
@list |> map zcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zcross">
<h3><a class="doc-anchor" href="#doc-zcross">#</a> <code>zcross</code></h3>
<p><code>zcross</code> — matrix operations (uncategorized batch) builtin. Alias for <code>zero_crossings</code>.</p>
<pre><code class="lang-perl">my $result = zcross $x
# or in a pipeline:
@list |> map zcross |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeeman-energy">
<h3><a class="doc-anchor" href="#doc-zeeman-energy">#</a> <code>zeeman_energy</code></h3>
<p><code>zeeman_energy</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = zeeman_energy $x
# or in a pipeline:
@list |> map zeeman_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeller-day-of-week">
<h3><a class="doc-anchor" href="#doc-zeller-day-of-week">#</a> <code>zeller_day_of_week</code></h3>
<p><code>zeller_day_of_week</code> — batch 13 builtin.</p>
<pre><code class="lang-perl">my $result = zeller_day_of_week $x
# or in a pipeline:
@list |> map zeller_day_of_week |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeno-survival">
<h3><a class="doc-anchor" href="#doc-zeno-survival">#</a> <code>zeno_survival</code></h3>
<p><code>zeno_survival</code> — batch 32 builtin.</p>
<pre><code class="lang-perl">my $result = zeno_survival $x
# or in a pipeline:
@list |> map zeno_survival |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zero">
<h3><a class="doc-anchor" href="#doc-zero">#</a> <code>zero</code></h3>
<p><code>zero</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = zero $x
# or in a pipeline:
@list |> map zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zero-crossings">
<h3><a class="doc-anchor" href="#doc-zero-crossings">#</a> <code>zero_crossings</code></h3>
<p><code>zero_crossings</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = zero_crossings $x
# or in a pipeline:
@list |> map zero_crossings |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zero-order-concentration">
<h3><a class="doc-anchor" href="#doc-zero-order-concentration">#</a> <code>zero_order_concentration</code></h3>
<p><code>zero_order_concentration</code> — batch 21 builtin.</p>
<pre><code class="lang-perl">my $result = zero_order_concentration $x
# or in a pipeline:
@list |> map zero_order_concentration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zero-pad">
<h3><a class="doc-anchor" href="#doc-zero-pad">#</a> <code>zero_pad</code></h3>
<p><code>zero_pad</code> — batch 25 builtin.</p>
<pre><code class="lang-perl">my $result = zero_pad $x
# or in a pipeline:
@list |> map zero_pad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zero-sum-minmax">
<h3><a class="doc-anchor" href="#doc-zero-sum-minmax">#</a> <code>zero_sum_minmax</code></h3>
<p><code>zero_sum_minmax</code> — batch 43 builtin.</p>
<pre><code class="lang-perl">my $result = zero_sum_minmax $x
# or in a pipeline:
@list |> map zero_sum_minmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeros">
<h3><a class="doc-anchor" href="#doc-zeros">#</a> <code>zeros</code></h3>
<p><code>zeros</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = zeros $x
# or in a pipeline:
@list |> map zeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeros-mat">
<h3><a class="doc-anchor" href="#doc-zeros-mat">#</a> <code>zeros_mat</code></h3>
<p><code>zeros_mat</code> — matrix / linear algebra builtin. Alias for <code>zeros_matrix</code>.</p>
<pre><code class="lang-perl">my $result = zeros_mat $x
# or in a pipeline:
@list |> map zeros_mat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeros-matrix">
<h3><a class="doc-anchor" href="#doc-zeros-matrix">#</a> <code>zeros_matrix</code></h3>
<p><code>zeros_matrix</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = zeros_matrix $x
# or in a pipeline:
@list |> map zeros_matrix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeta-potential-estimate">
<h3><a class="doc-anchor" href="#doc-zeta-potential-estimate">#</a> <code>zeta_potential_estimate</code></h3>
<p><code>zeta_potential_estimate</code> — batch 38 builtin.</p>
<pre><code class="lang-perl">my $result = zeta_potential_estimate $x
# or in a pipeline:
@list |> map zeta_potential_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zfill">
<h3><a class="doc-anchor" href="#doc-zfill">#</a> <code>zfill</code></h3>
<p><code>zfill</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = zfill $x
# or in a pipeline:
@list |> map zfill |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zfill-num">
<h3><a class="doc-anchor" href="#doc-zfill-num">#</a> <code>zfill_num</code></h3>
<p><code>zfill_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = zfill_num $x
# or in a pipeline:
@list |> map zfill_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zgemm">
<h3><a class="doc-anchor" href="#doc-zgemm">#</a> <code>zgemm</code></h3>
<p><code>zgemm</code> — batch 66 builtin.</p>
<pre><code class="lang-perl">my $result = zgemm $x
# or in a pipeline:
@list |> map zgemm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zincrby">
<h3><a class="doc-anchor" href="#doc-zincrby">#</a> <code>zincrby</code></h3>
<p><code>zincrby</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zincrby $x
# or in a pipeline:
@list |> map zincrby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-all">
<h3><a class="doc-anchor" href="#doc-zip-all">#</a> <code>zip_all</code></h3>
<p><code>zip_all</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = zip_all $x
# or in a pipeline:
@list |> map zip_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-apply">
<h3><a class="doc-anchor" href="#doc-zip-apply">#</a> <code>zip_apply</code></h3>
<p><code>zip_apply</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = zip_apply $x
# or in a pipeline:
@list |> map zip_apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-archive">
<h3><a class="doc-anchor" href="#doc-zip-archive">#</a> <code>zip_archive</code></h3>
<p><code>zip_archive</code> — crypto / encoding builtin. Alias for <code>zip_create</code>.</p>
<pre><code class="lang-perl">my $result = zip_archive $x
# or in a pipeline:
@list |> map zip_archive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-central-dir">
<h3><a class="doc-anchor" href="#doc-zip-central-dir">#</a> <code>zip_central_dir</code></h3>
<p><code>zip_central_dir</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = zip_central_dir $x
# or in a pipeline:
@list |> map zip_central_dir |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-eocd">
<h3><a class="doc-anchor" href="#doc-zip-eocd">#</a> <code>zip_eocd</code></h3>
<p><code>zip_eocd</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = zip_eocd $x
# or in a pipeline:
@list |> map zip_eocd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-fill">
<h3><a class="doc-anchor" href="#doc-zip-fill">#</a> <code>zip_fill</code></h3>
<p><code>zip_fill</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = zip_fill $x
# or in a pipeline:
@list |> map zip_fill |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-local-header">
<h3><a class="doc-anchor" href="#doc-zip-local-header">#</a> <code>zip_local_header</code></h3>
<p><code>zip_local_header</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = zip_local_header $x
# or in a pipeline:
@list |> map zip_local_header |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-with">
<h3><a class="doc-anchor" href="#doc-zip-with">#</a> <code>zip_with</code></h3>
<p><code>zip_with</code> — functional / iterator builtin. Alias for <code>take_while</code>.</p>
<pre><code class="lang-perl">my $result = zip_with $x
# or in a pipeline:
@list |> map zip_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zipf">
<h3><a class="doc-anchor" href="#doc-zipf">#</a> <code>zipf</code></h3>
<p><code>zipf</code> — python/ruby stdlib builtin. Alias for <code>zip_fill</code>.</p>
<pre><code class="lang-perl">my $result = zipf $x
# or in a pipeline:
@list |> map zipf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zipl">
<h3><a class="doc-anchor" href="#doc-zipl">#</a> <code>zipl</code></h3>
<p><code>zipl</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = zipl $x
# or in a pipeline:
@list |> map zipl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zipmap">
<h3><a class="doc-anchor" href="#doc-zipmap">#</a> <code>zipmap</code></h3>
<p><code>zipmap</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = zipmap $x
# or in a pipeline:
@list |> map zipmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ziv-lempel-estimate">
<h3><a class="doc-anchor" href="#doc-ziv-lempel-estimate">#</a> <code>ziv_lempel_estimate</code></h3>
<p><code>ziv_lempel_estimate</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = ziv_lempel_estimate $x
# or in a pipeline:
@list |> map ziv_lempel_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zlexcount">
<h3><a class="doc-anchor" href="#doc-zlexcount">#</a> <code>zlexcount</code></h3>
<p><code>zlexcount</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zlexcount $x
# or in a pipeline:
@list |> map zlexcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zpk2sos-step">
<h3><a class="doc-anchor" href="#doc-zpk2sos-step">#</a> <code>zpk2sos_step</code></h3>
<p><code>zpk2sos_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = zpk2sos_step $x
# or in a pipeline:
@list |> map zpk2sos_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zpk2tf-step">
<h3><a class="doc-anchor" href="#doc-zpk2tf-step">#</a> <code>zpk2tf_step</code></h3>
<p><code>zpk2tf_step</code> — batch 74 builtin.</p>
<pre><code class="lang-perl">my $result = zpk2tf_step $x
# or in a pipeline:
@list |> map zpk2tf_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zrangebyscore">
<h3><a class="doc-anchor" href="#doc-zrangebyscore">#</a> <code>zrangebyscore</code></h3>
<p><code>zrangebyscore</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zrangebyscore $x
# or in a pipeline:
@list |> map zrangebyscore |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zrank">
<h3><a class="doc-anchor" href="#doc-zrank">#</a> <code>zrank</code></h3>
<p><code>zrank</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zrank $x
# or in a pipeline:
@list |> map zrank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zrem">
<h3><a class="doc-anchor" href="#doc-zrem">#</a> <code>zrem</code></h3>
<p><code>zrem</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zrem $x
# or in a pipeline:
@list |> map zrem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zrevrank">
<h3><a class="doc-anchor" href="#doc-zrevrank">#</a> <code>zrevrank</code></h3>
<p><code>zrevrank</code> — batch 71 builtin.</p>
<pre><code class="lang-perl">my $result = zrevrank $x
# or in a pipeline:
@list |> map zrevrank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zrlc">
<h3><a class="doc-anchor" href="#doc-zrlc">#</a> <code>zrlc</code></h3>
<p><code>zrlc</code> — physics formulas builtin. Alias for <code>impedance_rlc</code>.</p>
<pre><code class="lang-perl">my $result = zrlc $x
# or in a pipeline:
@list |> map zrlc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zscore">
<h3><a class="doc-anchor" href="#doc-zscore">#</a> <code>zscore</code></h3>
<p><code>zscore</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = zscore $x
# or in a pipeline:
@list |> map zscore |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zscore-count">
<h3><a class="doc-anchor" href="#doc-zscore-count">#</a> <code>zscore_count</code></h3>
<p><code>zscore_count</code> — batch 33 builtin.</p>
<pre><code class="lang-perl">my $result = zscore_count $x
# or in a pipeline:
@list |> map zscore_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zscore-norm">
<h3><a class="doc-anchor" href="#doc-zscore-norm">#</a> <code>zscore_norm</code></h3>
<p><code>zscore_norm</code> — batch 27 builtin.</p>
<pre><code class="lang-perl">my $result = zscore_norm $x
# or in a pipeline:
@list |> map zscore_norm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zscores">
<h3><a class="doc-anchor" href="#doc-zscores">#</a> <code>zscores</code></h3>
<p><code>zscores</code> — statistics (extended) builtin. Alias for <code>z_scores</code>.</p>
<pre><code class="lang-perl">my $result = zscores $x
# or in a pipeline:
@list |> map zscores |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zst">
<h3><a class="doc-anchor" href="#doc-zst">#</a> <code>zst</code></h3>
<p><code>zst</code> — crypto / encoding builtin. Alias for <code>zstd</code>.</p>
<pre><code class="lang-perl">my $result = zst $x
# or in a pipeline:
@list |> map zst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zstd-encode-step">
<h3><a class="doc-anchor" href="#doc-zstd-encode-step">#</a> <code>zstd_encode_step</code></h3>
<p><code>zstd_encode_step</code> — batch 81 builtin.</p>
<pre><code class="lang-perl">my $result = zstd_encode_step $x
# or in a pipeline:
@list |> map zstd_encode_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zstd-frame-header">
<h3><a class="doc-anchor" href="#doc-zstd-frame-header">#</a> <code>zstd_frame_header</code></h3>
<p><code>zstd_frame_header</code> — batch 62 builtin.</p>
<pre><code class="lang-perl">my $result = zstd_frame_header $x
# or in a pipeline:
@list |> map zstd_frame_header |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zstd-window-size-log">
<h3><a class="doc-anchor" href="#doc-zstd-window-size-log">#</a> <code>zstd_window_size_log</code></h3>
<p><code>zstd_window_size_log</code> — batch 40 builtin.</p>
<pre><code class="lang-perl">my $result = zstd_window_size_log $x
# or in a pipeline:
@list |> map zstd_window_size_log |> p
</code></pre>
</article>
</section>
</main>
</div>
<script src="hud-theme.js"></script>
</body>
</html>